# What an AI task costs: cost per task for 12 common work tasks, at October 2026 prices

Report · By Nolli research, The Nolli team · Published 2026-10-20 · Updated 2026-10-20 · Prices and features checked 2026-10-19

Canonical page: https://withnolli.com/blog/what-an-ai-task-costs-cost-per-task

**Short answer.** On list prices read on October 19, 2026, a work task costs from about $0.0004 to $0.75 in model fees, depending on tokens and tier. The token counts are our assumptions. In our three worked examples the model fee was 0.1% to 55% of the cost per task. The rest was the cost of people fixing wrong answers.

## Key takeaways

1. On the assumed token counts, the 12 tasks cost from $0.00035 to $0.75 each in model fees, and the $10/$50 tier costs exactly 100 times the $0.10/$0.50 tier for the same tokens.
2. When a wrong answer costs $66 an hour of someone’s time (an assumption), the model fee was between 0.1% and 54.8% of cost per task in our three worked examples, so the cheapest tier is not automatically the cheapest task.
3. A dearer tier pays for itself only if it cuts errors by more than a break-even gap, which was 0.14 to 4.8 percentage points in our three examples; you can only know your own gap by measuring it.

A price list gives a price per million tokens. A manager asks what it costs to answer one support ticket. Between those two sits a guess about how many tokens a ticket takes, and that guess is the whole table below. We made it, we label it as an assumption every time it appears, and nobody should read it as a measurement.

What the table can do is fix the scale. Across 12 common work tasks, the model fee runs from a fraction of a cent to 75 cents. Then comes the part the table cannot show: the cost of a wrong answer, which is a person’s time and is usually larger than the fee. Method first, then the numbers, then what they leave out.

## How we built the table

> **Method.** We took list prices from the Anthropic and OpenAI pricing pages, which Claude read in a real browser on October 19, 2026. Both are standard processing at short context: no cached input, no regional uplift. Three tiers exist on both pages at matching prices, so each pair gets one number: $10 input and $50 output per million tokens (Claude Fable 5.1, gpt-6-astra), $2 and $10 (Claude Sonnet 5.5, gpt-6.1-sol), and $0.10 and $0.50 (Claude Haiku 5.5 for prompts up to 100,000 tokens, gpt-6-luna). Claude Opus 5.5 at $4 and $20 has no matching OpenAI price on the page, so it stays out of the table and is mentioned in the text. We did not read Google’s Gemini pricing, so it is absent. We then picked 12 common tasks and gave each a rough, round count of tokens in and tokens out. Those counts are assumptions: we did not run the tasks, and your documents will differ. Every figure was calculated with a script and re-checked. Prices change, so use the live pages for a decision.

The arithmetic is one line. Model cost = (tokens in × input price + tokens out × output price) ÷ 1,000,000, with prices per million tokens. A 3,000-token ticket with a 200-token answer on the $10/$50 tier is (3,000 × 10 + 200 × 50) ÷ 1,000,000 = $0.04. All 12 tasks stay under 100,000 tokens in, which is the limit for Haiku’s lower price.

Model cost per task / per 1,000 tasks, from list prices read on October 19, 2026 (Anthropic and OpenAI pricing pages, read in a browser). Tokens in and out are our assumptions, rounded. Each column covers two models at the same price: $10/$50 is Claude Fable 5.1 and gpt-6-astra; $2/$10 is Claude Sonnet 5.5 and gpt-6.1-sol; $0.10/$0.50 is Claude Haiku 5.5 and gpt-6-luna. No cached input, one call per task.

| Task | Tokens in / out (assumption) | $10 / $50 tier | $2 / $10 tier | $0.10 / $0.50 tier |
| --- | --- | --- | --- | --- |
| Route a support ticket | 3,000 / 200 | $0.0400 / $40.00 | $0.0080 / $8.00 | $0.00040 / $0.40 |
| Summarize a one-hour meeting | 12,000 / 800 | $0.1600 / $160.00 | $0.0320 / $32.00 | $0.00160 / $1.60 |
| Draft a reply to a customer email | 2,500 / 400 | $0.0450 / $45.00 | $0.0090 / $9.00 | $0.00045 / $0.45 |
| Extract fields from an invoice | 2,000 / 300 | $0.0350 / $35.00 | $0.0070 / $7.00 | $0.00035 / $0.35 |
| Classify 500 survey comments | 21,000 / 4,000 | $0.4100 / $410.00 | $0.0820 / $82.00 | $0.00410 / $4.10 |
| Write a first-draft SQL query | 4,000 / 600 | $0.0700 / $70.00 | $0.0140 / $14.00 | $0.00070 / $0.70 |
| Review a one-page contract clause | 3,000 / 800 | $0.0700 / $70.00 | $0.0140 / $14.00 | $0.00070 / $0.70 |
| Reconcile two revenue figures | 50,000 / 5,000 | $0.7500 / $750.00 | $0.1500 / $150.00 | $0.00750 / $7.50 |
| Summarize a 40-page report | 30,000 / 1,000 | $0.3500 / $350.00 | $0.0700 / $70.00 | $0.00350 / $3.50 |
| Write a job posting | 1,500 / 900 | $0.0600 / $60.00 | $0.0120 / $12.00 | $0.00060 / $0.60 |
| Check an expense line against policy | 4,000 / 200 | $0.0500 / $50.00 | $0.0100 / $10.00 | $0.00050 / $0.50 |
| Prepare a weekly status report | 8,000 / 1,000 | $0.1300 / $130.00 | $0.0260 / $26.00 | $0.00130 / $1.30 |

## What the table says

Two ratios come straight from the price lists. The $10/$50 tier is 100 times the $0.10/$0.50 tier on both input and output, so every row in the first column is exactly 100 times the last. The $2/$10 tier is 20 times the cheapest. Prices are linear in tokens, so the ratios hold for any task, and the only thing that changes the rank of the rows is how many tokens you assume.

Tokens, not task type, drive the cost. Reconciling two revenue figures is the dearest row because we assumed 50,000 tokens in. Extracting fields from an invoice is the cheapest because we assumed 2,000. Output is priced five times higher than input on all three tiers, so a task with a long answer costs more than its token count suggests. Change an assumption and the row moves; that is why the ratios matter more than any single cell.

Claude Opus 5.5, at $4 and $20 per million tokens, sits between the top two tiers. On the same assumed tokens it would cost $0.016 to route a ticket and $0.30 to reconcile the revenue figures, which is 40% of the top tier and twice the $2/$10 tier. We have no matching OpenAI price on the page we read, so it is not in the table.

**Model cost for 1,000 tasks, in dollars. Three tasks, three tiers. Token counts are our assumptions.**

- Route a ticket, $10/$50 tier (assumption): $40.00
- Route a ticket, $2/$10 tier (assumption): $8.00
- Route a ticket, $0.10/$0.50 tier (assumption): $0.40
- Summarize a meeting, $10/$50 tier (assumption): $160.00
- Summarize a meeting, $2/$10 tier (assumption): $32.00
- Summarize a meeting, $0.10/$0.50 tier (assumption): $1.60
- Reconcile revenue figures, $10/$50 tier (assumption): $750.00
- Reconcile revenue figures, $2/$10 tier (assumption): $150.00
- Reconcile revenue figures, $0.10/$0.50 tier (assumption): $7.50

Source: List prices read in a browser on October 19, 2026: Anthropic and OpenAI pricing pages. Tokens: 3,000 in and 200 out; 12,000 and 800; 50,000 and 5,000 (assumptions). Our calculation., https://platform.claude.com/docs/en/about-claude/pricing

Read the bars for scale. A thousand ticket routings on the cheapest tier cost 40 cents. A thousand reconciliations on the dearest cost $750. If your volume is a few hundred tasks a month, neither number will show up in a budget meeting. If it is millions, both will. That is the only honest use of this chart: it tells you when the fee is worth worrying about at all.

## What the table leaves out: the person fixing the answer

Our guide to choosing a model by cost per task defines the number this way: the model cost across every attempt, plus the time people spend reviewing the output and fixing its mistakes. The table above has only the first term.

**Cost per task, in the order the money is spent**

1. **Model cost**: (Tokens in × input price + tokens out × output price) ÷ 1,000,000. The table above.
2. **Retries**: A failed attempt is billed in full. An agent that calls a model four times pays four times.
3. **Review**: Minutes a person spends reading the result, times their hourly cost.
4. **Fixing mistakes**: Error rate × minutes to fix ÷ 60 × hourly cost.
5. **Cost per task**: The sum, for one task done correctly.

Then loop back: A wrong answer sends the task back: fix it or run it again, and pay again

The method in our cost-per-task guide. The worked examples below price the first and last cost terms only. Retries and review are left out, and we assume them equal across tiers.

To see how much the last term can matter, we worked three tasks. The assumptions are loud: the minutes to fix a wrong answer, the error rate on each tier, and the hourly cost of the person fixing it. We use $66 an hour, the rate our guide uses for its examples, which the guide calls illustrative. Microsoft’s Copilot Dashboard uses a different assumed rate, a default of $72 an hour from US Bureau of Labor Statistics data, as we described in our look at adoption analytics tools. Both are placeholders for your own loaded cost. The error rates are numbers we chose to show the arithmetic. They are not benchmark results for any model.

Cost per task = model cost + (error rate × minutes to fix ÷ 60 × hourly cost), at $66 an hour (assumption). Error rates and minutes to fix are assumptions, invented to show the arithmetic, not measured on any model. Model cost uses the assumed tokens in the first table. Retries and review are excluded.

| Task | Tier ($ per million tokens in / out) | Error rate (assumption) | Model cost | Fixing mistakes (assumption) | Cost per task | Model share of cost |
| --- | --- | --- | --- | --- | --- | --- |
| Route a support ticket: fix takes 5 min (assumption), so a wrong answer costs $5.50 | $0.10 / $0.50 | 6% | $0.0004 | $0.3300 | $0.3304 | 0.1% |
| Route a support ticket | $2 / $10 | 4% | $0.0080 | $0.2200 | $0.2280 | 3.5% |
| Route a support ticket | $10 / $50 | 3% | $0.0400 | $0.1650 | $0.2050 | 19.5% |
| Summarize a one-hour meeting: fix takes 3 min (assumption), so a wrong answer costs $3.30 | $0.10 / $0.50 | 8% | $0.0016 | $0.2640 | $0.2656 | 0.6% |
| Summarize a one-hour meeting | $2 / $10 | 5% | $0.0320 | $0.1650 | $0.1970 | 16.2% |
| Summarize a one-hour meeting | $10 / $50 | 4% | $0.1600 | $0.1320 | $0.2920 | 54.8% |
| Reconcile two revenue figures: fix takes 45 min (assumption), so a wrong answer costs $49.50 | $0.10 / $0.50 | 20% | $0.0075 | $9.9000 | $9.9075 | 0.1% |
| Reconcile two revenue figures | $2 / $10 | 10% | $0.1500 | $4.9500 | $5.1000 | 2.9% |
| Reconcile two revenue figures | $10 / $50 | 6% | $0.7500 | $2.9700 | $3.7200 | 20.2% |

Look at the last column first. In eight of the nine rows, the model fee is under 21% of the cost. In the cheapest-tier rows it is 0.1% to 0.6%. A team that chose a model by price per token would have been optimising the smallest line.

The three tasks go three ways, and that is the point of choosing them. Routing a ticket: the dearest tier is cheapest per task, at $0.2050 against $0.3304, but only because we gave it half the errors. Summarizing a meeting: the middle tier wins, at $0.1970. The dearest tier cuts the fixing cost from $0.165 to $0.132 and adds $0.128 of fee to do it, so it ends up dearest at $0.2920. Reconciling revenue figures: the dearest tier wins by a wide margin because one wrong answer costs $49.50 of someone’s time. Change one assumed error rate and a winner can change. We do not know the real rates. You can only get them from your own cases.

## How much better does the dearer tier have to be?

Flip the question. Instead of guessing error rates, ask how many percentage points fewer errors the dearer tier must deliver to pay for its higher fee. The answer needs no error rate at all.

Break-even gap (percentage points) = (model cost of the dearer tier − model cost of the cheaper tier) ÷ (minutes to fix ÷ 60 × hourly cost) × 100. For the meeting summary, going from the $0.10/$0.50 tier to the $10/$50 tier adds $0.1584 of fee. A wrong answer costs $3.30. So the dearer tier must be wrong at least 4.8 percentage points less often, say 96% right against 91.2%, before it pays. For the revenue reconciliation, the fee gap is $0.7425 against $49.50 per wrong answer, so the gap is 1.5 points.

**Extra accuracy the dearer tier must buy to pay for itself, in percentage points** (percentage points of error (assumption-based))

- Route a support ticket (fix: 5 min): 0.14 to 0.72 (0.14 for $0.10/$0.50 to $2/$10; 0.72 for $0.10/$0.50 to $10/$50)
- Summarize a one-hour meeting (fix: 3 min): 0.92 to 4.8 (0.92 for $0.10/$0.50 to $2/$10; 4.80 for $0.10/$0.50 to $10/$50)
- Reconcile two revenue figures (fix: 45 min): 0.29 to 1.5 (0.29 for $0.10/$0.50 to $2/$10; 1.50 for $0.10/$0.50 to $10/$50)

Source: Our calculation from list prices read on October 19, 2026 (Anthropic and OpenAI pricing pages). Assumption-based: tokens, minutes to fix and a $66 hourly cost are assumptions. The gap from the $2/$10 tier to the $10/$50 tier is 0.58, 3.88 and 1.21 points for the three tasks., https://platform.claude.com/docs/en/about-claude/pricing

Read the range as a bar of how demanding the test is, not how likely the tier is to pass it. The ticket needs the least because the tokens are few and a fix is five minutes: one percentage point of accuracy buys $0.055 of saved time, and the whole fee gap between the cheapest and the dearest tier is four cents. The meeting needs the most, because the input is long (so the fee is large) and a bad summary is quick to patch. The reconciliation sits between: a big fee gap, a very expensive error.

Our position, which is a judgment from these three cases and not a rule. For short tasks where a fix is quick, the cheap tier is a serious default and the burden is on the dearer tier to show a gap of several points. For tasks where one wrong answer takes an hour of an expert, the fee is noise, and you should choose by measured error rate. In both cases the gap is a number you can compare with a test result. If your test says the dearer tier is 2 points better and the break-even is 4.8, you have a reason not to pay.

This is a simple model, and its limits are plain. It assumes a fix takes the same time whichever tier made the mistake. It treats every wrong answer as equal, when some are caught in review and some reach a customer. And it ignores retries, which on agent workflows can multiply the fee.

## A caution before comparing providers

> **The same text is not the same number of tokens everywhere** Anthropic’s pricing page says that Claude 4.7 and later models use a newer tokenizer that produces approximately 30% more tokens for the same text, and that the exact increase depends on the content and workload shape. That comparison is against earlier Claude models, and the page says nothing about OpenAI. We found no page that gives the ratio between the two providers’ counts, and we did not measure it. Our table uses one assumed token count for both providers in each pair, because the per-token prices match. Matching prices per token do not guarantee matching prices per task.

To see how much it could matter, take the revenue reconciliation on the $2/$10 tier: $0.150 at our assumed counts, and $0.195 if the Claude side counted 30% more tokens (65,000 in, 6,500 out) than the other side. The pair is the same price per token and a different price per task. Count the same documents with each provider’s own token counter before comparing, and compare on your text.

Three more items change a real bill and are not in our table. Cached input is priced lower: $0.25 on Fable 5.1, $0.10 on Sonnet 5.5 and $0.01 on Haiku 5.5 (up to 100,000 tokens), against $1.00, $0.10 and $0.01 on the OpenAI models. Long inputs cost more: Haiku’s price rises to $0.50 and $2.50 above 100,000 tokens, and OpenAI’s page shows gpt-6-astra at $20 input and $75 output at long context. Regional endpoints carry a 10% uplift on some models. We priced none of these.

## What to measure on your own work

Replace each assumption with a measurement. Our guide to benchmarking AI on your own work explains how to build the test. The list below is the short form, in the order we would do it.

**Before you pick a tier**

- [ ] Pick one workflow and 20 to 50 past cases, including the awkward ones.
- [ ] Count real tokens in and out for those cases, with each provider’s own counter. Replace our assumptions.
- [ ] Run each tier several times per case. An error rate from one run is a guess.
- [ ] Time a person fixing a wrong answer, on real wrong answers. Replace the minutes we assumed.
- [ ] Use your own loaded hourly cost, not $66 or $72.
- [ ] Count retries and review minutes. Add them to every tier.
- [ ] Work out the break-even gap for your numbers, then compare it with the measured gap in errors.
- [ ] Re-run the test when a price or a model changes. List prices will have moved by the time you read this.

If you want the arithmetic done for you, the AI cost per task calculator compares two models on tokens, review time and fixing mistakes. Put in your measured numbers, not ours.

## What this post cannot say

- What any model scores on any of these tasks. We invented the error rates to show the arithmetic, and they are not benchmarks.
- How many tokens your tasks take. Our counts are rough and round, and a long thread or a scanned invoice can be many times larger.
- Whether a Claude model and an OpenAI model at the same price do the same job equally well. We priced them the same, which is not a quality claim.
- Anything about Google’s models, open-weight models or prices after October 19, 2026.
- What your people cost. $66 and $72 are placeholders.

## Where Nolli fits, and what it cannot do

Nolli benchmarks people, agents and models on your own work and shows the cost per task for each, which is the measurement the checklist above asks you to do by hand. It points out where a cheaper model does the same job, before you switch anything. It needs your cases and your team’s own definition of correct. It does not supply error rates of its own, and nothing in this post is a Nolli result: the prices come from the providers’ pages and every other figure is our assumption. No public price. Request a demo to see it run on your own work.

## Questions people ask

**How much does one AI task cost?**

On list prices read on October 19, 2026, and our assumed token counts, the model fee for the 12 tasks here ran from $0.00035 (extract fields from an invoice, cheapest tier) to $0.75 (reconcile two revenue figures, dearest tier). The fee is often the smaller part of cost per task once the time to fix wrong answers is counted.

**Why do Claude and OpenAI models appear at the same price?**

On the pages we read, three pairs are priced the same per million tokens: Claude Fable 5.1 and gpt-6-astra at $10 and $50, Claude Sonnet 5.5 and gpt-6.1-sol at $2 and $10, and Claude Haiku 5.5 (up to 100,000 tokens) and gpt-6-luna at $0.10 and $0.50. Equal prices say nothing about quality or about token counts.

**Is the cheapest model the cheapest per task?**

Not always. In our worked examples, with assumed error rates, the cheapest tier was dearest per task for two of three tasks once fixing mistakes was included. It won only where the errors added little cost. Measure the error rate on your own cases to know.

**What is the break-even accuracy gap?**

It is the number of percentage points by which a dearer tier must cut errors to pay for its higher fee. The formula is the fee difference divided by the cost of fixing one wrong answer, times 100. In our three examples it ranged from 0.14 to 4.8 points.

**Do tokens count the same across providers?**

Not necessarily. Anthropic says its newer tokenizer produces about 30% more tokens than earlier Claude models for the same text. We found no published ratio against OpenAI, so count your own text with each provider’s counter.

## Sources

- "Pricing." Anthropic (Claude Platform Docs), accessed October 19, 2026; read in a browser. https://platform.claude.com/docs/en/about-claude/pricing
- "Pricing." OpenAI (API docs), accessed October 19, 2026; read in a browser. https://developers.openai.com/api/docs/pricing
- "Connect to the Microsoft Copilot Dashboard for Microsoft 365 customers." Microsoft Learn, as read for our October 16, 2026 post; not re-read for this one. https://learn.microsoft.com/en-us/viva/insights/org-team-insights/copilot-dashboard
- "How to choose an AI model by cost per task." Nolli, accessed October 19, 2026. https://withnolli.com/learn/guides/ai-model-cost-per-task