OpenRouter Free Models: Limits and Trade-offs

Every few months I rebuild the model list behind my content pipelines, and every time I start by checking what OpenRouter is giving away. The free tier is real. It is also narrower and stranger than most write-ups admit, and the interesting part is not the price — it is what sits underneath a zero in the pricing column.

This is what free access looks like today, what it costs you in ways that never show up on an invoice, and where the ceiling is.

What "free" actually means on OpenRouter

OpenRouter is an aggregator: one API key, one OpenAI-compatible endpoint, hundreds of models behind it. Free models are the ones whose identifier ends in `:free` — the price is zero on both input and output tokens.

That suffix is a property of a specific deployment, not a permanent promise about the model. The same model can exist as a paid endpoint and a free one, served by different providers on different terms. OpenRouter says it expands free capacity by onboarding providers and, in some cases, covering the cost itself. It also says plainly that it cannot guarantee what the future holds. Treat any given free endpoint as a temporary arrangement.

There is also a shortcut: `openrouter/free`, a router that picks a free model at random for you. It filters the pool by what your request needs — vision, tool calling, structured outputs — and the response tells you which model it landed on. Useful when you want zero-cost inference and genuinely do not care which model answers.

The free tier limits, verified against the docs

There are two separate systems here, and confusing them wastes a lot of debugging time.

**Rate limits** govern how many requests you make, and they are what people mean by "the free tier." For any model ending in `:free`:

| Credits purchased, all time | Requests per minute | Requests per day | | --- | --- | --- | | Less than $10 | 20 | 50 | | At least $10 | 20 | 1000 |

Two things worth noticing. The per-minute ceiling does not move at all — paying does not make you faster, only more persistent. And the daily jump is tied to *having purchased* credits at some point, not to your current balance. Spend it all down and the higher daily allowance stays.

**Credit limits** govern spending and return a `402`. This one surprises people: if your account balance goes negative, you can get `402` errors on free models too. Zero-priced requests still run against an account that has to be in good standing.

Fifty requests a day is not a small production budget. It is barely a testing budget. One agent run with a few tool-calling iterations can eat a tenth of it before you have looked at any output.

Also worth knowing before you get clever: opening extra accounts or minting extra API keys does not help. OpenRouter governs capacity globally. Different models carry different limits, so spreading load across models is the only spreading that works.

Because this table moves, check it against the official limits page in OpenRouter's docs rather than any blog post, mine included. You can also query your own state directly — a `GET` to `https://openrouter.ai/api/v1/key` returns `is_free_tier`, daily usage, and remaining credit.

What you pay with instead of money

This is the part I care about most, and the part most listicles skip.

**Your prompts may train someone's model.** Provider policies differ, and OpenRouter surfaces them as structured data on every endpoint. Some free model cards say it outright. Poolside's free Laguna endpoint states that if you use it for free, your inputs and outputs may be used to train and improve their models. Liquid's free LFM endpoint says prompts and outputs may be retained and used to train Liquid models.

You do have a switch. Account settings let you refuse routing to providers that may train on your data — with **separate toggles for paid and free models**, which is exactly the trap. People opt out for paid, assume it covers everything, and keep feeding free endpoints. You can also enforce a data policy per request rather than account-wide.

**Retention varies wildly.** Across providers you will find zero retention, 30-day retention, 55-day retention, and a fair number listed as retained for an unknown period. If you are pushing anything belonging to a client through a free route, "unknown period" is your answer and it is not a good one.

**Capacity is best-effort.** Free endpoints are the first place a busy provider throttles. A `429` on OpenRouter can come from OpenRouter's own limits or from the upstream provider being at capacity — the error metadata carries the provider's original code when it is available. OpenRouter will retry other providers for the same model automatically, but if a model is only served free by one provider, there is nowhere to fall back to.

So the honest framing is: free costs you privacy control, predictability, and sometimes latency. For experiments that is a fine trade. For anything with a deadline it is not.

How to pick a free model for the job

The free catalogue rotates constantly, so I never hardcode a favourite. I pick by shape of task instead.

**Long-context reading and agent orchestration.** The free pool currently includes some genuinely large-context options — million-token windows are no longer exotic here. Good for digesting a pile of documents in one pass.

**Coding and tool use.** Several coding-specialised models sit in the free tier, and they are often the ones most explicit about training on your inputs. Fine for scratch work, poor for proprietary code.

**Small, fast, cheap-to-be-wrong.** Compact models handle extraction, classification, reranking, and RAG glue. This is where free tier economics actually make sense: high volume, low stakes, short outputs.

**Anything you would show a client.** Do not use a free endpoint as your production writer. Free deployments get retired without ceremony, and discovering that mid-batch is the worst way to learn it.

Practical rule: write your code against a *list* of models with automatic fallback on error, never a single hardcoded ID. OpenRouter supports model fallbacks natively. This one habit turns "the model disappeared" from an outage into a log line.

Errors you will actually hit

Three status codes cover almost everything, and they mean different things:

• **401** — the key itself is wrong, revoked, or malformed. Nothing to do with quota. The [same diagnostic logic applies across providers](https://ai-seowriter.ru/en/blog/invalid-api-key-openai) when a key stops being accepted.
• **402** — spending problem. Negative balance, or a per-key credit cap exhausted. Yes, on free models too.
• **429** — rate limited. Either you crossed 20 per minute or the daily cap, or the upstream provider is saturated.

One detail that costs people an afternoon: successful responses do not carry `X-RateLimit-*` headers. You cannot poll your remaining quota by inspecting normal traffic. Check the key endpoint, or count your own requests.

When free stops being the cheap option

The moment your usage becomes rhythmic rather than exploratory, free is working against you. Signals I watch for:

• You are batching. Fifty requests a day dies on the first real batch.
• You are writing retry logic to dodge 429s. That is a paid tier with extra steps.
• Output quality varies between runs because the router landed on a different model.
• You are sending anything you would not be comfortable seeing in a training set.

Any one of those and the $10 that unlocks the higher daily allowance is the cheapest infrastructure decision available. Any two, and you belong on paid endpoints with a known provider and a known data policy.

Free tiers outside OpenRouter

Aggregators are convenient, not obligatory. Most major providers run their own free or trial tiers, and going direct often means a clearer deal, because you are reading one company's policy instead of an aggregate of dozens. Getting started is usually a matter of [creating a key in the provider's own console](https://ai-seowriter.ru/en/blog/api-klyuch-gemini) and pointing your client at their endpoint.

Availability and quotas differ by region and change often enough that I will not quote numbers here. Check each provider's current documentation before you build against it.

And if what you actually need at the end of the chain is finished, published articles rather than raw model responses, the aggregator may not belong in the pipeline at all — a [dedicated SEO article generator](https://ai-seowriter.ru/en/generator-seo-statej) handles keys, generation, and publishing as one flow, which takes the rate-limit question off your desk entirely.

The short version

Free on OpenRouter is real: zero-priced endpoints, 20 requests a minute, 50 a day until you have ever bought $10 of credit, then 1000 a day. It is an excellent way to find out whether a model can do your task at all.

It is a poor foundation for anything scheduled, confidential, or client-facing — because free endpoints rotate, some providers train on what you send, and your per-minute ceiling never rises no matter what you pay. Use it to decide, not to run.