AI Agent Cost Per Document: $52.00 of Tokens and $325.00 of Hours

14 min read
AI Agent Cost Per Document: $52.00 of Tokens and $325.00 of Hours

One extraction task, 2,000 documents, one model call each. At the list prices both Anthropic and OpenAI published on their own pages on 2026-11-06, that run costs $52.00, which is 2.6 cents a document. Add a retry loop that runs one call in five a second time and it is $62.40. Serve the shared prompt prefix from cache instead of paying full price for it 2,400 times and the same work is $35.34, or 1.77 cents a document.

Then add the step that rarely appears in a quote. Send one document in twenty to a person for three minutes of checking, at the $65 an hour blend from our published rate band, and that is $325.00. It is 9.2 times the entire cached token bill, and it is not a token price at all.

That is the shape of the answer: the tokens are cents and the hours are hundreds.

The 2,000 documents are an example. They are not a client's volume and not anybody's volume, and every assumption behind the figures is listed and labelled below. The prices are list prices, read from both providers' own pricing pages on 2026-11-06, and they will change. The arithmetic will not. That is why this post shows the arithmetic and dates the prices separately, and why the thing to rebuild when a price moves is the price card, not the post.

Where the $52.00 comes from

$52.00 for 2,000 documents, or 2.6 cents each, assuming 8,000 input tokens and 1,000 output tokens per document at $2.00 per million in and $10.00 per million out. That is 16.0 million input tokens for $32.00 and 2.0 million output tokens for $20.00. Nothing else is in that number.

Here is every assumption, so you can change one and redo it yourself.

Assumption

Value

documents (example volume, not a client's)

2,000

shared prompt prefix per call: instructions, schema, examples

6,000 tokens

the document itself per call

2,000 tokens

what the model writes per call

1,000 tokens

retry rate (assumed)

1 call in 5 fails validation and runs once more

low confidence review rate (assumed)

1 document in 20

review time per document (assumed)

3 minutes

the same work by hand (assumed)

6 minutes per document

one time build (assumed)

120 engineering hours

rate

$65 per hour blended, from our published $40 to $100 band

And the run:

input   2,000 x 8,000 = 16,000,000 tok = 16.0 MTok x $2.00  = $32.00
output  2,000 x 1,000 =  2,000,000 tok =  2.0 MTok x $10.00 = $20.00
                                                     total  = $52.00

Two thirds of the input is the same 6,000 tokens, sent 2,000 times. The instructions, the output schema, the few examples you pasted in to make the extraction behave: identical on every call, paid for on every call. If the agent also has tools, their definitions live in that prefix too, and the way tool definitions are declared decides how many tokens they occupy on every single call. Hold that thought, because the prefix is the only part of this bill with a cheap fix.

Put $52.00 next to something you already price in hours. At $65 it is 48 minutes of engineering time. That is the real register of a token bill on a task this size, and it is why the interesting question is never "what do the tokens cost".

How much does it cost to process a document with AI?

On this example, between 1.77 cents and 3.12 cents a document in tokens, and 16.25 cents a document once a three minute human check on one document in twenty is included. Tokens scale with how much text you read and write. Review scales with your error tolerance, and it is priced in hours.

Those two sentences point in opposite directions. Token cost is a function of your prompt design. Review cost is a function of your accuracy requirement, which is a business decision nobody can make for you. We take the second apart in what a page actually costs to read, which treats accuracy as a cost rather than a specification and is the better read if your documents are scanned, handwritten or full of tables.

If your document is a clean digital PDF of predictable length, the arithmetic above transfers with the token counts swapped. If it is a 60 page contract, scale the 2,000 token figure and watch the input column, because input grows with document size while output barely moves.

One cost sits just outside this arithmetic and belongs in the same budget: where the extracted fields go, and whether the original file stays indexed and searchable. That is a storage decision rather than a token one, and how an AI document management system is put together covers it.

The retry loop costs exactly what it looks like

Validation failures are normal. The model returns a field in the wrong shape, misses a required key, or hallucinates a date format, and your code sends the call again. Assume one call in five does that once, and 2,000 documents becomes 2,400 calls.

input   2,400 x 8,000 = 19.2 MTok x $2.00  = $38.40
output  2,400 x 1,000 =  2.4 MTok x $10.00 = $24.00
                                    total  = $62.40

$62.40, or 3.12 cents a document. Twenty per cent more calls, twenty per cent more money. There is no discount for a second attempt and no penalty either. This is the most predictable line in the whole budget, which makes it the one worth asking about first: what is the measured validation failure rate on a real sample, and does the loop have a ceiling?

A loop with no ceiling is the only version of this that can surprise you. If a malformed document can fail validation forever, the cost of that document is unbounded and your run has a tail you cannot predict. Cap the attempts, log the ones that hit the cap, and route them to a person. That is a two line change at build time and an incident at three in the morning if you skip it.

The cap has a security reason as well as a financial one. A document is input you did not write, and text inside it can be crafted to change what your agent does next, a failure mode with its own defences: see prompt injection in an agent that reads untrusted files.

Note what the retry does to your options. A synchronous loop that reacts to a validation result cannot be submitted to a batch endpoint, which closes a door we come back to below. If your extraction does not need a loop, an agent built around a queue rather than a conversation is a different and usually cheaper animal.

The cache hit, with the write included

That 6,000 token prefix is the same on every call, so stop paying full price. Both providers priced a cache hit at $0.10 per million on 2026-11-06, a twentieth of the $2.00 base input price, and Anthropic's own documentation states the rule in words as well as in a table: a cache hit costs five per cent of the standard input price.

The same 2,400 calls, with the prefix served from cache:

cache hits   2,400 x 6,000 = 14.4 MTok x $0.10  =  $1.44
fresh input  2,400 x 2,000 =  4.8 MTok x $2.00  =  $9.60
cache writes    20 x 6,000 = 0.12 MTok x $2.50  =  $0.30
output                       2.4 MTok x $10.00  = $24.00
                                          total = $35.34

$35.34, or 1.77 cents a document. The 14.4 million tokens that cost $28.80 at base input price cost $1.44 as cache hits.

The $0.30 of cache writes is in that total on purpose. A write costs $2.50 per million on a five minute cache, so the prefix is written again once per five minute window: assume a 100 minute run and that is 20 writes. Leaving it out would flatter the cached number by exactly the amount that makes a worked example untrustworthy. If a vendor shows you a cached price with no write line, ask where it went.

Both figures go on the page: $62.40 and $35.34, same 2,000 documents, same work, same output. The difference is $27.06. We are deliberately not turning that into a percentage, because a percentage reads as a result and these are two arithmetic outputs of one made up example. Do the subtraction with your own token counts and you will get a different number, which is the point.

Caching is the first lever on almost any repetitive model workload and not the only one. Routing cheap requests to cheap models, trimming output length and batching anything nobody waits on all do work here, and token economics for a product that ships goes through each.

A cost breakdown comparing the base run, the retry run and the cached run for 2,000 documents, with the cache write line shown separately.

The $325.00 that is not a token price

Now the number that changes the conversation.

Assume your extraction flags one document in twenty as low confidence and a person spends three minutes checking each. That is 100 documents, 300 minutes, five hours.

2,000 / 20 = 100 documents
100 x 3 min = 300 min = 5.00 hours
5.00 x $65  = $325.00

$325.00, or 16.25 cents a document. Against the cached token bill of $35.34, that is 9.2 times as much.

The biggest number in an agent loop's cost is priced in hours, and it is the one token calculators cannot see. Every assumption in it is a business choice. Review one document in ten instead of one in twenty and it doubles. Cut the check from three minutes to ninety seconds with a better review interface and it halves. Decide the task tolerates no review and it disappears, along with your ability to say what the error rate is.

That last option is free in the budget and expensive everywhere else. The honest way to set a review rate is to measure how often the extraction is wrong on real documents first, which is its own piece of work: what to measure before you ship an agent covers how it gets built.

A second hours cost hides next to this one. Someone has to see the flagged documents, which means an interface, a queue and a record of who decided what. None of that is in the $325.00 and all of it is in the build. A review queue is the clearest example of the work separating a demo from a system, which is the subject of why AI pilots do not reach production.

Is it cheaper to use an AI agent or to pay someone to do it?

Below roughly 1,234 documents, paying someone is cheaper. Above it, the agent is. On this example, doing the work by hand costs $6.50 a document at six minutes and $65 an hour, the agent route costs a one time build of $7,800 plus $0.1802 a document, and $7,800 divided by the $6.3198 difference is 1,234.21 documents.

$7,800 / ($6.50 - $0.1802) = 1,234.21 documents

So the lines cross near 1,234 documents, and the agent route first becomes the cheaper of the two at the 1,235th document. At exactly 1,234 the manual route is still $1.40 ahead, which is why the right way to say this is "crosses near 1,234" rather than "at 1,234".

At the example's 2,000 documents: $8,160.34 for the agent route against $13,000 by hand.

Two things about that crossing point are worth more than the number itself. The first is that it is dominated by the build, not by the tokens. The $0.0177 of tokens per document is a rounding error inside the $0.1802; the review is almost all of the per document figure, and the 120 hour build is almost all of the decision. If you want to move the crossing point, change the build scope or the review rate. Nothing you do to the prompt will reach it. Build scope is its own subject, and what an AI agent costs to build treats it properly.

The second is that a one time build and a per document cost are different kinds of commitment, and the crossing point quietly assumes you will reach the volume. A 120 hour build amortised over 400 documents is a bad trade however good the agent is.

One warning about scaling the design rather than the volume. Splitting the task across cooperating agents multiplies the call count and the token bill with it, so a multi agent design has to earn those calls on accuracy. For field extraction over a known document type, one call and a validator is usually the whole correct answer.

The crossing point barely moves across the rate band

This is the part a reader can check by hand in a minute, and it is the strongest thing on the page.

Our published rate band is $40 to $100 per hour by role, blending around $65. Run the crossing point arithmetic at both ends of it. Every hour priced term scales with the rate: the manual cost per document, the build, and the review. Only the token bill does not, and it is too small to matter.

Rate

Manual per doc

Build

Review total

Agent per doc

Crossing point

$40

$4.00

$4,800

$200.00

$0.1177

1,236.4 docs

$65

$6.50

$7,800

$325.00

$0.1802

1,234.2 docs

$100

$10.00

$12,000

$500.00

$0.2677

1,233.0 docs

Across the whole $40 to $100 band, the crossing point moves by three documents. From 1,236 to 1,233.

Sit with that for a second, because it says something uncomfortable about how these decisions usually get made. The hourly rate is the thing most buyers negotiate hardest and the thing most vendor comparisons are built on, and on this question it is nearly irrelevant. Halve the rate and the build gets cheaper, but so does the manual alternative you are comparing it against, and the two effects cancel almost exactly. What actually moves the answer is the volume, the manual minutes per document and the review rate.

So the rate is the wrong negotiation. The right ones are: how many documents, really, in a year; how long does this genuinely take a person today, measured rather than remembered; and what fraction has to be checked.

An invitation to discuss document extraction cost arithmetic with the Zyneto team.

Why the 50% batch discount is not on this page

Both providers publish a Batch API that discounts input and output tokens by half for work submitted asynchronously. Anthropic's documentation states it as a fifty per cent discount on both input and output tokens. It is real, it is on both pricing pages, and it is not in any figure above.

The reason is the retry loop. The worked example is a synchronous loop that reads a validation result and decides whether to call again, and a loop shaped like that cannot run through a batch endpoint, which takes a set of requests and returns them later. Quoting a batch price for it would be a wrong number dressed up as a cheaper one. Anthropic's documentation also notes that fast mode is not available with the Batch API, which is a second reason not to mix the two registers in one estimate.

If your extraction can tolerate waiting, batch it and halve the token line. That is a large lever and the first thing to check about any bulk document job, because most are not urgent. What you cannot do is take a figure computed for a loop and apply a discount the loop is ineligible for, and that substitution is common enough in published AI cost tables to be worth spotting.

Two other published prices are absent for the same kind of reason. Fast mode and ultrafast tiers are real and irrelevant to a bulk run nobody is waiting on. And one provider's cheaper previous generation model carries a promotional price with a stated end date of 30 November 2026, under four weeks after these prices were read, so it is not on the card either: a price with weeks to live does not belong in a budget.

A third lever gets proposed here and usually should not be: training your own model so the prompt can be shorter. It converts token cost into a fixed cost plus a retraining obligation, and on a $35.34 run there is nothing to win. See fine tuning against retrieval.

A diagram showing where each cost sits in a document extraction loop: prefix tokens, document tokens, output tokens, retry, cache write and the human review queue.

The price card is the part that dates

This post has a shelf life and it is worth being blunt about which part.

Neither provider prints an effective date on its pricing page. Anthropic's public page says only that pricing and plans are subject to change at its discretion. OpenAI's page carries four dated notes, none of which touches the three figures used here. So there is no published date to cite, which is exactly why every price above carries the date it was read instead: $2.00 in, $10.00 out, $0.10 cached per million tokens, read from Anthropic's own pricing pages and OpenAI's own pricing page on 2026-11-06.

The coincidence is real and it was checked. Two providers published the same three prices at this tier on the same day, which is why the arithmetic is done once without picking a side, and why no model is recommended here: both are named only as the source of a published price.

When the prices move, rebuild the price card and leave the rest alone. The three levers, the 9.2 times ratio between review and tokens, and the stability of the crossing point across the rate band are structural. They are properties of a shape where the token terms are small and the hour terms are large, and that shape survives a price change in either direction. If every token price halved tomorrow, the cached run would be $17.67 and the review step would be 18.4 times it rather than 9.2, so the argument strengthens.

The same test applies to anything you are shown. A cost table with no read date on it is not a cost table, it is a screenshot of one, and the only way to know whether it is current is to open the provider's page yourself. That takes a minute.

An invitation to start a scoping conversation about a document extraction agent.

What to ask for before anyone builds this

Five questions, in the order they change the budget.

What is the real annual volume? Not the backlog, not the aspiration. The crossing point above sits near 1,234 documents on these assumptions, and the single fastest way to lose money here is to build for 2,000 documents a month and receive 200.

How long does this take a person today, measured? The six minutes in the example is an assumption, and it does more work in the crossing point than any technical number. Time it on twenty real documents before anyone quotes anything.

What fraction has to be checked, and by whom? This is the $325.00, the largest recurring line, and unlike the build it never ends.

How many tokens is a real document, and how big is the prefix? Open a representative file and count. If your prefix is 500 tokens rather than 6,000, caching is not your lever and you should stop talking about it.

Can it wait? If yes, the batch endpoint halves the token line. If no, keep the synchronous figures.

None of those five is a technical question, which is the recurring surprise in this kind of commissioning. Model choice is nearly settled for you by two providers publishing identical prices at this tier, and the architecture is well trodden: our AI agent development service page sets out the work, and the cost of building the agent itself dominates the crossing point above. What is not settled is your volume, your tolerance for error and your honesty about the current manual cost, and those three set almost the entire number. The arithmetic here is simple on purpose, because the hard part was never the arithmetic.

Frequently asked questions

On the worked example in this post, 2.6 cents a document in tokens for a plain run of 2,000 documents, 3.12 cents with a retry loop, and 1.77 cents with the retry loop plus a cached prompt prefix. Add a three minute human check on one document in twenty at $65 an hour and the per document figure becomes 18.02 cents, because the review is 16.25 cents of it. Prices are list prices read from Anthropic's and OpenAI's own pages on 2026-11-06.

In this example, 2,400 calls each carrying the same 6,000 token prefix. At the base input price of $2.00 per million those 14.4 million tokens cost $28.80. Served as cache hits at $0.10 per million they cost $1.44, plus $0.30 of cache writes because a five minute cache has to be rewritten once per five minute window. The full run goes from $62.40 to $35.34. Both figures are list prices read on 2026-11-06.

It depends on volume, and on this example the lines cross near 1,234 documents. By hand at six minutes a document and $65 an hour is $6.50 each. The agent route is a one time build of 120 hours, so $7,800, plus 18.02 cents a document for tokens and review. Below about 1,234 documents the manual route is cheaper and above it the agent is. Every input there is a stated assumption, so redo it with yours.

Barely. Across our published $40 to $100 per hour band the crossing point moves from 1,236 documents to 1,233, a total of three documents. Every hour priced term scales together: a lower rate makes the build cheaper and makes the manual alternative cheaper by almost the same proportion. Only the token bill stays fixed, and it is too small to shift the result. Volume, manual minutes per document and review rate all move the answer far more than the rate does.

Because the worked example is a synchronous loop that retries a call when validation fails, and a loop shaped like that cannot run through a batch endpoint, which accepts a set of requests and returns them later. The discount is real and published by both providers. Applying it to a workload that is ineligible for it would produce a cheaper number that is simply wrong. If your extraction can tolerate waiting, use batch and halve the token line.

Nobody knows, because neither provider publishes an effective date. Anthropic's page states only that pricing is subject to change at its discretion, and OpenAI's dated notes do not cover the three figures used here. That is why every price above carries 2026-11-06 as the date it was read. When prices move, rebuild the price card: the three levers, the ratio between review cost and token cost, and the stability of the crossing point across the rate band do not depend on the figures being current.

Hours, not tokens. In this example the human review step is $325.00 against a cached token bill of $35.34, so 9.2 times as much, and the one time build of 120 hours at $65 is $7,800, which is larger than either by two orders of magnitude. Token optimisation is worth doing and will not change your budget. The review rate, the build scope and the real volume will.

Vikas Choudhary

Vikas Choudhary

Vikas has around fifteen years of experience building software and now builds generative AI systems at Zyneto. His work covers retrieval augmented generation, agentic AI, knowledge graphs, AI memory, and the evaluation and guardrails that decide whether any of it is safe to put in front of customers. He has shipped enterprise copilots, document AI, chatbots and predictive analytics for e-commerce, fintech and marketing teams, and works day to day in Python, JavaScript and SQL. He follows multimodal models, business process automation and enterprise AI security closely, and mentors engineers moving into AI. He writes about architecture, inference cost and the failure modes that only show up at production scale.

Zyneto builds custom software, AI and automation

Tell us what you are building and we will reply with a clear next step.

Phone

We reply to every enquiry within one business day.

WhatsApp
Email
Book a Meeting