Cheapest LLM API for high-volume classification and extraction

Classification and extraction are the quiet giants of an LLM bill. Tagging support tickets, routing emails, flagging policy violations, pulling invoice fields into JSON: each request is small, but there are hundreds of thousands of them a month, and every one is sent to whichever model the team picked on day one. This guide prices that kind of work on the current small and mid-size models from OpenAI, Anthropic and Google, shows what batch processing and a simple cascade change, and explains how to check that a cheaper model is good enough before you move. All prices are US dollars per million tokens, taken from each provider's own pricing page on 9 November 2026. The workloads are illustrations, not measurements of your traffic.

Why these jobs are different

Three properties make classification and extraction the best place to cut cost.

• The task is narrow. Choosing one of twelve labels or copying an invoice number does not need a flagship model's reasoning. Small models are built for exactly this.
• Prompts are short and outputs are tiny. A classification call might send 400 tokens and get back 10. Cost is almost entirely the input price, so the cheapest input price wins.
• Nobody is waiting. Most of this work runs on stored records, so it qualifies for the half-price batch tier. Our batch API guide covers how that works.

Extraction is the same idea with a bigger prompt (the document) and a bigger output (the fields as structured text), which changes which price matters, as the examples below show.

Price per million tokens

Batch prices are exactly half of each standard price on all three providers. The full list, including cached-input and long-prompt rates, is in the pricing calculator.

Classification: 1,000,000 items a month

Take a ticket-routing job: 1,000,000 requests a month, each with 400 input tokens (instructions plus the ticket) and 10 output tokens (the label).

One classification costs $0.045 per thousand on Luna or Haiku 5.5, $0.145 per thousand on Flash-Lite, $0.45 on Terra or Haiku 4.5 and $0.90 per thousand on Sol or Sonnet 5.5. The mid-size default is 20 times the price of the small model for a task that may not need it. Two cautions: when Gemini 3.8 Flash doubles in January the same job rises from $337.50 to $675, and output is only 11% of the Luna bill here, so the input price decides the ranking.

Extraction: 200,000 documents a month

Now an invoice-extraction job: 200,000 documents a month, each with 2,000 input tokens and 300 output tokens of JSON.

Per thousand documents that is $0.35 on Luna or Haiku 5.5, $1.35 on Flash-Lite, $3.50 on Terra or Haiku 4.5 and $7.00 on Sol or Sonnet 5.5. Output is 43% of the Luna bill here, because 300 tokens of JSON cost far more than a 10-token label. That is why Flash-Lite, with its $2.50 output price, falls further behind: 3.2 times Luna on classification becomes 3.9 times on extraction. If your extraction returns long text, compare output prices first. If it returns a few short fields, tighten the output format: asking for only the fields you need, with short keys, directly lowers the biggest line of the bill.

The cascade: small model first

The usual objection to a small model is accuracy on the hard cases. The answer is not to buy the expensive model for everything but to send it only what the small model is unsure about. Run every item through the small model and ask it to return a confidence or an "unsure" label; escalate only those items to a mid-size model.

On the classification job above, suppose 10% of the items are escalated. Luna handles all 1,000,000 ($45) and Sol or Sonnet 5.5 handles 100,000 of them ($90), a total of $135 a month against $900 for running everything on the mid-size model. That is 85% less, and the hard cases still get the stronger model. The escalation share is the number to measure: the higher it is, the closer you get to the mid-size bill, so a small model that is confident when it should be is worth more than one that is merely cheap.

Batch, caching and prompt length

Three levers sit on top of model choice. Batch halves the price for anything that can wait up to a day, which is most stored-record work. Caching reduces the price of repeated instructions, but each provider has a minimum prompt length before caching applies (see our prompt caching guide), so a 400-token classification prompt may be too short to benefit; extraction prompts with a long fixed schema are better candidates. Prompt length is the lever teams forget: with input as the dominant cost, trimming a long instruction block or dropping unused few-shot examples cuts the bill in direct proportion.

How to pick without guessing

1. Build a labelled test set. A few hundred real items with the answer you would accept, including the awkward ones, from your own data.
2. Run the same set through two or three models. Start with the cheapest small model and one mid-size model as the reference.
3. Score the difference where it costs you. A wrong label that sends a ticket to the wrong team costs something; an extra manual review costs something else. Put a price on each error type.
4. Decide with the numbers. If the small model is within your tolerance, switch. If it fails only on a recognisable slice, use the cascade.
5. Re-check when prices move. Provider prices and model lines change every few months; the calculator uses current list prices.

To see which of your calls are classification or extraction in disguise, upload your usage export to the free Bill Analyzer. If you want your real traffic tested against cheaper models and a ranked plan, that is what the LLM Cost Report delivers.