What does it cost to run one invoice through a language model? The PLN bill for 1 000 documents a month

The text of an invoice run through a language model costs between about PLN 0.05 and PLN 0.14 in model fees. That is what the example below comes to: one PDF invoice, its data read, one retry, one check of the result, three models from OpenAI, Anthropic and Google, prices read from the providers’ pages on 12 October 2026 and converted at the NBP mid rate. At 1 000 invoices a month that is between about PLN 51 and about PLN 137 net. That estimate excludes reasoning tokens, which we come to below: two of the three models always add them, so the total cost has to be measured.

That number is needed, but it is usually the smaller part of the bill for an automation. I say so up front because it is easy to choose a model as if it were the largest cost. It usually is not: the cost of a project is driven by integrations with your systems, the state of your data and the level of confidence required, which we set out in the article on what AI implementation costs. This article supplies the number missing there: the unit cost, meaning what you pay the model provider for one document.

Two terms before we start. An API is access to the model for a program rather than for a person in a chat window — through the API, the automation sends the document to the model and receives the result on its own. A token is a piece of text, roughly part of a word; providers charge in tokens, separately for text sent to the model (input) and text the model writes (output).

What exactly we are costing

We cost one document from input to result, the way it passes through the automation described step by step in our n8n guide (the section on an invoice from an email to the accounting system). Each document takes three requests to the model:

1. Reading. The model receives instructions describing the fields (number, dates, tax IDs, line items, amounts, payment due date) plus the text of the document, and returns the data as named fields and values (JSON format). Translating them into the accounting system’s format is the integration’s job, not the model’s.
2. Retry. We assume that every document has to go through a second time — because the totals did not add up, say. In practice this applies to only some documents; we take the cautious case so as not to understate the bill.
3. Check. A separate request compares the extracted data with the document and points out any differences.

At the end a person approves the result before anything is posted. That is our assumption throughout: the model prepares the data, and the responsible person decides on posting.

We cost two documents: a supplier invoice in PDF format with five line items and an order sent by email with four. Both are illustrative and made up for this article — company names, tax IDs and the bank account number are placeholders — but they have the length and shape of typical documents of their kind.

One caveat that changes the bill more than the choice of model. Domestic invoices between businesses in Poland that fall under mandatory KSeF (the National e-Invoicing System) arrive through it as data in an XML file — a structured data file, not a picture of the invoice — and no model is needed to read them. The model reads what arrives outside KSeF: foreign invoices, receipts, documents from sellers who may still invoice outside the system (until 31 December 2026 taxpayers may do so while the VAT-inclusive total of the invoices they would otherwise have to issue in KSeF does not exceed PLN 10 000 a month), and orders in emails. Until the end of 2026, cash-register invoices and receipts with the buyer’s tax number that count as simplified invoices may also be issued outside KSeF. These are examples, not a full list: the law provides more exceptions to KSeF. How much of that there is, and what is left for AI with KSeF invoices, we covered in KSeF and accounting automation.

How many tokens one invoice has

We counted the tokens rather than guessing them: with a tokenizer — a program that splits text into tokens the way a model does — called o200k_base, from OpenAI’s open tiktoken library (version 0.14.0), which the library assigns to GPT-5 models. This is not a measurement of the three chosen models: each of them may split the same text a little differently.

How the invoice total follows from the table: reading is 571 + 572 input tokens and 471 output, the retry the same again, and the check receives the instructions, the invoice and the extracted data (112 + 572 + 471 input) and returns a verdict (100 output). In total 3 441 input tokens and 1 042 output tokens. For the order we assumed instructions of the same length as for the invoice; that gives 2 525 and 614.

For the calculation we double these figures and round up: 7 000 input and 2 100 output tokens per invoice, 5 100 and 1 300 per order. This is our planning assumption, not a verified upper bound. The reasoning: different models split the same Polish text into clearly different numbers of tokens. In Promptowy.com’s August 2026 measurement, Claude Fable 5 counted a Polish text at 363 tokens and GPT-5.6 Terra counted the same text at 239. Anthropic itself states that its models from version 4.7 onwards use a new tokenizer that produces about 30% more tokens from the same text. The same Promptowy.com measurement also showed that Polish text produces between 40 and 111 percent more tokens than English — which explains why Polish documents cost more, but our measurement is already of Polish text. You can estimate the input for your own documents with a tool that counts tokens for the specific model (Anthropic and Google offer token counting through the API); a general counter such as iletokenow.pl gives an approximation. Only the usage recorded in the responses to every request concerning a document shows its actual cost.

If you send the model an image of a scan or the whole PDF file instead of text, the token count is different and has to be measured separately. Our example assumes the text is extracted from the PDF before it is sent to the model, as in the n8n guide.

Price lists for three models (as of 12 October 2026)

From OpenAI and Anthropic we chose a model from the middle of the range — neither the cheapest nor the most expensive. Google’s counterpart is Gemini 3.8 Flash, which sits between the cheaper Flash-Lite and the more expensive Pro in its price list, but is clearly cheaper than the other two. This is not a quality comparison: before choosing a model, check on your own documents that it reads them equally well.

Prices are in dollars per million tokens, excluding VAT, for the standard mode; batch mode is 50% cheaper with all three (the result comes later). We convert at the NBP mid rate of PLN 3.9022 to the dollar (table A no. 197/A/NBP/2026 of 9 October 2026, the last published before we read the price lists).

Check again when: a provider changes its price list, the dollar moves by more than a few percent, a provider releases a new model version, or 1 January 2027 passes — Google then doubles the price of Gemini 3.8 Flash.

We read the prices from the OpenAI, Anthropic and Google (Gemini API) price lists; the full list of sources is at the end. The providers quote prices in dollars; the złoty amounts below are our conversion at the stated NBP rate, net. Agree the VAT treatment of a foreign service with your accountant.

The bill: one invoice and one order

How to work it out yourself, using the invoice and GPT-6.1 Sol: 7 000 input tokens × $2 / 1 000 000 = $0.014, plus 2 100 output tokens × $10 / 1 000 000 = $0.021. Total $0.035, which at 3.9022 is about PLN 0.137. Output costs five times as much as input, so the length of the model’s answer weighs more in the bill than the length of the document.

These amounts exclude reasoning tokens (described below) — they are an estimate for text tokens only. On GPT-6.1 Sol and Gemini 3.8 Flash reasoning cannot be switched off, so at the assumed token counts it adds to the bill; on Claude Sonnet 5.5 up-front reasoning can be switched off. Measure the total cost on the chosen model. Add reasoning tokens to the output in this estimate. When calculating the actual cost, check whether the output token count in the API response already includes them, and count them only once.

300, 1 000 and 5 000 documents a month

We calculate the monthly amounts from the cost per document before rounding (PLN 0.136577, for example), so they may differ by a złoty or two from multiplying the table above.

Invoices, PLN net per month, excluding reasoning tokens:

Orders, PLN net per month, excluding reasoning tokens:

If all three requests go through batch mode, each of these amounts halves. Bear in mind that batch mode comes with a delay: OpenAI and Anthropic state up to 24 hours per batch, and reading, retry and check run one after another, so the whole cycle may take more than a day. The tables show the cautious case — with every document retried and the token count doubled, but without reasoning tokens.

What raises the bill, and what the price list does not show

• Reasoning tokens. Models “think” before answering, and that invisible text is charged as output, at the most expensive rate — OpenAI, Anthropic and Google all say so plainly in their documentation. On GPT-6.1 Sol and Gemini 3.8 Flash reasoning cannot be switched off: the lowest available level is “low” and the default is “medium”. On Claude Sonnet 5.5 thinking is on by default, but up-front reasoning can be switched off with the between_tools setting; for the requests described here, without tools, the response then contains only text. OpenAI notes there can be anywhere from a few hundred to tens of thousands of such tokens per request. At 3 000 such tokens on each of the three requests, that is 9 000 more output tokens: 9 000 × $10 / 1 000 000 = $0.09, about PLN 0.35, so an invoice on GPT-6.1 Sol would cost about PLN 0.49 instead of PLN 0.137. We did not measure how many reasoning tokens reading an invoice actually uses — that is a figure to check in a pilot. Deep reasoning is usually not needed to read an invoice; choose the lowest level at which the results on your documents meet agreed accuracy criteria, and check in the returned data how many tokens were actually used.
• The whole email thread instead of one document. If the automation sends the model the entire correspondence, with signatures and quoted earlier messages, the input grows considerably. Send only what the model needs to read.
• The agent loop. An AI agent — a program that decides its own next steps and acts in your systems — asks the model many times per task. You then count tokens per task, not per request; we set this out in the article on what an AI agent costs.
• Where the data is processed. For Gemini 3.8 Flash on Vertex AI, Google charges 10% more for processing in a specific region (in the European Union, for example) than for global processing, and OpenAI adds 10% for processing with a chosen data location (data residency). Anthropic charges 1.1 times the rate for US-only processing — an option for companies that need the US, not the EU. Where invoice data may end up is first a GDPR question (the EU General Data Protection Regulation) and only then a price question — we cover it in GDPR and LLM implementation.
• Retesting after a model version change. Providers retire older versions; the automation is moved to the new one and checked again. That is mainly people’s time to prepare and assess the tests, though the test requests to the model cost money too.

A per-person subscription or the API: the sums for a company

The comparison people make most often goes like this: number of people × subscription price versus number of documents × cost per document. A standard seat in the Claude Team subscription costs $20 per person a month billed annually and $25 billed monthly — about PLN 78 or 98 net. Ten people in the finance department come to about PLN 780–980 net a month. A thousand invoices through the API come to PLN 51–137 net in our example, excluding reasoning tokens.

Comparing fees alone, ten such seats cost as much as about 5 700 invoices a month through GPT-6.1 Sol or Claude Sonnet 5.5 on annual billing (about 7 100 on monthly billing) — on the same assumptions, excluding reasoning tokens. That figure is only a reference point, not a break-even threshold, because the two are not substitutes. If the subscription is used for manual work in the chat, an employee opens the invoice, pastes it in, checks the result and moves it into the system. The API gives model access to an automation that has to be built and connected to the mailbox and the accounting system: the document goes to the model, the data to the system, and a person checks and approves the prepared result instead of retyping it. The real calculation is therefore the cost of building and maintaining the automation against the minutes of work saved on each document — and model fees are the smaller item in it.

One caveat for companies that already have Claude Team: according to Anthropic’s documentation, the subscription includes monthly Claude API credits — $20 for each standard seat, pooled up to $500, with unused credits expiring at the end of each billing cycle. Ten standard seats give $200, about PLN 780 a month — in our example, as much as about 5 700 invoices on Claude Sonnet 5.5 excluding reasoning tokens, assuming the full balance is available for this automation (other eligible uses draw from the same balance). With such a subscription the extra API bill may therefore be small or zero. The credits have to be claimed by linking an organisation in the Claude console (new subscribers after seven days), and they cover the Claude API but not, for example, Claude on Vertex AI; check the conditions in the documentation.

How to cap spending — four settings for the finance director

1. A monthly spending limit. OpenAI lets you set a monthly spend limit for the organisation and for individual projects, with alerts or with requests blocked once it is reached, but warns that the block does not take effect instantly, so recorded spend can slightly exceed the set amount — it is not a guaranteed immediate cut-off. Anthropic has spending limits and notifications for each workspace in the Claude console. In the Gemini API, Google itself assigns the billing account a monthly cap that depends on its usage tier (you can request a higher one), while you set the monthly project cap yourself; neither cap is available for accounts on monthly invoiced billing (Invoiced/Offline). Google describes the project cap as experimental: billing data can be delayed by about 10 minutes, and long-running tasks such as batch jobs can exceed the cap. Put the invoice automation in its own project or workspace (depending on the provider), with its own access key, so you can track its cost and apply whichever limits, restrictions or notifications that provider offers. An account-wide limit still applies to every project.
2. A cap on answer length. Every request can carry a maximum number of output tokens (max_output_tokens at OpenAI, max_tokens at Anthropic). Reading an invoice has a predictable length, so the cap protects against an answer that for some reason never ends. A caveat: at OpenAI this cap also covers reasoning tokens, so too low a value can cut the answer off before any result appears — and you still pay for the tokens used.
3. Batch mode for documents that can wait. All three providers give a 50% discount if the result can come later; halving the whole bill requires all three requests to go through batch mode. Supplier invoices rarely need posting within a minute, so a day’s batch can be sent in the evening — bearing in mind that reading, retry and check run one after another and the result may only be ready after more than a day.
4. Cost per document as a number in the report. The API response reports the number of tokens used. For every request connected with a document (reading, retry and check), record every billed category: input, output, cache reads and writes if you use prompt caching, and reasoning where the provider reports it separately — each counted once at its own price-list rate. Account for cache storage separately where the provider charges for it (on Gemini it depends on the number of tokens and how long they are stored), and split it across the documents that used the cache without counting the same charge twice. Show the cost per document every month next to the number of documents, checking the total against the model provider’s invoice. A sudden rise usually means something changed: longer documents, more retries or a new model version.

When this bill does not matter

At 300 invoices a month the model fee in our example comes to about PLN 15–41 (excluding reasoning tokens). At that volume the more important question is whether the automation pays for itself at all — and integrations and people’s time answer that. In the KSeF article we assumed an illustrative fully loaded hourly cost of PLN 90; on that assumption one minute spent checking a document costs PLN 1.50, more than any of the three models in our example charges for processing ten invoices (on the table’s assumptions, excluding reasoning tokens). Since a person approves every result anyway, the model fee rarely settles whether the automation makes sense.

The token bill starts to weigh at large volumes, for agents that ask the model many times per task, for models that use many reasoning tokens, or for long documents such as contracts. That is when it is worth comparing models on your own documents and your own figures.

What next

How automating the flow of accounting documents from the mailbox to the system works is described on our accounting automation page, and how an automation project runs from choosing the process to maintenance on the AI automation for business page. We cost the model during the pilot, on the client’s documents, not on an example from an article.

Tell us how many documents reach your company each month, and from where. We will tell you whether at that volume they are worth automating — including when the answer is “not yet”.

Sources, as of 12–13 October 2026

• OpenAI — API pricing (detailed) and API pricing for business — GPT-6.1 Sol, GPT-6 Astra, GPT-6 Luna, batch mode, data-residency surcharge; read 12 October 2026; OpenAI — spend limits — organisation and project limits, enforcement not instantaneous; read 13 October 2026.
• OpenAI — reasoning models — reasoning tokens billed as output, max_output_tokens; OpenAI — GPT-6.1 Sol model — reasoning levels from “low” (no “none” or “minimal”), default “medium”; OpenAI — batch mode; read 12 October 2026.
• Anthropic — Claude API pricing and Claude pricing — Claude Sonnet 5.5, Opus 5.5, Haiku 5.5, batch mode, the new tokenizer from version 4.7, the Team subscription; monthly API credits for Max and Team plans; read 12 October 2026.
• Anthropic — workspaces and spending limits, batch processing, token counting and Claude thinking — on Claude Sonnet 5.5 thinking is on by default, up-front reasoning switched off with between_tools; read 12 October 2026.
• Google — Gemini API pricing — Gemini 3.8 Flash, Flash-Lite and Pro, the price until 31 December 2026 and from 1 January 2027, reasoning tokens in the output price, batch mode; page updated 9 October 2026, read 12 October 2026.
• Google Cloud — Vertex AI pricing — regional processing surcharge; Gemini API — billing and spend caps and token counting; Gemini API — thinking — on Gemini 3.8 Flash the default is “medium”, with “low”, “medium” and “high” available; read 12 October 2026 (billing page re-read 13 October 2026: tier-based account cap, project cap, Invoiced/Offline accounts).
• KSeF — “Poniżej 10 000 zł” (in Polish) — the limit includes VAT and counts only invoices that must be issued in KSeF; read 12 October 2026; KSeF — scope of mandatory KSeF (in Polish) — exclusions from KSeF, cash-register invoices and receipts with a tax number until the end of 2026; read 13 October 2026.
• NBP — US dollar mid rate, table A no. 197/A/NBP/2026 of 9 October 2026 — PLN 3.9022; NBP exchange-rate tables.
• Promptowy.com, “Polski podatek tokenowy” (21 August 2026, measurements of 14 August) and “Ile tokenów ma polski tekst” (in Polish) — differences in the token count of Polish text between models; read 12 October 2026.
• iletokenow.pl — a token counter for Polish text (in Polish).
• tiktoken (OpenAI), version 0.14.0 — the o200k_base tokenizer used to measure the example documents on 12 October 2026.