Free LLM APIs: which models are free and what limits apply

As of November 2026, the most useful free LLM API options are OpenRouter's ":free" models (20 requests per minute, 50 per day, or 1,000 per day once you have bought $10 of credits), Cerebras (1 million tokens per day), Cloudflare Workers AI (10,000 neurons per day) and Google's Gemini API free tier. The catches are daily caps, model IDs that expire, and free tiers that may train on your prompts.

Free inference is easy to find in 2026. The harder question is how much work it does before it stops. A free tier is a rate limit plus a set of data terms, and both decide whether it is useful to you. Below we go through the providers worth using, what each one gives away, and then do the arithmetic on a coding agent.

Which free LLM APIs are worth using right now?

Most free LLM APIs fall into one of three types. Aggregators such as OpenRouter route free requests to whichever provider is subsidizing a model. Model labs such as Google and Cohere give a free tier on their own API to get developers started. Fast-inference clouds such as Cerebras, Cloudflare and NVIDIA give daily allowances so you try their hardware.

The table below lists the limits each provider publishes. Where a provider sets limits per model or changes them often, we say so and link the page.

Groq, Mistral's La Plateforme, GitHub Models and Hugging Face also have free access. Their caps are set per model or per plan and move often enough that we would only be quoting a snapshot, so check their consoles directly. Hugging Face, for example, gives a small monthly credit for its inference providers, and GitHub Models ties limits to your Copilot plan.

One honest caveat on the whole table: none of these limits are contracts. Free tiers get cut with little notice, and no provider publishes a history of how often that happens.

What are OpenRouter's free model limits?

OpenRouter is the reason the query "openrouter free models" has 2,400 monthly searches. Any model ID ending in ":free" costs nothing, and OpenRouter's FAQ sets the limits at 20 requests per minute and 50 requests per day. Buy at least $10 of credits once and the daily cap rises to 1,000 free-model requests.

What this means is that $10 is the price of a 20x larger free tier, and you keep the $10 as credit for paid models.

Now, the not so great news. A free variant is a provider choosing to subsidize a model on OpenRouter, so it can be slower, more crowded at peak hours, and gone next month. Some upstream providers also log prompts on free endpoints, which is why OpenRouter has privacy settings to exclude endpoints that may train on inputs. If you need a comparison with a gateway that does not run a free-tier marketplace, we covered that in our OpenRouter alternative write-up.

Do free tiers train on your prompts?

Some do, and the clearest case is Google. The Gemini API terms split services into paid and unpaid. For unpaid services, Google says it uses the content you submit to provide, improve and develop its products and machine learning technologies, and that human reviewers may read and annotate inputs and outputs. Simon Willison flagged this in October 2024, and the terms still draw the same line.

The rest are less clear-cut. Aggregators pass your prompt to whichever company is serving the free model, so the training terms are that company's terms. Providers with ongoing allowances (Cloudflare, Cerebras) tend to publish one set of data terms for free and paid use, but we would read them before sending anything you would not post publicly.

The rule we use is simple: assume a free tier may keep your prompts unless the provider's terms say in writing that it does not. That rules out customer data, credentials, unreleased code from a client, and anything covered by a DPA.

Best free models for coding

Coding is the most common reason people look for a free AI API, and it is also the workload that hits free caps fastest. A coding agent re-sends the file context, the conversation and the tool results on every step. That means one "fix this bug" task becomes 10 to 20 requests, each carrying tens of thousands of input tokens.

For quality, the free models worth trying are the open-weight coding models served on OpenRouter's ":free" list and on Cerebras. Which one leads changes month to month, so we would not trust a static ranking. Our Requesty coding benchmark tests 25 models on 129 real backend tasks, and our guide to the best AI coding model weighs cost against quality. Use those to pick the paid model you fall back to when the free one runs out.

How far does a free tier stretch for a coding agent?

Take a developer running an agent in Cline or Continue on a free model for a day. We want to know how many tasks the free tier covers before it stops answering.

Our assumptions:

• Each agent request carries ~20,000 input tokens (system prompt, open files, conversation so far) and ~1,000 output tokens, so ~21,000 tokens per request.
• One task (a bug fix or a small feature) takes ~15 requests.
• The developer does 10 tasks on a normal day.

The weakest input is the 20,000 tokens per request. Context grows as a task goes on, so early requests are smaller and late ones larger, and repositories differ a lot.

On a 1 million tokens per day tier such as Cerebras, 1,000,000 / 21,000 is about 47 requests, or roughly 3 tasks. On OpenRouter without credits, the 50 requests per day cap gives about the same: 50 / 15 is just over 3 tasks. With $10 of credits bought, 1,000 requests per day covers about 66 tasks on request count alone. The 20 RPM limit becomes the constraint at that point, since an agent firing requests in quick succession can hit 20 in a minute.

Even if we double the context to 40,000 input tokens per request, the token-capped tier drops to ~24 requests, or under 2 tasks a day. The request-capped OpenRouter tier does not change, because it counts requests, not tokens. Halve the context and the token tier only reaches about 6 tasks. Our 10-task day needs ~150 requests and ~3.2 million tokens, so on any of these numbers a token-capped free tier covers a fraction of a working day.

The second-order effect is that the free tier is not where your coding costs go away. It is where you (i) prototype the agent setup and (ii) run evals on candidate models before picking a paid one. Teams running Claude Code or Cursor at scale have a different problem, which we cover in managing coding tool costs across a team.

Why free model IDs expire

Most free model access is promotional. A lab launches a model, pays an aggregator or inference cloud to serve it at zero price for a few weeks, collects usage and feedback, then switches the ID to paid or removes it. That is a fine deal for you as long as you know the end date.

The risk is building on an ID that stops working on a Tuesday afternoon. Requesty now ships an expiry date with each free model ID, and we explained the reasoning in free model IDs now ship with expiry dates. Elsewhere you usually find out when requests start returning errors.

So what should you do with free LLM APIs?

Use them for what they are good at: prototyping, evals and side projects where a 429 at 4pm is fine. For anything users touch, treat the free model as the first link in a chain and not the whole chain.

Three things to set up now. First, keep a failover chain across free tiers and a paid model, so a cap on one provider sends the request to the next. Second, track expiry dates on every free model ID you use. Third, keep sensitive prompts on paid endpoints with data terms you have read.

Requesty does the chain part through one OpenAI-compatible API: change your base URL to https://router.requesty.ai/v1 (or router.eu.requesty.ai/v1 for the EU endpoint) and set up a fallback policy that tries the free model first, then a paid one. You can bring your own provider keys or use one Requesty key, put budget caps on the paid fallback, and pay 5% on top of model costs. See the free models docs and the current list with expiry dates at requesty.ai/free-models. If you are moving from several provider SDKs to one, one API for GPT, Claude, Gemini and open-weight models walks through the switch.

import os
from openai import OpenAI
 
client = OpenAI(
    base_url="https://router.requesty.ai/v1",
    api_key=os.environ["REQUESTY_API_KEY"],
)
 
response = client.chat.completions.create(
    model=os.environ["REQUESTY_MODEL"],
    messages=[{"role": "user", "content": "Summarize this diff."}],
)
print(response.choices[0].message.content)

import OpenAI from "openai";
 
const client = new OpenAI({
  baseURL: "https://router.requesty.ai/v1",
  apiKey: process.env.REQUESTY_API_KEY,
});
 
const response = await client.chat.completions.create({
  model: process.env.REQUESTY_MODEL!,
  messages: [{ role: "user", content: "Summarize this diff." }],
});
console.log(response.choices[0].message.content);

Set REQUESTY_MODEL to a free model ID from the free models page or to a fallback policy name. When the free ID expires, you change one environment variable instead of your code.