Cheapest LLM API 2026: OpenAI, Anthropic, Google, DeepSeek, Mistral, xAI and Groq Compared

Groq's OpenAI GPT OSS 20B has the lowest uncached bill across the three workloads compared here, starting at $0.075 per million input tokens and $0.30 per million output tokens. The cheapest LLM API changes when you produce longer answers, reuse a large prompt, or need a second attempt: Mistral's Ministral 3 3B can win on output, while OpenAI GPT-6 Luna and Anthropic Claude Haiku 5.5 give existing integrations an inexpensive starting point.

Cheapest LLM API: Prices Verified October 20, 2026

Start with the input and output columns together. A token is a small unit of text the model processes; input includes your instructions, documents and conversation history, while output includes the model's billed response and, where applicable, its reasoning. A million input tokens and a million output tokens are separate purchases.

All prices below are USD per 1 million tokens, verified against the providers' own live pages on October 20, 2026. These are current paid budget tiers for the seven named providers, not a census of every host or a quality ranking. Groq supplies hosting for an OpenAI open-weight model; its rates come from Groq itself. The other rows use the model maker's direct API.

Notes: Groq's model card displays $0.037 for cached input. Its caching documentation describes a 50% discount, which mathematically gives $0.0375 from the input rate. The table preserves the card's displayed precision; the worked examples below do not rely on that rounded cached rate. †Groq and Mistral Batch figures are calculated from their documented 50% discounts. Groq Batch, Mistral Batch.

The conditions change the bill. OpenAI's row applies through 272K input tokens; longer prompts use higher full-request rates. Haiku's row applies through 100,000 prompt tokens, including cached tokens; above that, input and output rates rise fivefold. Grok Build's higher tier starts at 200K prompt tokens. The worked jobs below remain under all three thresholds. OpenAI model pricing, Claude long-context pricing, xAI pricing.

DeepSeek peak hours are 01:00-04:00 and 06:00-10:00 UTC, Monday through Friday, excluding Chinese public holidays. All other hours are off-peak. Its cheaper scheduled rate is not a Batch API discount. DeepSeek pricing.

Cached input means a qualifying repeat read, not every input token. OpenAI Luna cache writes cost $0.125 per million; short-prompt Haiku writes cost $0.125 for five minutes or $0.20 for an hour. Google lists storage at $1 per million cached tokens per hour. Count these charges separately from successful reads. OpenAI pricing, Claude caching, Gemini pricing.

LLM Pricing Calculator: Three Jobs, One Formula

Price the complete request, then multiply by the number of jobs. The model with the cheapest input can lose when it writes a long answer. Your application's tool definitions and previous messages also belong in the input count.

For ordinary uncached input, the formula is:

Cost per request = (input tokens × input rate + billed output tokens × output rate) ÷ 1,000,000.

These are explicitly assumed workloads, calculated for this comparison, not measured generations:

• Classifying a ticket: 500 input tokens and 20 billed output tokens. Return a short department label or routing object.
• Summarising a document: 10,000 input tokens and 500 billed output tokens. Return a bounded digest of an already extracted document.
• One coding-agent step: 20,000 input tokens and 2,000 billed output tokens. Read instructions, relevant code and tool results, then produce the next response or proposed edit.

Output budgets include any charged reasoning tokens. A reasoning model may use more than these budgets on your task, so replace the assumptions with its reported usage. The same document also produces different counts under different tokenizers. Equal token counts make rates comparable; they do not establish equal quality, equal document lengths or equal reasoning effort.

Cost per 1,000 Completed Single-Call Jobs

The table assumes each call succeeds. It excludes cache reads and writes, storage, tools, regional premiums, tax, retries and human review. An agent step is one model call, not an entire completed coding assignment.

All totals are original arithmetic from the dated provider rates above. Multiply by ten for 10,000 monthly jobs. At that volume, the assumed coding step costs $21 on Groq or $30 on Luna. The difference is $9 a month before failures and tools, a useful perspective before spending a week migrating a working feature.

Classifying a Ticket: Keep the Answer Tiny

Groq is the first price candidate for this bounded job. One call costs (500 × $0.075 + 20 × $0.30) ÷ 1,000,000 = $0.0000435. At 10,000 tickets a month, that is $0.435 of Standard inference, or $0.2175 with its documented Batch discount if the queue can wait.

A founder tagging inbound support requests should define the permitted labels before choosing a model. “Billing,” “technical,” and “account” can be validated mechanically; an unsolicited paragraph explaining the choice adds output without helping the router. Check ambiguous tickets separately and send them to review rather than forcing a confident label.

The catch is latency versus scheduling. Live triage wants an immediate result. Reclassifying an old help-desk archive can wait for Batch. Groq documents processing windows from 24 hours to seven days, so an overnight promise requires a capacity plan rather than an assumption. Groq Batch documentation.

Summarising a Document: Pay for a Useful Digest

Gemini 2.5 Flash-Lite is a sensible first document candidate when you want its supported PDF and multimodal input. On the text-token assumption, one summary costs (10,000 × $0.10 + 500 × $0.40) ÷ 1,000,000 = $0.00120. That is $12 for 10,000 monthly summaries, or $6 through Batch. Groq's corresponding text-only calculation is lower, but its selected model does not accept the same range of input types. Gemini model capabilities, Groq model capabilities.

Use that arithmetic for extracted text. A scanned PDF with page images can have a different token profile; document extraction, retrieval and storage can add their own charges. The useful acceptance test is whether the digest preserves the decision, deadlines and exceptions, not whether it sounds polished.

For a founder processing customer interviews, ask for a fixed set of findings with source references. If the summary misses a qualification that changes the product decision, a cheaper paragraph has not completed the job. Keep the original document available for checking instead of paying for a second expansive rewrite.

One Coding-Agent Step: Budget the Whole Loop

Start with Luna or Haiku inside an existing integration, and evaluate Groq as a cheaper alternative. Luna's assumed step costs (20,000 × $0.10 + 2,000 × $0.50) ÷ 1,000,000 = $0.003. Short-prompt Haiku has the same bill. Neither figure says the model can complete your particular change.

A coding agent repeatedly sends context, receives a proposed action, runs tools, and feeds the results back. A failed test can trigger another call with an even longer history. Count each pass, the billed reasoning and the external execution environment. A token table cannot price that whole loop without observing its behavior.

For a small maintenance task, require the changed files, the relevant test result and a clear stopping condition. Prefer a narrow patch over a long narration. Reducing total billed output from 2,000 to 500 tokens at Luna's rate saves $0.00075 per step, or $7.50 across 10,000 steps, provided the shorter response still completes the work.

Caching, Batch and Output Length Change the Winner

Caching helps repeated input; Batch helps work that can wait; shorter output helps every successful call. These are different adjustments, and combining them blindly overstates the saving.

A Cache Read Is Not a Cache Write

Assume the coding step reuses an eligible 18,000-token prefix, adds 2,000 fresh input tokens and generates 2,000 billed output tokens. A prefix is the unchanged beginning of the request, such as instructions and stable reference material. On a successful cache hit, Luna or short-prompt Haiku costs:

(18,000 × $0.01 + 2,000 × $0.10 + 2,000 × $0.50) ÷ 1,000,000 = $0.00138.

The first request writing that prefix at $0.125 per million costs $0.00345, assuming the changing suffix stays ordinary input. For ten calls with one write and nine full reads before expiry, total cost is $0.01587, versus $0.030 without caching: a 47.1% saving. That is the complete ten-call comparison, not a claim that a tenfold input discount cuts the entire bill tenfold.

For the same successful-hit step, DeepSeek costs $0.001554 off-peak or $0.003108 at peak. Its lower cache-read rate does not beat Luna here because the fresh input and output cost more. Mistral's corresponding hit-only calculation is $0.00058; that is a promising price for a bounded task, not evidence of equivalent coding ability.

Cache only material you expect to reuse. Google storage for a 10,000-token explicit cache held for an hour costs $0.01. Each full Standard-price reuse saves $0.0009 in input charges, so it takes twelve cache reads to exceed the storage charge alone; initial processing is additional. A one-off summary does not justify that cache simply because a discounted read rate exists. Gemini caching prices.

Batch Discounts Have Provider-Specific Rules

Use Batch for independent backlog work, not the next action in a live conversation. OpenAI, Anthropic, Google, Mistral and Groq document half-price input/output routes for the selected models. DeepSeek's pricing page lists time windows instead; Grok Build 0.1 explicitly does not support Batch.

Anthropic says its Batch and caching discounts stack. Groq says they do not: Batch tokens already receive the discount regardless of cache status. Google's selected Batch cache-read rate stays at $0.01, rather than halving with its ordinary input rate. Build the invoice from the relevant token categories instead of multiplying the whole bill by two discount percentages. Claude discounts, Groq caching rules, Google Batch pricing.

The Output Ratio Flips Groq Versus Mistral

Ministral 3 3B becomes cheaper than Groq GPT OSS 20B when output exceeds one token for every eight input tokens, assuming equal uncached Standard token counts and successful results. Mistral charges more for input but less for output; solving those two bills gives an output/input threshold of 0.125.

With 20,000 input and 4,000 output tokens, Mistral costs $0.0024 per call and Groq costs $0.0027. The three baseline jobs have shorter outputs, which is why Groq wins those rows. A feature that generates long descriptions, rewrites or reports may reverse that ordering.

Do not cut output merely to fit the cheaper column. Specify the minimum useful deliverable: the label, the extract, the patch or the bounded digest. Then check whether the cheaper model can produce it consistently.

AI API Pricing Comparison: Which Budget Tier to Buy

Use these seven entries as an evaluation order, not a benchmark leaderboard. Each has a different operational wall. The prices are the current starting Standard input/output rates; the full ladders belong on the providers' pricing pages.

1. Groq: First Price Candidate for Short, Checkable Text

Groq is an inference provider hosting OpenAI GPT OSS 20B, a text model with tool use, reasoning and structured-output support. It leads the three uncached billing examples because its low input price suits short answers over larger prompts. For a support labeler or text-only document queue, start here if you are prepared to compare acceptance against your existing route. The wall is the result, not the advertised generation speed: an invalid label or another reasoning pass can erase the saving. Model details.

Best for: Short validated answers and independent text queues
Standout: Lowest uncached bill for the three stated token budgets
Pricing: From $0.075 input and $0.30 output per million tokens
Free trial: No promotional allowance included in this comparison

The Groq pricing guide covers the wider buying decision. For this shortlist, use the publicly priced GPT OSS row. Groq's current catalog puts Llama 3.1 8B behind a sales quote, so an old public rate cannot be your budget. Current production catalog.

Set Up the First Comparison

1. 1

   Choose one bounded job

   Take ticket classification, not the entire support assistant. Write the allowed labels and the conditions that require review.

2. 2

   Compare representative requests

   Use 100 representative, appropriately sanitized examples as an initial screen. Include ambiguous, malformed and unusually long tickets. Run the current route and the candidate against the same acceptance criteria.

3. 3

   Log the complete result

   Record accepted or rejected output, billed input and output, end-to-end latency, and any retry or escalation. Separate cache reads from ordinary input.

4. 4

   Move only the passing task class

   Route validated classifications to the cheaper model. Keep a fallback for rejected results and continue monitoring beyond the initial sample.

2. Mistral: The Output-Heavy Price Candidate

Mistral offers Ministral 3 3B, a compact model with structured outputs, function calling and document-question support. Its flat input/output price makes it attractive for a bounded transformation that writes a substantial result from a short prompt. A founder generating standardized product descriptions can evaluate it before paying a higher output rate elsewhere. Its wall is task complexity: the cheapest output is useful only if the small model preserves your required details and constraints. Ministral capabilities.

Best for: Bounded rewrites, descriptions and extraction with machine-checkable output
Standout: Same Standard price for input and output
Pricing: From $0.10 input and $0.10 output per million tokens
Free trial: Evaluation credits excluded; the quoted rate is paid inference

Use ministral-3b-2512 when reproducing this candidate. “Small,” “Mini” and “3B” are not interchangeable product names. If the task requires a larger Mistral model after evaluation, recompute the bill at that model's rate rather than carrying the tiny-model price into a different capability class.

3. Google: A Practical Document and Prototype Route

Google Gemini provides Gemini 2.5 Flash-Lite, a currently listed stable model for lightweight work with text, images, video, audio and PDFs. It is a useful first candidate when your summarizer handles more than extracted text, or you want to prototype with a published free tier. The paid text bill is close enough to the cheapest entries that input support may decide the integration. The wall is the gap between your normalized text budget and the actual mixed-media request. Gemini model details.

Best for: Lightweight document processing and sanitized prototypes
Standout: Broad input formats plus a published free tier
Pricing: Paid Standard from $0.10 text input and $0.40 output per million tokens
Free trial: Free tier available, subject to its separate limits and terms

Google's pricing page distinguishes free-tier content use from paid-tier content use. Use appropriate sanitized data for a free prototype and check the paid terms before processing customer material. The Gemini pricing page separates the wider subscription and API choices; this comparison concerns the Developer API alone.

4. OpenAI: Keep a Working Integration Cheap

OpenAI offers GPT-6 Luna for focused, high-volume work, with structured outputs and adjustable reasoning effort. For an application already using OpenAI, it is the first budget model to evaluate before changing providers. Existing validators and fallback handling are assets, especially when the baseline monthly saving from a migration is only a few dollars. The wall is uncontrolled reasoning or repeated tool loops: a low unit rate does not cap the number of billed tokens. Luna model documentation.

Best for: Bounded tasks inside an existing OpenAI application
Standout: A cheap candidate without rebuilding provider-specific operations
Pricing: From $0.10 input and $0.50 output per million tokens in the short-context tier
Free trial: No promotional credit deducted from the quoted costs

For tool workflows, the model page directs users to Responses; Chat Completions function calling requires reasoning_effort set to none. Preserve the endpoint and settings in your evaluation record. “The same model” under different reasoning or tool configurations is not the same operational experiment.

For a short classification task, start with the least reasoning that passes your validation. For a proposed code change, allow more only when it improves accepted results enough to justify the additional tokens. Those are decisions your test set must establish, not conclusions available from a price page.

5. Anthropic: Cheap Claude Steps Within the Prompt Tier

Anthropic positions Claude Haiku 5.5 for classification, routing, extraction and subagent tasks. It belongs near the front of an existing Claude application's evaluation list because its short-prompt rates match Luna. Keep the integration when both clear the task and migration provides no operational benefit. Its wall is the 100,000-token prompt threshold, which counts cache reads as well as newly submitted material. Haiku overview, pricing rules.

Best for: Classification and extraction inside an existing Claude workflow
Standout: Short-prompt price parity with Luna and stackable Batch/cache discounts
Pricing: From $0.10 input and $0.50 output per million tokens through 100,000 prompt tokens
Free trial: Documentation lists a small testing credit without a fixed amount

A short labeler and an accumulated coding conversation can start on the same model and end in different pricing tiers. Log prompt length by request, not just a monthly average. A low average can conceal a smaller set of expensive long-context calls.

The Claude API pricing guide covers the broader ladder. Here the decision is narrower: evaluate Haiku for the bounded step and retain a stronger fallback when your acceptance test requires it. Do not equate a model's supported context window with its cheapest context-price band.

6. DeepSeek: Repeated Context and Schedulable Work

DeepSeek currently serves deepseek-flash as DeepSeek V4.1 Flash-1017, with JSON output, tools and a large context window. It merits evaluation for repeated-context work that can run off-peak, especially when an existing DeepSeek prompt already passes. It does not win the uncached jobs above, and its very low cache-read price cannot compensate for every output-heavy request. The wall is the combination of clock time, cache misses and output length. Current model and pricing.

Best for: Repeated context and queues with scheduling flexibility
Standout: Low cache-hit input pricing with an explicit off-peak schedule
Pricing: From $0.15 input and $0.60 output per million tokens off-peak
Free trial: No standing allowance assumed in the comparison

Read the DeepSeek pricing guide for the broader account and usage decision. For scheduling, log the request's billed window and actual hit tokens. A founder can move a historical document backlog off-peak; a live customer conversation has to run when the customer arrives.

Keep deepseek-flash and its served version in the cost record. The official page says older Flash aliases now resolve to the current model and rates. A model string preserved in an old configuration is not a price lock.

7. xAI: Buy the Coding Fit, Not a Cheap-Token Reputation

xAI lists Grok Build 0.1 as its lowest-priced text model on the current public pricing table. It is a coding-oriented model with function calling, structured outputs and reasoning. Include it when that workflow fit might justify a higher per-call bill, then require evidence from your own tasks. Its wall for this query is straightforward: it costs more than the other selected routes, and the model page says Batch is unsupported. Grok Build model, current xAI prices.

Best for: A coding workflow where its accepted-result advantage is demonstrated
Standout: A coding-specific candidate with documented tool capabilities
Pricing: From $1.00 input and $2.00 output per million tokens below 200K prompt tokens
Free trial: No subscription credit or trial allowance assumed

Do not transfer a remembered price from an older Grok Fast model to this row. The official current pricing table is the source of the recommendation. If your account exposes other models or negotiated terms, price those explicitly before substituting them.

The right reason to pick xAI is fewer failed or repeated coding steps on your workload. That advantage was not tested here. Without it, the quoted token costs give no reason to make it the default ticket labeler or simple summarizer.

Who Should Pick What

Pick the cheapest route that passes the job, then keep measuring completed outcomes. The starting recommendation follows the task's constraints.

For a ticket classifier, evaluate Groq first on price, with Mistral as another bounded-output candidate. Require an allowed label and a reliable review route. If OpenAI or Claude already works, compare the small possible saving with the engineering time needed to switch.

For a document summarizer, try Gemini when PDF or mixed-media input avoids a separate preparation step. Try Groq when your documents are already clean text. Judge factual coverage and preserved exceptions before prose style, and put independent backlogs through Batch when the deadline permits.

For a coding-agent step, begin with Luna or Haiku in the integration you already maintain. Add Groq as a price candidate, DeepSeek for repeated-context or scheduled work, and Grok Build when you have a reason to test its coding fit. A lower input rate cannot decide how many tool loops the assignment needs.

The Decision Rule That Flips the Choice

Switch away from the cheap first call when its failures make the complete route more expensive. Consider an explicitly hypothetical coding workflow: the cheap call costs $0.0021, and an escalation costs another $0.003. If 40% of tasks escalate and each fallback succeeds, average token cost is $0.0021 + 0.40 × $0.003 = $0.0033 per completed task.

That exceeds the $0.003 direct route under the same assumed token counts. Break-even is a 30% escalation rate. This is a routing calculation, not an observed failure rate for Groq, Luna or any other model; longer retry prompts and human repair can make the threshold lower.

Define success before counting it. For classification, success means the correct allowed label. For summarization, it means the required facts survive. For coding, it means the intended change passes the agreed checks. A response that merely arrives is not a completed task.

If you use a gateway to compare routes, account for its separate commercial terms. The OpenRouter pricing guide explains that buying route. No OpenRouter or other reseller rate is used in this page's provider tables.

How These Were Picked

This is a dated pricing comparison and original cost analysis, not a hands-on quality benchmark. Official pricing and capability pages were read during this run. No model was exercised on the three jobs, and none of the recommendations claims measured superiority in accuracy or latency.

The shortlist contains the seven providers in scope, with a currently listed general-purpose budget text model or, for xAI's current lowest text row, its coding-oriented model. Selection excludes deprecated model families, quote-only prices, specialist safety classifiers, image generation, speech and embeddings. Their capabilities or billing units would make a cheapest-text comparison misleading.

The evaluation turns on five practical criteria: ordinary input/output cost, caching and Batch rules, required input formats, prompt-length thresholds, and the work needed to get an accepted result. The second table holds token counts constant so the arithmetic can be reproduced. A production forecast must replace those counts with each model's actual usage.

This article extends the broader cheapest AI API comparison with a direct-provider price table and three task budgets. Rates from trackers, aggregators and resellers are excluded. Public prices are a starting point; a negotiated contract or account-specific model restriction needs its own comparison.

The Ones to Avoid

Avoid the mismatched route, not an entire provider. These choices turn a cheap-looking number into the wrong forecast.

• Groq Llama 3.1 8B at an old public rate: the current catalog says Contact Sales. Get a quote or use the currently priced GPT OSS row.
• Grok Build for a simple labeler without a measured advantage: it has the highest baseline bill here. Coding orientation does not help a three-label routing task by itself.
• Haiku's short-prompt price on long conversations: cached history still counts toward the prompt threshold. Price each request's tier.
• DeepSeek budgeted as permanently off-peak: live demand can land in the more expensive windows. Price the schedule your customers create.
• Gemini explicit caching for a document read once: storage and initial processing can exceed the saving from a discounted read that never happens.
• Ministral as an unvalidated autonomous coder: low output cost is a reason to evaluate a bounded task, not evidence that every proposed change is correct.
• Standard processing for an eligible backlog: when timing permits, compare the documented Batch route before changing model or provider.

Free Access and Price-Comparison Questions

LLM API pricing comparison

Compare input, billed output, cached reads, cache creation or storage, Batch and prompt-length tiers for a named model. Groq leads the three uncached examples here; Mistral can lead when output grows. Actual acceptance, tokenization and retries determine the bill for your application.

Free LLM API for developers

Google lists a free tier for Gemini 2.5 Flash-Lite. Its limits and content-use terms differ from Paid. Use suitable sanitized data for evaluation, and forecast the paid route before putting customer demand behind a free allowance.

Free LLM API unlimited

None of the cited pricing evidence establishes an unlimited free production service. Treat free access as an evaluation option with its own conditions. A paid token rate plus measured request volume is a more useful production budget than an unsupported unlimited claim.

The Monday Move

On Monday, measure one feature before changing the whole stack. Pull a representative request sample, count its actual input and billed output, and compare the current route with the cheapest plausible candidate. Keep the same acceptance test and record retries, cache writes, hits and tool costs.

For a labeler, enforce the allowed labels. For a summary, check the facts and exceptions. For a coding step, require the patch and relevant test result. Move only the task class that passes, retain the fallback, and save the pricing date alongside the calculation so the budget can be updated without repeating the whole evaluation.

Use the AI business workflow audit checklist to map one feature's inputs, acceptance checks and fallback before changing its model.