Groq Pricing (2026): Throughput, Not Tokens, Forces the Upgrade

Groq pricing starts at $0 on Free; Developer has no base subscription and bills usage. GPT-OSS 20B is the cheapest general-purpose production text route with public self-serve prices, at $0.075 input/$0.30 output per million tokens; Llama 3.1 8B Instant and Llama 3.3 70B Versatile now require a sales contact. The worked GPT-OSS 120B Free ceiling still represents just $1.44 a month of paid traffic, so throughput is what forces the upgrade.

Groq pricing at a glance

Groq has no self-serve monthly seat price to memorize. The choice is between a rate-limited Free plan, a pay-as-you-go Developer plan, and custom Enterprise capacity.

Prices, plan access, and limits were verified against Supported Models, Billing FAQs, and the rate-limit documentation on October 13, 2026. Groq's former standalone pricing URL now redirects to its homepage; the model documentation is the current price reference.

A token is the unit the model bills. Input tokens include instructions, conversation history, documents, and tool definitions sent to the model. Output tokens are what the model generates. Groq quotes both sides per one million tokens, so monthly cost is the sum of input, output, audio, and any built-in tool usage.

Developer does not carry a monthly or annual subscription commitment. Groq asks for a payment method, meters usage, and normally invoices in arrears. There is no separate overage rate: Free blocks excess traffic at the applicable limit, while Developer continues billing usage at the same model rates until a rate limit, account restriction, or Spend Limit blocks it. Enterprise Performance works differently: the buyer purchases provisioned input and output capacity rather than paying the public on-demand token rate.

The Free plan is useful until a shared limit becomes a production dependency

Groq's Free plan can support a prototype, an internal helper, and a surprisingly useful amount of low-volume automation. It stops being free infrastructure the moment a rate-limit error becomes a customer-facing event.

Limits apply to the organization, not to each API key. Creating more keys does not multiply capacity. Groq also enforces several dimensions at once: requests per minute, requests per day, tokens per minute, and tokens per day. The first ceiling reached blocks the next call with HTTP 429. Some organizations also have separate input and output token-per-minute caps. Cached tokens are excluded after processing, so parallel bursts can still hit a limit.

The published Free plan currently includes these production and preview models:

• GPT-OSS 120B, GPT-OSS 20B, and Qwen3.8-27B preview: 30 RPM, 1,000 RPD, 8,000 TPM, and 200,000 TPD.
• GPT-OSS Safeguard 20B preview: 3 RPM, 1,000 RPD, 2,000 TPM, and 200,000 TPD.
• Llama Prompt Guard 2 22M and 86M previews: 30 RPM, 14,400 RPD, 15,000 TPM, and 500,000 TPD.
• Orpheus V1 English and Arabic Saudi previews: 10 RPM, 100 RPD, 1,200 TPM, and 3,600 TPD.
• Whisper Large V3 and Turbo: 20 RPM, 2,000 RPD, 7,200 audio seconds per hour, and 28,800 audio seconds per day.

Developer lists the same models with higher base limits:

• GPT-OSS 120B, GPT-OSS 20B, and Qwen3.8-27B: 1,000 RPM, 500,000 RPD, and 250,000 TPM.
• GPT-OSS Safeguard 20B: 1,000 RPM, 500,000 RPD, and 150,000 TPM.
• Llama Prompt Guard 2 22M and 86M: 100 RPM, 50,000 RPD, and 30,000 TPM.
• Both Orpheus models: 250 RPM, 100,000 RPD, and 50,000 TPM.
• Whisper Large V3: 300 RPM, 200,000 RPD, 200,000 audio seconds per hour, and 4 million audio seconds per day.
• Whisper Large V3 Turbo: 400 RPM, 200,000 RPD, 400,000 audio seconds per hour, and 4 million audio seconds per day.

The Developer table publishes no daily token cap for those text and speech-generation models. Neither plan includes the two enterprise Llamas or MiniMax M2.7; Compound is retired. Source: both plan tables.

Groq describes that public table as a high-level summary. The Limits page inside the Console is the authority for an individual organization's current allowance.

The daily token ceiling often binds before the request count. Take an uncached GPT-OSS 120B request with 2,000 input tokens and 500 output tokens, assuming no tighter account-specific input/output cap. At 2,500 total tokens, the 200,000 TPD limit permits 80 such requests a day. The 8,000 TPM ceiling permits three in one minute; a fourth comparable request would cross the token limit even though the plan advertises 30 RPM.

That is the free-to-paid break-even. The same request costs $0.0006 on Developer, so 80 a day for a 30-day month costs about $1.44. There is little financial reason to bend a production workflow around the Free ceiling. The upgrade buys capacity while the model bill is still smaller than most SaaS add-ons.

Who never needs to pay

You may never need Developer if Groq is used for local development, occasional evaluation, a personal internal script, or a demo whose traffic remains below the applicable token and request caps. Free also makes sense when a 429 can wait for a retry and nobody is promised continuous service.

Pay when the workflow has a user, a deadline, or a queue that cannot tolerate the shared cap. Developer also adds Batch, Flex, chat support, and Spend Limits. Those operational controls and higher limits are the practical boundary; upgrading to Developer does not restore the enterprise-only Llama models.

Every current Groq model price

Groq's current production catalog is compact: two self-serve GPT-OSS text models, two enterprise Llama text models, and two speech-to-text models. A separate preview catalog carries models that may disappear on short notice. All prices below follow Supported Models.

Production text models

• GPT-OSS 20B costs $0.075 input and $0.30 output per million tokens. It is the cheapest general-purpose production text route with public self-serve pricing. Cached input is $0.0375 per million. Its base Developer allowance is 250,000 TPM and 1,000 RPM, with a 131,072-token context window.
• GPT-OSS 120B costs $0.15 input and $0.60 output per million tokens. Cached input is $0.075 per million. Its base Developer allowance is 250,000 TPM and 1,000 RPM, with a 131,072-token context window.
• Llama 3.1 8B Instant requires a sales contact. Groq labels it Enterprise and publishes “Contact Sales” for both price and capacity, with a 131,072-token context window.
• Llama 3.3 70B Versatile requires a sales contact. It is also Enterprise, with “Contact Sales” for price and capacity and a 131,072-token context window.

Since August 16, 2026, the two Llama models have been discontinued for Free and Developer usage; enterprise customers with a committed-spend contract are unaffected. Their former self-serve prices are no longer a valid budget basis. Source: Groq's deprecation notice.

Start a production evaluation with GPT-OSS 120B when a larger open-weight model is required but a same-model provider fallback matters. Move down to GPT-OSS 20B only when an acceptance check shows the smaller model keeps the result quality. Evaluate either Llama against a sales quote, not its former public rate.

A higher price must repay itself through fewer retries, shorter responses, lower review work, or a capability the cheaper route lacks.

Speech-to-text models

• Whisper Large V3 costs $0.111 per audio hour. Its base Developer capacity is 200,000 audio seconds per hour and 300 RPM, with a 100 MB maximum file.
• Whisper Large V3 Turbo costs $0.04 per audio hour. Its base Developer capacity is 400,000 audio seconds per hour and 400 RPM.

At 1,000 audio hours, the line items are $111 for Whisper Large V3 and $40 for Turbo, a $71 gap. The lower price is the starting call, but an audio team should keep whichever model clears its transcript acceptance threshold. A cheaper transcript that needs correction is not a cheaper outcome.

Compound systems and preview models

Groq Compound and Compound Mini were decommissioned on September 21, 2026. They are no longer current model choices. GPT-OSS 20B and 120B still support built-in browser search and code execution, whose costs need a separate budget line.

The live preview catalog currently lists:

• Qwen3.8-27B: $0.80 input and $4.00 output per million tokens.
• Safety GPT-OSS 20B (GPT-OSS Safeguard 20B): $0.075 input and $0.30 output per million tokens.
• Llama Prompt Guard 2 22M: $0.03 input and output per million tokens.
• Llama Prompt Guard 2 86M: $0.04 input and output per million tokens.
• Canopy Labs Orpheus V1 English: $22 per million characters.
• Canopy Labs Orpheus Arabic Saudi: $40 per million characters.
• MiniMax M2.7: Enterprise, “Contact Sales” for price and capacity.

Preview means evaluation, not a production promise. Groq says these models can be discontinued at short notice. An evaluation using Qwen3.8-27B therefore needs a stable production route before it reaches customers.

Groq's current Supported Models page does not list a DeepSeek or Kimi model. Older posts and calculators that still price those names as active Groq routes are stale. If DeepSeek is the requirement, price it through a current provider rather than assuming it remains in Groq's catalog; the DeepSeek pricing analysis covers that separate decision.

Cost per outcome decides the model

Groq's token rates are so low that model choice matters less than traffic shape until usage becomes large. The clean comparison fixes one request and prices each route against it.

Use a standard worked request with 2,000 input tokens and 500 output tokens. At 100,000 requests a month, before caching, Batch, tools, or retries:

• GPT-OSS 20B: $30 total, or $0.0003 per request.
• GPT-OSS 120B: $60 total, or $0.0006 per request.
• Qwen3.8-27B preview: $360 total, or $0.0036 per request.

The useful denominator is not a request. It is an accepted result. If a smaller model retries, produces longer output, or sends more work to a human reviewer, the cheap request can become the expensive workflow. Track accepted outcomes beside tokens so the model can earn its place instead of winning on sticker price.

There is no paid volume break-even where one publicly priced self-serve Groq model automatically becomes cheaper than another. Those on-demand token rates are linear and Developer has no base fee. Enterprise quotes require a separate comparison. GPT-OSS 20B stays half the worked cost of GPT-OSS 120B at one request and at one million requests. The decision flips only when outcome quality or operating behavior changes the amount of work needed.

For a funded founder, that can mean GPT-OSS 20B for classification and GPT-OSS 120B for ambiguous cases. For a mid-market CTO, it means retaining model and token fields in every request log so procurement can see cost per accepted workflow. For a senior operator, it means measuring corrections and retries, not treating one successful demo as proof of the production route.

Batch beats caching for asynchronous work, and the discounts do not stack

Groq Batch is the lowest published rate when a result can wait. It charges 50% less than synchronous API pricing, runs outside standard per-model limits, and accepts a processing window from 24 hours to 7 days.

On the 100,000-request GPT-OSS 120B workload, the choices are:

• Synchronous with no cache: $60.
• Synchronous with 50% of input tokens served from cache: $52.50.
• Synchronous with 80% of input tokens served from cache: $48.
• Batch: $30.

The current rule that changes the budget is explicit: Batch and prompt-caching discounts do not stack. Every Batch token is billed at the 50% Batch rate regardless of cache status. A spreadsheet that halves the $30 Batch total again to $15 is wrong.

Prompt caching remains useful for synchronous GPT-OSS traffic. It is automatic, carries no feature fee, and discounts cached input by 50%. It currently supports GPT-OSS 20B, GPT-OSS 120B, and GPT-OSS Safeguard 20B. Cache hits require an exact matching prefix, the minimum cacheable prefix ranges from 128 to 1,024 tokens by model, and unused cache data expires after two hours. A hit is best effort, not guaranteed.

Put stable system instructions and tool definitions at the beginning of a prompt, with variable user data after them. Then read cached-token usage from responses. A projected cache ratio is not a budget fact until production usage shows it.

Batch has different operational edges. A JSONL file can contain up to 50,000 lines and be up to 200 MB. Jobs that miss the chosen processing window expire, although Groq charges only successfully completed requests. Batch files and results can remain in Groq's systems for up to 30 days, so sensitive workloads need a data-retention review before cost savings decide the route.

Tool costs need their own budget

The tool loop can cost more than the model. Compound is retired, and its former Basic Search, Advanced Search, and Visit Website prices should not be carried into a new budget.

The current browser-search and code-execution docs still point pricing readers to Groq's former pricing page, which now redirects to the homepage. Those pages do not state current numeric tool rates. Confirm tool charges with Groq before approving the workflow.

Keep the arithmetic separate from the tariff: 100,000 standard GPT-OSS 120B requests cost $60 in model tokens. If your search budget is $500, the combined budget is $560. That is an illustrative assumption, not a current Groq tool quote.

This is the budget line most likely to surprise an agent team. Token optimization cannot rescue a workflow whose agent searches on every turn. The first control is a tool policy: define when search is necessary, cap tool loops, cache durable results outside the model, and record tool calls per accepted outcome.

The paid bill has no annual lock, but it has operational edges

Developer is usage-billed, not a disguised annual SaaS contract. The less obvious terms concern when money leaves the account, how limits behave, and what happens to credits.

New Developer accounts use progressive billing. Groq can issue an invoice when cumulative lifetime usage crosses $1, $10, $100, $500, and $1,000. After the $1,000 threshold, ordinary monthly billing takes over. Accounts with an Indian billing address use $1 and $10 thresholds followed by recurring $100 increments. Groq does not require payment until usage reaches at least $0.50.

That schedule can create several small card charges early in adoption. It is not an added fee, but finance should recognize the pattern before treating the charges as duplicates.

Spend Limits block traffic, with a short reporting lag

Paid plans can set one organization-wide monthly Spend Limit. It covers every API key and endpoint, resets on the first of the month, and blocks new requests once the limit is detected. Groq supports alert points such as 50%, 75%, and 90% of the cap.

Spend tracking updates with a 10 to 15 minute delay. A burst can therefore push the final bill slightly past the configured amount before blocking starts. Groq suggests beginning with a limit 20% to 30% above expected monthly usage. For a critical path, that buffer also reduces the chance that a normal traffic spike turns the budget control into an outage.

Credits expire, and prepaid sales are final

Groq Service Credits expire one year after purchase or issuance unless a different term is specified. They are non-transferable, cannot be redeemed for cash, and are non-refundable. Closing the account expires the balance immediately.

Groq's Billing FAQ handles general refund requests case by case through support. That does not override the specific Service Credit terms: purchased and promotional credits remain final-sale balances. Buy a credit amount tied to a forecast, not a vague future migration.

Flex trades guaranteed capacity for a higher ceiling

Flex is available to paid customers at the same token price as On Demand and offers 10 times the on-demand rate limit. The trade is best-effort capacity. If Flex is full, it can fail quickly with HTTP 498 and capacity_exceeded.

Use Flex for retryable queues, evaluations, and bulk work that can absorb a fast failure. Do not make it the only route for a non-repeatable customer action. Enterprise Performance is the contracted option when best-effort capacity is unacceptable, with a 99.9% availability SLA and a 99% latency guarantee under the enterprise agreement.

Groq, Together AI, and Fireworks tie on uncached GPT-OSS 120B tokens

Groq does not win GPT-OSS 120B on public token price alone. Groq, Together AI, and Fireworks AI all list $0.15 input and $0.60 output per million tokens for the same model.

Use one normalized workload: 100 million input tokens and 20 million output tokens. With no cache discount, each provider costs $27. That tie is the useful result because it forces the provider decision onto cache economics, rate limits, deployment choices, reliability, and observed latency.

Together AI

Together AI is a multi-model inference provider whose serverless GPT-OSS 120B route costs $0.15 input and $0.60 output per million tokens. Its serverless product has no minimum or provisioning charge.

Together's current GPT-OSS 120B row does not publish a cached-input rate. Its caching documentation says a model without a cached price bills all input at the standard rate. On the normalized workload, that leaves the total at $27 even if the prompt repeats. Together offers up to 50% lower Batch pricing on supported serverless models, so it remains viable for asynchronous work when that exact model is eligible.

Choose Together when the broader model catalog or a path from serverless to reserved infrastructure matters more than Groq's specific operating profile. Skip a price-led move between the two until a workload exposes a difference, because the uncached GPT-OSS line item is identical.

Fireworks AI

Fireworks AI lists GPT-OSS 120B at $0.15 input, $0.015 cached input, and $0.60 output per million tokens.

At a 50% input cache share, the normalized total is $20.25 on Fireworks, $23.25 on Groq, and $27 on Together. That makes Fireworks the public-price winner for repeat-heavy GPT-OSS 120B input, provided its listed cached rate applies to the measured workload. Groq Batch is still lower for asynchronous work at $13.50 on the same normalized traffic.

OpenAI developed GPT-OSS but does not serve it through the OpenAI API or its consumer app. A direct OpenAI API comparison therefore swaps both provider and model, which breaks price normalization. Compare the same model across hosting providers first, then evaluate different proprietary models by accepted outcome. The cheapest AI API shortlist covers the broader model and provider field.

The provider decision is straightforward:

• Choose Groq when synchronous throughput and its operating controls win the measured route, or when 50% Batch pricing makes delayed work cheapest.
• Choose Fireworks when repeated GPT-OSS context consistently earns the listed $0.015 cached-input rate.
• Choose Together when its wider serverless-to-dedicated path matters and the workload does not benefit from a GPT-OSS cached rate.

Who should pick Groq, and who should skip it

Groq is a strong choice when an open model already clears the quality bar and response speed affects the product. It is a weaker choice when the model requirement, capacity guarantee, or deployment control sits outside its current self-serve catalog.

A funded founder should choose Groq when a fast open model keeps the product responsive and the team can preserve a same-model fallback. A mid-market CTO should use Developer only after centralizing keys, logging model and tool usage, and setting an organization cap. A senior operator should care about cost per accepted result, not the dramatic tokens-per-dollar headline.

Skip Groq as the only provider when the application requires a proprietary model absent from its catalog, a guaranteed best-effort route, or a preview model that has no stable replacement. Enterprise Performance can address contracted capacity for its supported models, but it is custom provisioned pricing rather than a cheaper public tier.

The explicit decision rule is this: choose Groq only when a current production model passes the acceptance test and either synchronous operating behavior or Batch cost beats the same-model fallback. If neither is true, the low token rate is not a reason to migrate.

Groq's price history rewards live verification

Groq pricing changes at the feature and model level, even when the billing structure stays pay as you go. The two Llama models left Free and Developer on August 16, 2026; the current catalog marks their pricing “Contact Sales.”

Qwen3.8-27B replaced Qwen3.6-27B on September 14, 2026, and Compound and Compound Mini were decommissioned on September 21. Groq's deprecation history records those access changes; the model page lists current prices.

Catalog churn matters just as much as price history. Models that appeared in older pricing coverage, including Kimi and DeepSeek routes, are absent from the current Supported Models page. A budget should carry its verification date, model ID, and fallback instead of treating a copied price as permanent.

The Monday move: price one accepted workflow and cap it

On Monday, take one bounded workflow and produce a budget that engineering and finance can both inspect. Do not begin with a provider-wide migration.

1. 1

   Capture the traffic shape

   Export a representative week of request count, input tokens, output tokens, cache-hit tokens, model IDs, tool calls, retries, and accepted results. Separate synchronous traffic from jobs that can wait.

2. 2

   Price three routes

   Calculate On Demand at the live model rates, Batch at 50% for eligible delayed work, and tools as their own line items. Do not apply cache savings to Batch, and do not assume a cache ratio that usage fields have not measured.

3. 3

   Set the paid boundary

   If Free limits interrupt a supported self-serve route, move it to Developer. If the route requires either Llama model, contact sales instead. Set a monthly Spend Limit 20% to 30% above the forecast, then place alerts at 50%, 75%, and 90%. Leave room for the 10 to 15 minute reporting delay.

4. 4

   Keep one fallback warm

   Run the same model through one alternate provider for a small evaluation set. Record the endpoint, observed acceptance rate, and reroute trigger so a catalog change or capacity error does not become an emergency migration.

The result is one budget line per accepted workflow: model tokens, tools, retries, and human review. Re-run it when the live model catalog, rate limits, or price page changes.

Frequently asked questions

How much does Groq AI cost?

Groq Free costs $0. Developer has no base subscription: GPT-OSS 20B costs $0.075 input/$0.30 output and GPT-OSS 120B costs $0.15 input/$0.60 output per million tokens. GPT-OSS 20B is the cheapest general-purpose production text route with public self-serve prices. Llama 3.1 8B Instant and Llama 3.3 70B Versatile now require a sales contact.

Is Groq free to use?

Yes, within model-specific organization limits. GPT-OSS 120B and 20B currently list 30 RPM, 1,000 RPD, 8,000 TPM, and 200,000 TPD on Free. Exceeding an applicable limit returns HTTP 429.

Which Groq AI models are free to use?

Free lists GPT-OSS 20B and 120B, Whisper Large V3 and Turbo, plus the Qwen3.8-27B, GPT-OSS Safeguard 20B, Llama Prompt Guard 2 22M/86M, and Orpheus English/Arabic Saudi previews. Each has its own caps, listed above. Neither Llama 3.1 8B Instant nor Llama 3.3 70B Versatile is included; MiniMax M2.7 is also enterprise-only, and Compound is retired. Preview models remain for evaluation, not production.

How much is Groq per month?

There is no public monthly or annual self-serve subscription. Add monthly input, output, audio, tool, and service-tier usage at the current rates. The worked 100,000-request GPT-OSS 120B workload costs $60 synchronously before cache or tool charges.

Does Groq offer a student discount?

Groq does not list a student-specific discount in the model or billing documentation verified on October 13, 2026. Students and other light users can use the general $0 Free plan within its rate limits.

What is Groq's refund policy?

Groq handles general billing refund requests case by case through support. Service Credits are stricter: purchased and promotional credits are non-refundable, non-transferable, and expire after one year unless a different term is stated.

Did Groq pricing change?

Yes. The current model page lists both Llama models as Enterprise with “Contact Sales,” and Qwen3.8-27B preview costs $0.80 input/$4.00 output per million tokens. GPT-OSS 20B remains $0.075/$0.30 and 120B $0.15/$0.60. Batch is still 50% off eligible synchronous rates; cached input is 50% off on supported GPT-OSS models, and the discounts do not stack. The former standalone pricing URL redirects to Groq’s homepage, so use the model docs.

How does Groq compare with OpenAI pricing?

OpenAI does not serve GPT-OSS through its own API, so a direct comparison changes the model. For a normalized GPT-OSS 120B workload, Groq, Together AI, and Fireworks AI all cost $27 for 100 million input and 20 million output tokens before cache discounts.

Get the AI Tools Map for Business Owners

The AI Tools Map for Business Owners turns model prices into an adoption route, with the quality floor, operating role, and cost trigger each tool must earn. Subscribe to get the next edition free.