Groq API Pricing 2026: Every GroqCloud Model per Million Tokens, Free Tier Limits, Batch and Cost per Conversation

Published 27 October 2026. Every price below was read from GroqCloud's documentation on 27 October 2026, and every price is as of that date.

Groq API pricing comes down to six self-serve text models on GroqCloud, plus two Whisper and two Orpheus audio models, as of 27 October 2026. GPT-OSS 120B costs $0.15 per million input tokens, $0.075 per million cached input tokens and $0.60 per million output tokens, and Groq states its speed as roughly 500 tokens per second. GPT-OSS 20B costs $0.075, $0.037 and $0.30 at roughly 1,000 tokens per second, and Qwen 3.8 27B, the only self-serve model that takes images, costs $0.80 input and $4.00 output with no cached rate. The Batch API takes 50% off every token, the free plan gives GPT-OSS 120B 30 requests and 8,000 tokens a minute, and Llama 3.1 8B, Llama 3.3 70B, MiniMax M2.7 and Muse Spark Open are now "Contact Sales" models with no public price.

Two things make most Groq pricing guides wrong today. The pricing page they cite, groq.com/pricing, now returns a redirect to Groq's homepage and shows no prices, so the current list prices live only in the models page of the developer docs. And Groq removed most of the cheap models those guides lead with: Llama 3.1 8B at $0.05 input, Llama 3.3 70B, Llama 4 Scout, Qwen3 32B and Kimi K2 all left the free and Developer plans between April and August 2026, and the Compound agent systems shut down on 21 September 2026, according to Groq's deprecations page. In the worked example further down, a 40-turn conversation costs $0.080 on GPT-OSS 120B without caching and $0.046 with it, which is the same uncached price as DeepSeek's deepseek-flash off-peak and roughly three times its cached price.

Groq is also not Grok. Groq (Groq LLC, at groq.com) builds the LPU inference chip and runs GroqCloud, a cloud that serves other companies' open-weight models; Grok is xAI's own model family, sold through a separate API documented at docs.x.ai. Nothing on this page is a Grok price.

Groq price per million tokens, every model on GroqCloud

US dollars per million tokens, from Groq's models page and each model's own page, as of 27 October 2026. Speeds are Groq's own published figures, not our measurements. Cached input applies only on a cache hit, and Groq lists the 20B cached rate as $0.037, which is half of $0.075 rounded down.

Groq describes production models as meeting its "high standards for speed, quality, and reliability" and preview models as "intended for evaluation purposes only", which "may be discontinued at short notice". Read the status column as part of the price. Of the six self-serve text models, only the two GPT-OSS models are production models, so a team that wants a production-grade model on Groq without an enterprise contract is choosing between GPT-OSS 120B and GPT-OSS 20B.

Qwen 3.8 27B costs 5.3 times as much as GPT-OSS 120B on input and 6.7 times on output, and it is the only self-serve model that accepts images (up to three per request, 20 MB per file). GPT-OSS 20B costs exactly half of GPT-OSS 120B on every meter and, by Groq's figures, runs twice as fast.

Reasoning is billed as output. Groq's reasoning guide describes reasoning chains as "part of the token output", and the GPT-OSS models default to medium effort according to the API reference, with low and high available through reasoning_effort. Qwen 3.8 27B also accepts none, and at default it returns no reasoning tokens on Groq. A reply of 300 visible tokens that spends 2,000 tokens reasoning bills 2,300 output tokens, which is $0.0014 on GPT-OSS 120B instead of $0.00018.

What changed in 2026, and why other guides show different prices

Source: Groq deprecations page, read 27 October 2026.

The Llama, Qwen3 32B, Llama 4 Scout and Qwen 3.6 notices each say the deprecation "applies to free and developer-tier usage; enterprise customers with a committed-spend contract are not affected", which is why Llama 3.1 8B and Llama 3.3 70B still appear on the models page, marked Enterprise and priced at "Contact Sales". If your code still calls llama-3.3-70b-versatile on a pay-as-you-go key, it has been returning errors since 16 August.

Several of the pages that rank for "groq pricing" were written before these changes and still lead with Llama 3.1 8B at $0.05 input and $0.08 output, Llama 3.3 70B at $0.59 and $0.79, and Compound tool fees. Those were real prices, and none of them can be bought on a self-serve account today. The cheapest self-serve chat model on GroqCloud is now GPT-OSS 20B at $0.075 input and $0.30 output.

Groq free tier and Developer plan rate limits

RPM and RPD are requests per minute and per day; TPM and TPD are tokens per minute and per day. From Groq's rate limits page, as of 27 October 2026. Groq calls these "base limits" and says higher limits "are available for select workloads and enterprise use cases"; the exact limits for your organization are on the Limits page of the console.

The free plan has no token allowance to spend down. It is free for as long as you stay inside these limits, and Groq's billing FAQ asks for a payment method (a credit card, a US bank account or a SEPA debit account) only when you upgrade to the Developer plan. Upgrading costs nothing up front; the Developer plan is pay-as-you-go at the prices above and adds Flex processing, the Batch API, spend limits and chat support. Limits apply to the whole organization, not to each API key, so five keys share one 30 RPM budget, and whichever limit you hit first returns HTTP 429 with a retry-after header. Every response also carries x-ratelimit-remaining-requests (counted per day) and x-ratelimit-remaining-tokens (counted per minute), which is enough to pace a client before it hits the wall.

Groq's billing FAQ says it "occasionally" offers promotional credits, "such as during hackathons and special events". It publishes no standing sign-up credit.

The free tier does not hold a long conversation

A chat request carries its whole history, so with the token assumptions used in the worked example below, turn 13 of a conversation sends 8,150 input tokens, which on its own is more than the free plan's 8,000 tokens per minute on GPT-OSS 120B, GPT-OSS 20B and Qwen 3.8 27B. A full 40-turn conversation moves 490,000 tokens through the model without caching, more than twice the free plan's 200,000 tokens per day.

Caching softens this. Groq's prompt caching page says "cached tokens do not count towards your rate limits", and if every earlier turn hits the cache, the same 40-turn conversation counts about 35,650 tokens (the uncached input plus the output), so roughly five such conversations fit in a free day on the GPT-OSS models. The same page adds that cached tokens "are subtracted from your limits after processing", and cache hits are not guaranteed, so treat the free tier as a prototyping budget and expect 429s once conversations get long. Qwen 3.8 27B has no prompt caching on Groq, so every token of history counts against its limits.

Groq prompt caching: 50% off, automatic, GPT-OSS only

Prompt caching on Groq is automatic, costs nothing extra and cannot be switched off. When a request starts with the same prefix as a recent request, the matching tokens bill at half the input price: $0.075 instead of $0.15 per million on GPT-OSS 120B, and $0.037 instead of $0.075 on GPT-OSS 20B and GPT-OSS Safeguard 20B. Those three are the only models Groq caches today; Qwen 3.8 27B and the Prompt Guard models bill every input token at the full rate.

Four rules decide whether you get the discount, all from Groq's prompt caching page:

• A cache entry expires after 2 hours without use, and lives only in volatile memory, never shared between organizations.
• The minimum cacheable prompt "varies by model, ranging from 128 to 1024 tokens".
• Only exact prefix matches hit, so a timestamp or user ID at the top of the system prompt breaks the cache for everything after it.
• Hits are best effort: "Groq tries to maximize cache hits, but this is not guaranteed."

You check what you were billed for in usage.prompt_tokens_details.cached_tokens on each response. There is no cache write fee and no storage fee, which makes the arithmetic simple and also caps the saving: a cache hit on Groq saves 50%, where a cache read saves 90% on Claude Haiku 5.5, 95% on Claude Sonnet 5.5 and 98% on DeepSeek's deepseek-flash. For a long conversation that difference is most of the bill, and the comparison table below shows it.

Groq Batch API: 50% off every token, 24 hours to 7 days

The Batch API runs requests asynchronously at "a 50% cost discount compared to synchronous API pricing", with its own rate limits that do not touch your synchronous ones. On GPT-OSS 120B that is $0.075 input and $0.30 output per million tokens; on GPT-OSS 20B it is $0.0375 and $0.15. You upload a JSONL file of up to 50,000 lines and 200 MB through the Files API, set a completion window between 24 hours and 7 days, and collect the results by custom_id, since they can come back in any order. Requests the window does not reach expire and land in an error file.

The discounts do not stack. Groq says "all batch tokens are billed at the 50% batch rate regardless of cache status", so a cached prefix inside a batch costs the same as an uncached one. Batch is available on the Developer plan and above.

Check model support before you plan around it. On 27 October the Batch page lists GPT-OSS 20B and GPT-OSS 120B among the self-serve chat models, plus Whisper Large V3 and V3 Turbo for transcription (and V3 alone for translation). It also still lists Llama 3.1 8B, Llama 3.3 70B and Llama Guard 4 12B, which the deprecations page shows as enterprise-only or shut down, and it does not list Qwen 3.8 27B or GPT-OSS Safeguard 20B.

Groq service tiers: on-demand, Flex, Performance and enterprise

Groq sells the same models through four service tiers, set per request with the service_tier parameter, according to its service tiers page:

Sources: Flex processing and Performance tier, read 27 October 2026.

Flex is the cheapest way to get more throughput on Groq, because it costs nothing extra: you pay on-demand prices, get ten times the limits and accept that some requests fail with a 498, which a jittered retry handles. The Performance tier is the opposite trade. It is sold as "input and output capacity bundles" that you pay for "rather than per-token usage", so its price is a contract number, not a list price.

Above the API, Groq's platform page describes three enterprise layers: GroqMetal (dedicated bare-metal infrastructure), GroqCore (the inference stack on that dedicated capacity) and GroqAssured (governance, auditability and control). None of them has a public price. LoRA adapters on Groq are also enterprise-only, and the LoRA page says to "reach out to our enterprise support team for pricing".

Whisper and Orpheus: Groq audio pricing

Sources: speech to text and Orpheus text to speech guides.

Transcribing 1,000 hours of audio costs $40 on Whisper Large V3 Turbo and $111 on Whisper Large V3, and both are 50% cheaper through the Batch API. The 10-second minimum matters for voice agents that send short utterances: a 3-second clip bills as 10 seconds, so a stream of short clips costs more than three times its audio length suggests. Orpheus is a preview model, and at $22 per million characters a 200-character reply costs $0.0044. Groq retired its earlier PlayAI voices on 31 December 2025 in favour of Orpheus.

Browser search, code execution and Compound: no published price today

GPT-OSS 120B and GPT-OSS 20B can call two built-in tools on Groq, browser search and code execution (run in E2B sandboxes). Both docs pages answer the pricing question with "Please see the Pricing page", and that link goes to groq.com/pricing, which on 27 October 2026 redirects to Groq's homepage and lists no prices. We could not find a current per-call or per-hour tool price anywhere in Groq's documentation.

The tool fees quoted on older guides belonged to groq/compound and groq/compound-mini, the agent systems that wrapped search and code execution around a model. Groq announced their deprecation on 24 August 2026 and shut both down on 21 September 2026 with no named replacement. If you are about to put browser search into production, ask Groq for the tool price in writing and watch the usage dashboard for the first few days. The tool also moves your token bill: Groq's browser search guide warns that higher reasoning effort can produce "extended browser sessions" that "may consume significantly more tokens than necessary", and recommends low effort for most queries.

What a 40-turn conversation costs on Groq, DeepSeek, Gemini and Claude

Take a chat assistant with a 2,000-token system prompt, where each user message is 150 tokens and each reply is 350 tokens; these are the same assumptions as our Gemini API pricing, DeepSeek API pricing and Claude API pricing guides, so the figures line up across all four. Turn 1 sends 2,150 input tokens, and turn 40 sends 21,650, because the API is stateless and each request carries every exchange before it. The whole 40-turn conversation consumes 476,000 input tokens to produce 14,000 output tokens, and a 100-turn conversation consumes 2,690,000 input tokens. Reasoning tokens are left out, so a reasoning model adds to every output figure below.

Rates for the comparison were read on 27 October 2026 from DeepSeek's pricing page (deepseek-flash at $0.15 input, $0.003 cache hit and $0.60 output off-peak, double at peak), Anthropic's pricing page (Haiku 5.5 at $0.10 input for prompts up to 100,000 tokens, $0.50 output, $0.125 five-minute cache write and $0.01 cache read; Sonnet 5.5 at $2, $10, $2.50 and $0.10) and Google's Gemini API pricing page (3.8 Flash at $0.75, $3.75 and $0.075 cached until 31 December 2026).

"Cache warm" on Groq means that from turn 2, the previous request's whole prompt is read at the cached rate and the 500 new tokens (the last reply plus the new message) bill at the full rate, which matches how Groq's caching guide describes multi-turn chat. That is the same model we used for DeepSeek and for Gemini's implicit cache; Claude's rows include its 1.25x cache write on the new tokens of each turn. The per-sibling details are on each of those pages.

Three things come out of the table. Without caching, Groq's GPT-OSS 20B is the cheapest model in it at $0.040 for 40 turns, and GPT-OSS 120B ties DeepSeek deepseek-flash off-peak at $0.080, because their list prices are identical ($0.15 input, $0.60 output). With caching, the order flips: GPT-OSS 120B at $0.046 costs more than three times deepseek-flash off-peak ($0.013) and Claude Haiku 5.5 ($0.014), because a Groq cache hit still costs half the input price while theirs cost 2% and 10% of it. And Qwen 3.8 27B, at $0.437 for 40 turns with no cache, costs more than Gemini 3.8 Flash with no cache and nearly four times Gemini 3.8 Flash with its cache.

At 10,000 forty-turn conversations a month, GPT-OSS 120B costs $798 without caching and $457 with it, and GPT-OSS 20B costs $399 and $226. On Claude Sonnet 5.5 the same volume costs roughly $10,920 and $2,396. What Groq sells on top of the per-token price is speed, roughly 500 tokens per second on GPT-OSS 120B and 1,000 on GPT-OSS 20B by its own figures, and for a voice agent or any product where the user waits on the reply, that is often the line item that decides it.

The table also shows the shape of the problem. Going from 40 to 100 turns multiplies turns by 2.5 and the uncached GPT-OSS 120B bill by 5.3, because every turn carries every turn before it, and Groq's 50% cache discount flattens that curve less than any other cache in the table. The cache also lasts two hours at most, which does nothing for a user who comes back tomorrow. The other lever is to stop resending the whole transcript. We build Maximem Synap, a memory layer that returns a ranked set of facts about the user, trimmed to a token budget you set (2,000 tokens by default), in place of the full history. When that beats caching, and when it does not, is worked through in how to reduce LLM token costs in long conversations.

How Groq bills: progressive thresholds, India, and spend limits

Groq bills monthly in arrears, but new Developer accounts are charged early as their lifetime usage crosses $1, $10, $100, $500 and $1,000, according to the billing FAQ. Each threshold triggers an invoice and an automatic payment; usage that does not reach the next threshold waits for the end-of-month invoice, and after $1,000 of lifetime usage only the monthly invoice remains. Customers with a billing address in India follow a different rule: invoices at $1 and $10, then at every further $100 of usage, with no $500 or $1,000 thresholds. Groq does not invoice amounts under $0.50.

Groq accepts Visa, MasterCard, American Express and Discover cards, US bank accounts and SEPA debit. Refunds are "handled on a case-by-case basis" through support, failed payments can be retried twice, and a long run of failed payments can lead to suspension. You can downgrade to the free plan at any time after paying a final invoice for unbilled usage.

Spend limits are the first control to set on a new Developer account. They are monthly, organization-wide caps in US dollars, available on paid plans to organization owners, with email alerts at whatever thresholds you add. When a limit is reached, every key in the organization gets HTTP 400 with the code blocked_api_access until the 1st of the next month or until you raise the limit. Spend updates every 10 to 15 minutes, so a burst can run past the cap by that much before the block lands, and there are no per-key, daily or weekly limits.

Where Groq processes and keeps your data

By default Groq does not retain the inputs and outputs of inference requests, according to its Your Data page. It may log them for up to 30 days to troubleshoot reliability problems or investigate abuse, and any customer can turn on Zero Data Retention in the console's Data Controls to stop that. Batch input and output files are kept for 30 days unless you delete them sooner, which is why turning on Zero Data Retention also switches off Batch and fine-tuning.

Retained customer data sits in Google Cloud Platform buckets in the United States, and Groq points to standard contractual clauses for transfers from other countries. The hardware is spread wider: Groq's platform page says it operates 13 data centres across four continents, including sites in the US, Canada, Finland, the UK, Australia and Saudi Arabia. The docs do not say which data centre serves a given self-serve request, so a team with a data-residency requirement should raise it with Groq's enterprise team, where GroqAssured and dedicated capacity are sold.

Which Groq model to pick on cost

For most text workloads on a self-serve account, the decision is GPT-OSS 20B against GPT-OSS 120B, because they are the only production text models and the only ones with cached pricing. GPT-OSS 20B costs half as much on every meter and Groq lists it at twice the speed; GPT-OSS 120B is the larger model, and the only way to know whether it earns double the price on your prompts is to run your own evals on both. Groq's deprecation notices pointed Llama 3.1 8B users to GPT-OSS 20B and Llama 3.3 70B users to GPT-OSS 120B, which is a reasonable starting map for a migration.

Qwen 3.8 27B is the pick when you need image input or its thinking and instruct modes, and it costs 5.3 times GPT-OSS 120B on input and 6.7 times on output, with no cache discount and a 16,384-token output cap. Treat it as a preview model in production planning: Groq retired its predecessor, Qwen 3.6 27B, on 14 September 2026. GPT-OSS Safeguard 20B and the two Prompt Guard models are classifiers for moderation and prompt-injection screening, priced to sit in front of a main model.

Vendor risk is worth a sentence for a CTO. Groq closed a $350 million Series A on 17 August 2026 at a $3.5 billion valuation, after raising $650 million in June 2026, and says it serves more than six million developers, according to its funding announcement. The more practical risk is model churn: ten model IDs left the self-serve plans in 2026, and the deprecation emails gave between roughly two weeks and two months of warning.

How to estimate your monthly Groq bill, and cut it

A request costs (cached input tokens times the cached rate) plus (uncached input tokens times the input rate) plus (output and reasoning tokens times the output rate), halved if it runs through Batch. For a conversation, input per turn is the system prompt plus every earlier turn, so estimate per conversation as in the table above and multiply by conversations per month; for audio, multiply hours by the Whisper rate after rounding each short clip up to 10 seconds.

Six levers move a typical Groq bill, roughly in order of size:

1. Use GPT-OSS 20B unless GPT-OSS 120B wins your evals. It is half the price on every token.
2. Send everything that can wait through Batch. Evaluation runs, back-fills and bulk classification get 50% off every token, cached or not.
3. Keep the prefix stable. Put the system prompt, tool schemas and fixed documents first and anything per-user last, call again within two hours, and watch cached_tokens.
4. Set reasoning effort per task. Reasoning bills as output, and low is enough for routing and classification.
5. Use Flex for throughput instead of asking for an enterprise contract. It costs the same as on-demand with ten times the limits, as long as you retry 498s.
6. Stop resending the whole conversation once chats run long, by summarising or retrieving only what the next turn needs.

Set a spend limit and alerts before any of this, because the 10 to 15 minute tracking lag is the only gap between a runaway loop and the cap.

Frequently asked questions

How much does the Groq API cost per million tokens?

As of 27 October 2026, GPT-OSS 120B costs $0.15 per million input tokens, $0.075 per million cached input tokens and $0.60 per million output tokens; GPT-OSS 20B costs $0.075, $0.037 and $0.30; and Qwen 3.8 27B costs $0.80 input and $4.00 output with no cached rate. Batch requests cost 50% less.

Does Groq have a free tier?

Yes. The free plan is limited by rate rather than by a token allowance, and Groq asks for a payment method only when you upgrade to the Developer plan: GPT-OSS 120B, GPT-OSS 20B and Qwen 3.8 27B each get 30 requests per minute, 1,000 requests per day, 8,000 tokens per minute and 200,000 tokens per day, as of 27 October 2026.

What are the Groq Developer plan rate limits?

The Developer plan raises GPT-OSS 120B, GPT-OSS 20B and Qwen 3.8 27B to 1,000 requests per minute, 500,000 requests per day and 250,000 tokens per minute, and paid accounts can use Flex for ten times the on-demand limits at the same price. Higher limits are available on request for enterprise workloads.

How much does Llama 3.3 70B or Llama 3.1 8B cost on Groq now?

They have no public price. Groq removed Llama 3.1 8B Instant and Llama 3.3 70B Versatile from the free and Developer plans on 16 August 2026, and lists both as Enterprise models at "Contact Sales". Groq recommends GPT-OSS 20B in place of Llama 3.1 8B and GPT-OSS 120B in place of Llama 3.3 70B.

Does Groq offer a Batch API discount?

Yes. The Batch API costs 50% less than synchronous pricing on every token, with a completion window from 24 hours to 7 days and files of up to 50,000 requests. The batch discount does not stack with the prompt caching discount.

How does Groq prompt caching work and what does it cost?

Caching is automatic and free, and a cache hit bills cached input tokens at half the normal input price. It works on GPT-OSS 120B, GPT-OSS 20B and GPT-OSS Safeguard 20B, needs an exact prefix match of 128 to 1,024 tokens depending on the model, and expires after two hours unused.

How much does Whisper cost on Groq?

Whisper Large V3 Turbo costs $0.04 per hour of audio and Whisper Large V3 costs $0.111 per hour, as of 27 October 2026, with a minimum of 10 seconds billed per request.

Where is the Groq pricing page?

The old groq.com/pricing address redirects to Groq's homepage as of 27 October 2026. Current per-model prices are on the models page of GroqCloud's documentation and on each model's own page there.

Is Groq the same as Grok?

No. Groq is the company behind the LPU inference chip and the GroqCloud API, which serves open-weight models such as GPT-OSS and Qwen. Grok is xAI's model family, with its own API and its own prices.

Is Groq cheaper than DeepSeek, Gemini or Claude?

Without caching, often yes: a 40-turn conversation costs $0.040 on GPT-OSS 20B and $0.080 on GPT-OSS 120B, against $0.080 on DeepSeek deepseek-flash off-peak, $0.410 on Gemini 3.8 Flash and $1.09 on Claude Sonnet 5.5. With caching, DeepSeek deepseek-flash ($0.013 off-peak) and Claude Haiku 5.5 ($0.014) come out cheaper than GPT-OSS 120B ($0.046), because Groq's cache discount is 50%.

Sources

All retrieved 27 October 2026.

• GroqCloud documentation: models, model pages for GPT-OSS 120B, GPT-OSS 20B, GPT-OSS Safeguard 20B, Qwen 3.8 27B, Llama 3.3 70B, MiniMax M2.7 and Muse Spark Open, rate limits, prompt caching, Batch, service tiers, Flex processing, Performance tier, billing FAQs, spend limits, deprecations, changelog, reasoning, API reference, speech to text, Orpheus text to speech, browser search, code execution, LoRA and Your Data
• Groq: platform and Series A announcement, 17 August 2026; groq.com/pricing checked and found redirecting to the homepage
• DeepSeek Models & Pricing
• Claude API pricing, Anthropic
• Gemini Developer API pricing, Google
• xAI Grok models

Worked examples are our own arithmetic on those rates.