Default WorkspaceGuides
429 fallback, coding agents & gateway comparisons
API DocsBYOK & Keys

OpenRouter Free Models (2026): Limits, How to List Them, and Handling 429s

Updated · By Hisham · Published · Facts and limits are dated; check the linked sources.

OpenRouter free models are the model variants whose ID ends in :free: you pay nothing per token, but your requests are capped per minute and per day. If you build on them, you will eventually see 429 Rate limit exceeded or an OpenRouter completion error 429 Provider returned error. Retrying in a loop doesn't fix it, and neither does adding more OpenRouter keys. This guide covers what the free-model limits are and what counts against them (from OpenRouter's own docs), how to find the current list of free models, how to check your API key's free usage, which retries help and which make things worse, and how to fail over across providers with SentioGate without hammering an endpoint that has asked you to wait.

As of 2026-10-30 (rechecked 2026-11-03), from OpenRouter's limits documentation, models documentation and pricing page. OpenRouter changes these, so check the linked pages before you rely on the numbers.

How to find OpenRouter free models (the 2026 list)

OpenRouter adds and retires free variants often, so a list copied into a blog post goes stale fast. Read the live list instead:

  • On the website: open the models page or the model selector in the Chat Playground and search for "free".
  • From the API: GET https://openrouter.ai/api/v1/models returns every model with its pricing. Free variants have an ID ending in :free, with prompt and completion prices of "0".
curl -s https://openrouter.ai/api/v1/models \
  | jq -r '.data[] | select(.id | endswith(":free")) | .id'
  • Let OpenRouter pick: the model ID openrouter/free is OpenRouter's Free Models Router. It picks a free model at random from those available, filtered for the features your request needs, such as tool calling, image input or structured outputs.

Whichever free model you call, the limits below apply to your account.

The free-model limits in one table

Free model variants are the ones whose model ID ends in :free. They have two limits, set by how many credits your account has bought in total:

Credits purchased (all time)Requests per minuteRequests per day
Less than $102050
At least $10201,000
  • The per-minute limit is the same for everyone: 20 requests per minute on free variants.
  • The daily limit is per account, per UTC day. Buying $10 of credits once (all time) raises it from 50 to 1,000. OpenRouter notes it grants the higher ceiling starting one credit below the threshold, to absorb rounding and top-up fees.
  • Paid variants have no platform-level request cap. On paid models, limits come from the provider serving the request, apart from DDoS protection against traffic that dramatically exceeds reasonable usage.

What counts, and what does not

  • Failed attempts count toward the daily cap (pricing FAQ). A client that retries a failing request in a tight loop uses up the day quickly.
  • More accounts or API keys do not raise the limits. OpenRouter: "Making additional accounts or API keys will not affect your rate limits, as we govern capacity globally." Rotating keys on one account doesn't get around a free-tier cap.
  • A negative credit balance blocks free models too. You may see 402 errors on free models until you add credits and bring the balance above zero.
  • BYOK requests are not gated by the free-model daily counter.

How to check your API key's free usage limits

Call GET https://openrouter.ai/api/v1/key with your key. The response includes free_model_daily_requests with used, limit and remaining for the current UTC day. The per-minute limit is not reported there. The same response shows limit_remaining, the credit left on the key if you set a spending cap on it.

curl -s https://openrouter.ai/api/v1/key \
  -H "Authorization: Bearer $OPENROUTER_API_KEY"

When OpenRouter itself rejects a request for a platform limit, the 429 response carries X-RateLimit-Limit, X-RateLimit-Remaining and X-RateLimit-Reset headers for the limit you hit. Successful responses don't include them, so poll the key endpoint if you want to watch your usage before you run out.

Where a 429 comes from

  1. OpenRouter itself, when you exceed the free-model per-minute or per-day limit (or DDoS protection).
  2. The upstream provider, when the provider serving that model is rate limiting or at capacity. OpenRouter already retries other providers for the same model before the error reaches you.

Why OpenRouter says "Provider returned error" on a 429

When your logs show an OpenRouter completion error 429 with message Provider returned error, the rate limit came from the upstream inference provider hosting that model rather than your personal OpenRouter account counter. Even if you still have requests left in your daily allowance, every upstream host serving that :free model is throttled right now. Retrying the same model immediately just hits the same bottleneck; failing over to a different model or another provider (such as Groq or Gemini on your own keys) is the fastest way to recover.

Mid-stream limits don't come back as HTTP 429

If the limit hits after streaming has started, the error arrives as an SSE event with finish_reason: "error", because the 200 status has already been sent. Your stream parser has to check for it.

Retries that help, and retries that hurt

A 429 tells you to wait. How long to wait, and whether to wait at all, depends on which limit you hit:

SituationWhat to do
Per-minute limitWait. Honor Retry-After when it's present, otherwise back off exponentially with jitter. Retrying is fine.
Daily free-model cap reachedDon't retry the same free model today. Every :free model on that account shares the cap, and it resets with the UTC day. Switch models or providers.
Upstream provider at capacityOpenRouter's model fallbacks (models: [...]) can move you to another model.
Every option is cooling downReturn a fast, honest error with a Retry-After to your caller instead of holding the request open.

Two traps:

  • OpenRouter's own models fallback stays inside OpenRouter. It's useful against one model's providers being down. But if you hit the account-wide free cap, falling back to another :free model hits the same cap. OpenRouter also notes that if a :free model is followed by a paid model in models, you're billed for the paid one.
  • Hot-loop retries make it worse. Failed attempts count toward the daily cap, and an immediate retry uses up the per-minute window for nothing.

Client-side retries help with brief traffic spikes, but when a provider or account hits its daily ceiling, retrying the same endpoint only exhausts limits faster. Cross-provider failover, cooldown state shared across processes, and multi-key fallback without client stalls are where a gateway helps.

Options when the free limits are not enough

  • Buy $10 of credits once to move from 50 to 1,000 free requests a day. Note OpenRouter's 5.5% (Standard) fee on credit purchases.
  • Switch to the paid variant of the model, which has no platform-level request cap.
  • Use your own provider keys. On Standard and Business, OpenRouter includes $25,000 of list-price inference per month through BYOK with no fee, then 5%.
  • Fail over across providers you already have, as below.
  • Compare other free tiers. See the free LLM API list and the best OpenRouter alternatives.

Cross-provider fallback with SentioGate

SentioGate is an OpenAI-compatible, bring-your-own-key (BYOK) router. You keep your OpenRouter, Groq, Gemini, Mistral, DeepSeek or xAI keys in its encrypted Vault (or pass them per request), send model: "auto", and it handles the failover. Here's what it does on a 429, as implemented today:

  1. Remembers the cooldown. A 429 puts that model on that key into a cooldown that's shared across requests. It honors the upstream Retry-After, and uses a short default when there's no Retry-After.
  2. Recognizes the daily free-model cap. When OpenRouter's error says the daily free-model limit was hit, all :free models on that key cool down until 00:00 UTC (or the Retry-After, if one is sent), instead of being tried one by one.
  3. Tries your next key for the same model, then (with auto) the next model. Same model on your next key first (useful for paid keys and other providers; OpenRouter itself says extra keys don't raise its free limits). With model: "auto" it then moves to the next-ranked model in your enabled pool, which can be on another provider, skipping models that are cooling down. A pinned provider/model only gets key failover; it never silently switches models. On the hosted service an auto request tries healthy candidate models within a bounded timeout budget.
  4. Fails fast and honestly. If nothing is available, you get 429 with code: "upstream_rate_limited" and a Retry-After header. The request isn't left hanging.

auto only routes to models you've enabled in the Vault's model list, so enable the :free variants you want there, next to your Groq or Gemini models.

Python (SDK 1.2.0)

# pip install sentiogate-python
import os
from sentiogate import AutoRouterClient, RouterClientError

router = AutoRouterClient(
    api_key=os.environ["SENTIOGATE_API_KEY"],  # sg_live_...
    max_retries=2,       # off by default; retries only transient 429s, only after Retry-After (>= 1 s)
    max_retry_wait=30,   # never sleeps longer than this; a longer Retry-After raises instead
)
try:
    resp = router.chat(messages=[{"role": "user", "content": "Reply with exactly: pong"}])  # model="auto"
    print(resp["model"], resp["choices"][0]["message"]["content"])
    print(resp.get("router", {}).get("attempts"))  # BYOK: which provider/model attempts were made
except RouterClientError as e:
    print(e.status_code, e.code, e.retry_after)  # e.g. 429 upstream_rate_limited 60.0

JavaScript / TypeScript (streaming)

// npm i @sentiogate/sdk
import { AutoRouter, RouterClientError } from '@sentiogate/sdk';

const router = new AutoRouter({ apiKey: process.env.SENTIOGATE_API_KEY, maxRetries: 2, maxRetryWaitMs: 30000 });
try {
  for await (const chunk of router.streamChat({ messages: [{ role: 'user', content: 'Count from 1 to 5.' }] })) {
    process.stdout.write(chunk.choices?.[0]?.delta?.content || '');
  }
} catch (e) {
  // 429s and 403s arrive before the first chunk, so you can still retry or fall back cleanly.
  if (e instanceof RouterClientError) console.error(e.statusCode, e.code, e.retryAfter);
  else throw e;
}

Any OpenAI client

import os
from openai import OpenAI
client = OpenAI(base_url="https://api.sentiogate.dev/v1", api_key=os.environ["SENTIOGATE_API_KEY"])
r = client.chat.completions.create(model="auto", messages=[{"role": "user", "content": "hi"}])

The OpenAI SDK has its own retry logic for 429s. If you also set SentioGate SDK retries, pick one layer to do the retrying, not both.

No keys yet? The free community pool

With a SentioGate API key and no provider keys, requests go to the free community pool. Send model: "auto". During the beta it allows 600 requests per 5 hours per user, for testing your integration rather than production traffic. When you use up your requests, you get a 429 community_pool_exhausted whose Retry-After header is the time until your window frees up. If the pool is briefly busy, you get a 503 community_busy with a short Retry-After instead. Wait for the Retry-After before retrying, and add your own keys in the Vault for production.

FAQ

Where can I find the list of OpenRouter free models?

Search for "free" on the OpenRouter models page, or call GET https://openrouter.ai/api/v1/models and keep the IDs ending in :free. The list changes often, so read it live instead of hard-coding it. The model ID openrouter/free picks a free model for you.

How do I check my OpenRouter API key's free usage?

Call GET https://openrouter.ai/api/v1/key with the key. The free_model_daily_requests field shows used, limit and remaining for the current UTC day. The per-minute limit is not reported there.

Why does OpenRouter return 429 on free models?

Either you hit OpenRouter's limit for :free models (20 requests per minute, and 50 per day, or 1,000 per day once the account has bought at least $10 of credits), or the upstream provider serving that model is at capacity.

What does "Provider returned error" mean on an OpenRouter 429?

The limit came from the upstream provider hosting that model, not from your own OpenRouter counter. Retrying the same model right away hits the same bottleneck, so switch to a different model or provider.

When does the OpenRouter daily free limit reset?

OpenRouter counts it per UTC day, so it resets at 00:00 UTC. Every :free model on the account shares the cap, and more keys or accounts do not raise it.

Why do I get 402 on a free model?

A negative credit balance can block free models. Add credits to bring the balance above zero.

What does SentioGate do when the daily free-model cap is hit?

It cools down all :free models on that key until 00:00 UTC (or the Retry-After, if one is sent) instead of trying them one by one. With model: "auto" it then moves to your next enabled model, which can be on another provider such as Groq or Gemini.

Sources