Free LLM APIs in 2026: What's Actually Free, and What You Pay Instead

Search for a free LLM API and you get a list. Thirteen providers, fifteen providers, a table of logos, a column of green checkmarks. What almost none of those lists tell you is the part that decides whether the free tier is any use to you: every free LLM API charges you in something. It just isn't cash.

There are three currencies. You pay in your data, you pay in your ceiling, or you pay in your model tier — and usually all three at once. This piece goes through each one with the providers' own documentation, not a secondhand table, and then answers the question those lists skip: what happens when the free tier runs out.

Currency one: your data

This is the one that should decide the question for most teams, and it's the one that gets a footnote at best.

Google's Gemini API pricing page is unusually direct about it. For every model with a free tier, the page lists what happens to your content. On the free tier the line reads "Content used to improve our products." On the paid tier of the same model, the same line reads "Content not used to improve our products." Same model, same endpoint, same code — the only thing that changes is whether Google gets to keep what you sent.

Mistral works the same way with a different default. On La Plateforme, input and output data are used to train models unless you opt out, and free-plan users can opt out — it's a toggle in the Privacy menu of the Admin Console, and once confirmed, Mistral stops using your inputs and outputs for training. Team and Enterprise plans aren't in the training pool at all.

That distinction matters more than it looks. A lot of the roundups you'll find state flatly that Mistral's free tier requires you to accept training. That was true of an earlier policy and it is not true now. If you are evaluating on the basis of a blog post from six months ago you will get this wrong in both directions — assuming a provider is safe when it isn't, or ruling one out when a checkbox would have solved it.

The practical rule: if the prompt contains anything you'd hesitate to paste into a public forum, the free tier is not free. Customer records, internal code, unreleased product copy, anything under an NDA — the cost of a free tier there is a data-governance problem you've quietly created for someone else to find.

Currency two: your ceiling

Free tiers are metered on more axes than people expect, and you hit whichever one runs out first. Groq publishes its free-plan limits per model, and the shape is instructive:

Read those two model rows against each other. Same requests per minute, but the bigger model gives you 1,000 requests a day instead of 14,400 — a fourteen-fold cut for stepping up in capability. And the limits apply at the organization level, not per user, so a second developer on the same account doesn't get their own allowance; they eat into yours.

A daily cap is the one that quietly kills projects. 1,000 requests a day sounds generous until you attach it to anything real: a chat feature with 50 users at 20 turns each is your entire day. A nightly batch job that retries on failure can burn the cap before breakfast. Rate limits per minute you can engineer around with a queue. A per-day ceiling you cannot — you can only wait for midnight.

The number to work out before you build is not "is there a free tier" but "what's my requests-per-day budget per user, and how many users does that support?" If the answer is under a hundred, you are building a demo, and you should know that going in.

Currency three: your model tier

The third cost is the one that shapes what you can actually build: frontier models are not on free tiers, and the gap is widening.

Google's free tier now covers the Flash class and the embedding models — Gemini 3.6 Flash, Gemini 3.5 Flash, Gemini 3.5 Flash-Lite, Gemini 3.1 Flash-Lite, Gemini 2.5 Flash, Gemini 2.5 Flash-Lite and Gemini 2.0 Flash. The Pro line is not on it. That's a deliberate narrowing: Pro-series models were moved to paid-only for API access in 2026, and the free tier has been Flash-and-below since.

This is not a complaint — Flash-class models in 2026 are genuinely strong, and for classification, extraction, routing, summarisation and most retrieval-augmented work they are the correct choice whether or not you're paying. But it does mean a free tier cannot answer the question you most want answered during evaluation, which is "does the good model solve my hard case?" You will be evaluating the cheap model and inferring upward, and that inference is frequently wrong in both directions.

The one that really is free per token

There is a category the roundups usually mention and rarely think through: open-weight models you run yourself. Download the weights, serve them on your own hardware, and the marginal cost per token is genuinely zero. No rate limit, no daily cap, no training clause, no tier — you own the whole thing.

What you've done is move the cost from a line item to a payroll line. Someone has to size the GPU, pick and tune the serving stack, keep it patched, handle the 3 a.m. page when throughput collapses, and re-do all of it when a better checkpoint lands two months later. For a team that already runs infrastructure, that can be the cheapest option by a wide margin at volume. For a team of three shipping a product, an engineer-week spent on inference plumbing costs more than several years of the API bill it replaced.

Self-hosting is the right answer when you have volume, a privacy requirement that admits no other solution, or an existing platform team. It is the wrong answer when what you actually needed was to stop thinking about inference.

The cost nobody puts in the table: free tiers don't compose

Here is the failure mode that actually costs teams time, and it comes from following the free-tier advice too well.

You take the sensible route. Google's free tier for the Flash-class work. A different provider's free tier for fast open-weight inference. A third for speech. Each one is genuinely free, each was a good individual decision. Six weeks later you are holding three API keys, three SDKs, three rate-limit regimes, three billing relationships and three different failure behaviours — and your retry logic, your observability and your cost accounting have to understand all of them.

Then one of them changes. A provider narrows its free tier — as happened when Pro-class models moved to paid-only. Your fallback path was never tested because it never fired. The migration you're now doing is not a config change; it's a refactor of the layer you built to paper over the differences, and you're doing it under time pressure because the thing is already in production.

The free tier was free. The lock-in you accumulated to get it was not. This is the real reason to care about whether your access layer is portable: not ideology about vendor neutrality, but the fact that free tiers are the most volatile part of any provider's offering, and building directly against three of them guarantees you'll be migrating something within the year.

What to actually do

If you're prototyping and the data is not sensitive — take the vendor free tiers, and take them without guilt. They exist for exactly this. Write the integration behind one interface of your own from day one so that swapping the provider is a config change and not a refactor.

If the data is sensitive — do not use a free tier that trains on your inputs. Either pay for the tier where the vendor contractually doesn't (the Google free-versus-paid line is explicit about this), turn off training where the provider allows it on the free plan, or self-host. There is no fourth option, and discovering this after launch is considerably more expensive than the API bill you were avoiding.

If you're evaluating models against each other — the free tier will mislead you, because it doesn't contain the models you'd ship. Evaluate on the tier you intend to run in production, on your own prompts. The cost of a proper eval is a few dollars; the cost of choosing wrong is the quarter.

If you're going to production — the question stops being "what's free" and becomes "what's the cost per token, and what happens when this provider has an outage." Those are different questions with different answers, and a free tier answers neither.

Where OrcaRouter fits

OrcaRouter runs a rotating set of free AI models callable at $0 per token, alongside free API credits from open voucher drops, student programs and partner hackathons. Creating an account and claiming an open offer requires no payment method; the lineup of free models changes as new open-weight and promotional models land, and promo credit from a voucher or hackathon is normally spendable across the whole catalog rather than being scoped to the free models.

The part that matters for the problem described above is what happens next. Everything runs through one OpenAI-compatible endpoint, so the free model you prototype on and the frontier model you ship on are the same integration — a string change in the model field, not a migration. When a free tier narrows or a model is deprecated, you change a model ID. When you need to compare Gemini 3.6 Flash against DeepSeek V4 Flash on your own prompts, you do it without signing up for anything new.

That is the honest pitch for a router in a piece about free APIs: not that we're cheaper than free, but that free tiers are the most volatile thing you can build against, and the cost of that volatility is the thing worth designing away.

The short version

Free LLM APIs in 2026 are real, useful and worth using — for prototyping, for non-sensitive workloads, for learning, and for the large class of tasks a Flash-class model handles perfectly well. They are not a production strategy, and they are not free.

Before you build on one, get three answers in writing from the provider's own documentation rather than a roundup: does this tier train on my data, what is my requests-per-day ceiling, and is the model I'd actually ship even available here? If you can answer all three and still like the deal, take it. If you can't answer them, you haven't priced it — you've just seen the number zero and stopped reading.