The Groq API free tier,
measured.

Is the Groq API free?

Yes. GroqCloud has three plans: Free, Developer and Enterprise. The Free plan gives you an API key with fixed rate limits on each model, and Groq does not say it expires. You pay nothing until you upgrade to the Developer plan, which needs a card, a US bank account or a SEPA debit account.

Upgrading to the Developer plan costs nothing. Groq bills you after each month for the usage in it, and only once that usage reaches $0.50. For new accounts, Groq also sends an invoice early each time total usage crosses $1, $10, $100, $500 and $1,000.

Groq's API is compatible with the OpenAI API. Any code or tool that calls OpenAI can use Groq by changing the base URL to https://api.groq.com/openai/v1 and the key.

Free tier limits by model, October 2026

This table is Groq's own free-tier table as published on 24 October 2026. RPM and RPD count requests per minute and per day. TPM and TPD count tokens per minute and per day.

For text generation, that leaves three models: gpt-oss-120b, gpt-oss-20b and the Qwen preview. Groq says preview models can be removed at short notice and should not be used in production. The two gpt-oss models are listed as production models.

Models that left the free tier in 2026

Most free-tier tables on other sites still list Llama and Kimi models. Groq shut down the models below for Free and Developer accounts on these dates. Enterprise customers with a committed-spend contract kept access.

If your code still names one of these models, requests to that model fail. Fireplexity's code names moonshotai/kimi-k2-instruct, an older Kimi K2 version that Groq shut down on 10 October 2025. The Limits page in Groq's console shows the current limits for your own organization.

How the four limits work

Groq applies all four limits at once, and a request fails at whichever limit it reaches first. Groq's own example: with a limit of 50 requests and 200,000 tokens a minute, 50 small requests in one minute still hit the request limit.

• Limits belong to the organization, not to the key. Every key in one organization draws on the same allowance, so creating more keys does not add capacity.
• Input and output tokens both count toward TPM and TPD. Some organizations have separate input and output caps. The Limits page shows the split when you hover over TPM.
• Cached input tokens do not count. When a request repeats a prefix of an earlier one, such as the same system prompt, the cached part is free of the limits. Caching works on the gpt-oss models only.
• Reasoning tokens count as output. The gpt-oss models write hidden reasoning tokens before the answer, and Groq bills and counts them like the visible answer. In our test they were about a quarter of all output tokens.

Which limit you hit first: a real test

Published tables list the limits but not how many answers a real app gets from them. To measure the number of answers, we replayed Fireplexity's two model calls for real questions. Fireplexity is an open-source AI search app that runs on Groq by default. For each question it sends six web pages, each trimmed to 2,000 characters, then makes a second call to write five follow-up questions.

We copied the prompts and trimming code from Fireplexity's repository and used live Google results as the sources. Each request went to openai/gpt-oss-120b through OpenRouter, locked to Groq as the only provider with no fallback, so Groq ran every request. Five questions ran with normal trimming, and three ran again with every source filled to the 2,000-character cap, which is the most Fireplexity ever sends.

The results, per question:

• Tokens used: 2,312 to 4,556, with an average of about 3,400.
• Requests made: 2, one for the answer and one for the follow-up questions.
• Answer time: 1.5 to 6.3 seconds end to end, or about 210 to 350 output tokens a second.
• Cost at Developer plan prices: $0.0006 to $0.0012. OpenRouter reported these costs, and they match Groq's list prices exactly.

Now apply the free limits for gpt-oss-120b to those numbers:

• The daily token limit is reached first. 200,000 tokens divided by 4,556 is 43 questions, and divided by the 3,400 average it is 59. Plan on about 40 to 60 answers a day.
• The per-minute token limit sets how many people can use the app at once. At 8,000 tokens a minute, one full question fits in a minute and two short ones only just fit. A second person asking in the same minute usually gets an error.
• The request limits are never reached. 1,000 requests a day is 500 questions, about ten times what the token limit allows, and 30 requests a minute is far above the 2 to 4 that fit in 8,000 tokens.

Two settings cut token use on the free tier. Dropping Fireplexity's follow-up call saves about 600 tokens and one request per question. Setting reasoning_effort to low on the gpt-oss models cuts the hidden reasoning tokens, which were 24% of the output in our test.

What happens when you hit a limit

Groq returns HTTP status 429 Too Many Requests. A 429 response carries a retry-after header with the number of seconds to wait. Every response, successful or not, also carries six headers that show how much of your limit is left:

• x-ratelimit-limit-requests and x-ratelimit-remaining-requests: your daily request limit and what is left of it.
• x-ratelimit-reset-requests: the time until the daily request count resets.
• x-ratelimit-limit-tokens and x-ratelimit-remaining-tokens: your per-minute token limit and what is left of it.
• x-ratelimit-reset-tokens: the time until the per-minute token count resets.

For a per-minute limit, waiting a few seconds and retrying works. For a daily limit, the wait can be hours, and the code should stop retrying and report the error. This function does both:

async function groqChat(body, tries = 4) {
  for (let i = 0; i < tries; i++) {
    const res = await fetch('https://api.groq.com/openai/v1/chat/completions', {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${process.env.GROQ_API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(body),
    });
    if (res.ok) return res.json();
    if (res.status !== 429) throw new Error(`Groq ${res.status}: ${await res.text()}`);

    const wait = Number(res.headers.get('retry-after')) || 2 ** i;
    if (wait > 60) throw new Error(`Groq daily limit reached, retry in ${wait} s`);
    await new Promise(r => setTimeout(r, wait * 1000 + Math.random() * 250));
  }
  throw new Error('Groq rate limit: retries used up');
}

Fireplexity uses the Vercel AI SDK with maxRetries: 2, so it retries a 429 twice. After that it shows the user “Rate limit exceeded” with a suggestion to wait and try again.

Groq API pricing after the free tier

Groq removed its public pricing page in August 2026, and groq.com/pricing now opens the home page. Prices are shown in the console under the billing plans, and the same rates are passed through on OpenRouter's Groq listings, where we checked them.

At these prices, the 8 test questions above cost $0.0006 to $0.0012 each, so 1,000 Fireplexity answers cost about one dollar. Llama 3.1 8B and Llama 3.3 70B are still served for Enterprise contracts, but they are no longer available on the Developer plan.

The Developer plan raises the rate limits, and Groq's rate-limits documentation lists the Developer limits for each model on a separate tab. The Developer plan also unlocks four features:

• Batch processing costs 50% less. You upload a file of up to 50,000 requests and get results within 24 hours to 7 days. Batch jobs have their own limits, separate from the per-minute ones.
• Prompt caching charges half price for cached input on the gpt-oss models. A prefix stays cached for about two hours without use. The batch and caching discounts do not stack.
• Flex processing gives 10 times the normal rate limits at the same price. When Groq has no spare capacity, a flex request fails quickly with status 498 and the error capacity_exceeded. You turn it on with "service_tier": "flex" in the request.
• Spend limits cap your monthly bill in dollars. Past the cap, every key gets a 400 error with blocked_api_access until the 1st of the month or until you raise the cap. Groq updates spend every 10 to 15 minutes, so a busy app can pass the cap slightly.

What Groq does with your prompts

Groq's data page says Groq does not keep inference requests by default. In limited cases it keeps logs for reliability and abuse monitoring for up to 30 days. Any customer, on any plan, can turn on Zero Data Retention in the console's data controls. With Zero Data Retention on, Groq keeps no logs, and batch processing and fine-tuning stop working because they need stored files.

Google's terms for the free Gemini API say Google uses your prompts and responses to improve its products, and human reviewers may read them. Groq's data page has no such rule and does not treat free and paid accounts differently.

Groq's free tier next to other free options

Four services give free API access to large language models, each with different limits:

For paid use, Groq is not the cheapest host of gpt-oss-120b. OpenRouter lists more than 20 providers for the model, and the cheapest charge $0.03 per million input tokens and $0.15 per million output tokens, a fifth of Groq's input price and a quarter of its output price. Cerebras charges $0.35 and $0.75. What Groq offers for the higher price is speed. Its LPU chips are built for inference, and our answers streamed at 210 to 350 tokens a second.

Does the Nvidia deal change the free tier?

The deal has not changed the free tier so far. In December 2025, Groq signed a non-exclusive deal that licenses its inference technology to Nvidia. Founder Jonathan Ross, president Sunny Madra and other staff moved to Nvidia, and Simon Edwards became Groq's chief executive. CNBC reported the deal at $20 billion; the companies did not disclose the terms.

Groq said GroqCloud would keep running without interruption, and the free tier still exists ten months later. The free tier now offers fewer models than it did a year ago, and most of the 2026 removals name a gpt-oss model as the replacement.

Running Fireplexity on the free tier

Fireplexity's code still asks Groq for moonshotai/kimi-k2-instruct, which no longer exists, so every search fails until you change the model name. Both model calls are in one file:

$ cp .env.example .env.local      # set FIRECRAWL_API_KEY and GROQ_API_KEY
$ perl -pi -e 's#moonshotai/kimi-k2-instruct#openai/gpt-oss-120b#g' \
    app/api/fireplexity/search/route.ts
$ npm run dev

Groq's free tier gives one person about 40 to 60 answers a day. Firecrawl's free plan, which does the searching and scraping, allows 1,000 credits a month, or 60 to 100 questions. For one person, Firecrawl's monthly credits run out long before Groq's daily token limit becomes a problem. Our self-hosting guide covers the paid plans for both services and the hosting options. Our Firecrawl alternatives page covers cheaper ways to do the search part.

Common questions