Provider pricing

Groq API pricing: per-token rates, cache and batch

Groq is a speed-first, pay-per-token API. On 19 November 2026 the hosted text line-up is three models: GPT-OSS 120B at $0.15 input and $0.60 output, GPT-OSS 20B at $0.075 and $0.30, and Qwen3.8 27B at $0.80 and $4.00 per million tokens. Caching cuts input cost in half for the GPT-OSS models, and batch cuts everything in half but does not stack with cache.

P
Plugsky Editorial Team
Verified 19 November 2026 · Groq model and rate-limit docs

Short answer: Groq charges $0.075–$0.80 per million input tokens and $0.30–$4.00 per million output tokens across its three hosted text models, with no long-context multiplier. GPT-OSS 120B is the default choice at $0.15/$0.60. The two levers that change the bill are prompt caching, which halves cached input cost on GPT-OSS only, and the Batch API, which halves all tokens but cannot be combined with caching.

Groq prices per million tokens

ModelInputOutputCached inputContextMax output
openai/gpt-oss-120b$0.15$0.60$0.075131,07265,536
openai/gpt-oss-20b$0.075$0.30$0.0375131,07265,536
qwen/qwen3.8-27b$0.80$4.00Not offered131,07216,384

Prices are USD per 1 million tokens, retrieved 19 November 2026 from Groq's official model documentation at console.groq.com/docs/models. Cached-input figures are the published 50% discount applied to the list input rate, not a separately quoted price. Llama 3.1 8B and Llama 3.3 70B are listed as enterprise models with “Contact Sales” pricing, so no public rate exists.

Groq does not publish a long-context tier. A 100,000-token request and a 1,000-token request pay the same input rate per token, which makes Groq unusually easy to model compared with providers that reprice a whole request when it crosses a threshold. The constraint is the context ceiling, not the rate: GPT-OSS stops at 131,072 tokens and Qwen3.8 27B caps completion at 16,384 tokens.

Groq's free tier, in plain numbers

Groq publishes a Free plan with 30 requests per minute, 1,000 requests per day, 8,000 tokens per minute and 200,000 tokens per day. The same limits are shown for GPT-OSS 120B, GPT-OSS 20B and Qwen3.8 27B. That is enough for a prototype, a small internal tool or a model bake-off, but the token caps bind quickly. A 4,000-token request consumes 2% of the daily token allowance, so the practical ceiling is about 50 requests per day at that size, not 1,000.

The free tier is a rate-limited evaluation lane, not a production plan. Cached tokens do not count toward rate limits, but they are subtracted after processing, so a large parallel burst can still hit a limit. If your product needs predictable throughput, budget for paid usage from the start rather than designing around 200K tokens per day.

What changes the Groq bill

Prompt caching: 50% off input, GPT-OSS only

Groq caching is automatic, needs no code change and carries no storage fee. It matches an exact prompt prefix in volatile memory, expires after two hours without use, and requires a minimum cacheable length that Groq says ranges from 128 to 1,024 tokens depending on the model. On a hit, the cached portion of the input is billed at half price. That makes GPT-OSS 120B cached input $0.075 and GPT-OSS 20B cached input $0.0375 per million tokens.

Caching is currently supported only for openai/gpt-oss-20b, openai/gpt-oss-120b and openai/gpt-oss-safeguard-20b. Qwen3.8 27B has no published cache discount, so the $0.80 input rate is the rate you pay. To get hits, put system instructions, tool schemas, few-shot examples and fixed documents first; put timestamps, user IDs and the live question last. A single changed byte in the prefix invalidates the match.

Batch: 50% off, but the discounts do not stack

The Batch API accepts JSONL files of up to 50,000 lines and 200 MB, processes them asynchronously in a window you set from 24 hours to 7 days, and bills at 50% of synchronous pricing. Batch traffic does not consume your standard per-model rate limits. You are charged only for completed requests; expired work can be resubmitted.

The important exclusion: batch and prompt caching do not stack. Groq states that all batch tokens are billed at the 50% batch rate regardless of cache status. So the cheapest path for a cache-heavy workload is usually synchronous requests with a high hit rate, not batch. For a workload with no reusable prefix, batch is the simpler 50% saving.

Output length is the real cost driver

Output is priced at 4× input on GPT-OSS 120B and 5× on Qwen3.8 27B. A workload that writes long answers pays far more than one that reads long documents. Set max_completion_tokens deliberately, cap chain-of-thought where the model allows it, and measure p95 output length rather than average. Groq publishes one output rate; it does not publish a separate reasoning-token line, so budget reasoning inside the output allowance.

Worked example: 10M input, 2M output on GPT-OSS 120B

ScenarioInput costOutput costTotal
No cache, synchronous10M × $0.15 = $1.502M × $0.60 = $1.20$2.70
70% cache hit, synchronous3M × $0.15 + 7M × $0.075 = $0.975$1.20$2.175
No cache, batch$0.75$0.60$1.35
70% cache hit, batch$0.75 (no cache stack)$0.60$1.35

Two conclusions follow. First, a 70% cache hit saves $0.525, or 19.4%, on the synchronous bill. Second, batch saves more than caching on this mix because output is half the total and batch discounts output too. If your prefix is stable and your volume is latency-tolerant, compare both paths with real hit rates instead of assuming cache always wins.

When a flat plan wins

Groq is per-token with no published flat subscription. That is the right shape for spiky or experimental work: you pay for what you use and nothing when idle. A flat plan wins when three conditions hold at once: volume is steady, spend is predictable, and your p95 prompt is large enough that per-token arithmetic crosses the plan price every month.

At list price, $60 buys 400 million GPT-OSS 120B input tokens or 100 million output tokens. A team burning 300 million input and 40 million output tokens per month pays $45 + $24 = $69 on Groq before cache or batch, so a $60 unlimited-fair-usage plan is already cheaper and removes the variance. Below roughly 250 million blended tokens per month, per-token Groq is usually the lower bill. Above it, the flat plan wins unless you specifically need Groq's LPU latency.

Plugsky's paid plans start at $8/month for Hobby, with Builder at $60/month for unlimited fair usage, a 256K input and 32K output ceiling, 10 concurrent requests and 600 RPM. The trade-off is honest: Plugsky does not claim Groq's tokens-per-second, so choose Groq when latency is the product and a flat plan when cost predictability is.

How to verify these numbers

  1. Open console.groq.com/docs/models and confirm the model ID, input rate, output rate and context window.
  2. Open console.groq.com/docs/prompt-caching and confirm which models support caching and the 50% discount.
  3. Open console.groq.com/docs/batch and confirm the 50% batch rate and the no-stacking rule.
  4. Pull your own p95 input and output tokens from production logs; list prices only become a budget when multiplied by real token counts.
  5. Re-check after any model launch or retirement. Groq moves preview models to production and retires old IDs without a price change notice on this page.

Use the LLM API cost calculator to model cache hit rates and batch share, the rate-limit calculator to check whether 30 RPM or 8K TPM binds first, and the free API tracker for the current free-tier comparison. The cheapest LLM API guide ranks providers by workload rather than headline rate.

FAQ

How much does Groq charge per million tokens?

On 19 November 2026 Groq listed GPT-OSS 120B at $0.15 input and $0.60 output, GPT-OSS 20B at $0.075 and $0.30, and Qwen3.8 27B at $0.80 and $4.00 per million tokens. Prices are flat per token; Groq publishes no long-context surcharge.

Does Groq have a free tier?

Yes. The Free plan lists 30 requests per minute, 1,000 requests per day, 8,000 tokens per minute and 200,000 tokens per day for each hosted text model. The token caps usually bind before the request caps on long prompts.

Is Groq prompt caching free?

Caching has no extra fee and applies automatically to GPT-OSS 20B and 120B. Cached input is billed at a 50% discount, so GPT-OSS 120B cached input is effectively $0.075 per million tokens. Qwen3.8 27B is not listed as cache-supported.

Does Groq batch pricing stack with prompt caching?

No. The Batch API bills all tokens at 50% of the synchronous rate, and that discount does not stack with prompt caching. A batch request pays the batch rate regardless of cache status.

Need the same models without per-token variance?

Plugsky is OpenAI-compatible, starts free with no card, and moves to a flat plan when volume is predictable. Published RPM, concurrency and daily caps.

Start Free → See plans