Most developers hit the same wall once they start building with large language models. The prototype works, and then the API bill starts tracking every experiment. Frontier models still bill by the token. Claude Opus 5.5 lists at $4 per million input tokens and $20 per million output tokens, and that adds up fast once you are calling it in a loop.
Search for 'free AI API unlimited tokens' and you will find a pile of posts promising a way around that. The honest version is less exciting but more useful. OpenRouter gives you no-credit-card access to a rotating set of models at $0 per token, but 'unlimited' is not the right word. You get 20 requests per minute and either 50 or 1,000 requests per day, depending on whether you have bought $10 of credits. No token cap, but a very real request cap.
The free list also turns over fast. In July 2026, Owl Alpha, Tencent Hy3, Qwen3 Coder and gpt-oss-120b were all free on OpenRouter; none of them is free today, and the lineup is led by Thinking Machines Lab's 975-billion-parameter Inkling and NVIDIA's Nemotron family. Every limit, price and model ID below was checked against OpenRouter's live API and model pages on October 27, 2026.
Here is the current free lineup at a glance before we get into the mechanics:
| Model | Size | Context (free) | Best For |
|---|---|---|---|
| Thinking Machines Inkling | 975B / 41B active MoE | 1M tokens | Coding and agent harnesses, text, image and audio input |
| NVIDIA Nemotron 3 Ultra | 550B / 55B active MoE | 1M tokens | General reasoning, agent orchestration |
| NVIDIA Nemotron 3.5 Super VL | 120B / 12B active MoE | 1M tokens | Documents, screenshots and video input |
| Google Gemma 4 | 31B dense / 26B-A4B MoE | 262K tokens | Multimodal input, function calling, 140+ languages |
| Poolside Laguna S 2.1 | 118B / 8B active MoE | 262K tokens | Coding agents, going away October 31, 2026 |
| openrouter/free | Router over the free models | 200K tokens | Code that should keep working as models rotate |
That table covers the six worth knowing individually. Counting embedding, reranking, speech and 'decision' models, OpenRouter lists 28 model IDs ending in :free right now, 16 of them chat models, and we get to the rest further down.
The Free Tier: Rate Limits, Not Token Limits
This is the part most 'unlimited tokens' articles get wrong. OpenRouter's free models charge $0.00 per input token and $0.00 per output token, so there is genuinely no token-based billing. What every account does have is a request cap, documented on OpenRouter's limits page:
- 20 requests per minute, always, regardless of account status
- 50 requests per day if you have bought less than $10 of credits in total
- 1,000 requests per day once your credit purchases reach $10
The docs say the daily tier is selected by all-time credits purchased, so it counts what you have bought over the account's lifetime, not your current balance. Once you cross $10, the higher ceiling stays even if your balance later drops to zero. In practice the 1,000 tier starts at 9 credits, one below the threshold, which OpenRouter says absorbs rounding and top-up fees.
So a 100,000-token conversation costs you one request, same as a two-word prompt, and an agent loop that calls the model dozens of times per task hits the daily ceiling long before any token count matters. Two more things can stop you: Cloudflare's DDoS protection blocks requests that dramatically exceed reasonable usage, and a negative credit balance can block free models too, with 402 errors. That mostly happens if you use paid models alongside free ones and let the balance run dry.
Checking How Many Free Requests You Have Left
OpenRouter reports the daily counter on its key endpoint:
curl https://openrouter.ai/api/v1/key -H 'Authorization: Bearer $OPENROUTER_API_KEY'
The response includes a free_model_daily_requests object with used, limit and remaining counts for the current UTC day. An agent can check it before a long run instead of discovering the ceiling through 429 'Rate limit exceeded' errors halfway through. It does not report the per-minute limit, though. When you do hit a limit, the 429 response carries X-RateLimit-* headers describing the one you hit.
A quick parsing pattern with jq makes this easier to use in a script:
curl -s https://openrouter.ai/api/v1/key -H 'Authorization: Bearer $OPENROUTER_API_KEY' | jq '.free_model_daily_requests'
That gives you something like {"used": 12, "limit": 50, "remaining": 38}. You can recieve these values before launching a batch job and stop early if the remaining count is too low. The remaining field is the one that matters most because it tells you how many requests are still available for the rest of the UTC day.
Getting Set Up
- Go to the OpenRouter keys page and sign up with email or GitHub. No credit card is needed for free models.
- Generate an API key on that page. You can optionally cap each key with a credit limit.
- Optional, recommended: buy credits. Pay-as-you-go carries a 5.5% platform fee on credit purchases, and $10 of purchases in total is what raises your free-model ceiling to 1,000 requests a day. It is a one-time threshold, not a subscription.
- Call the API. Free models carry a
:freesuffix on their model ID, and OpenRouter's Free Models collection is the fastest way to see what is available today.
If you only plan to use free models, you can stop at step 2 and spend $0. The $10 is purely about the daily ceiling, and it is worth buying once a project becomes something you use every day, because 50 requests disappear fast when you are iterating on prompts. Before you buy, note that OpenRouter's FAQ says OpenRouter reserves the right to expire unused credits a year after purchase.
Calling a Free Model
Because OpenRouter mirrors the OpenAI API shape, you can use curl directly or the standard OpenAI Python SDK pointed at a different base URL. Here is the raw HTTP version:
curl https://openrouter.ai/api/v1/chat/completions -H 'Content-Type: application/json' -H 'Authorization: Bearer $OPENROUTER_API_KEY' -d '{"model": "nvidia/nemotron-3-ultra-550b-a55b:free", "messages": [{"role": "user", "content": "Explain the difference between MoE and dense transformer architectures in two sentences."}]}'
And the same call using the official OpenAI Python SDK, just repointed at OpenRouter:
from openai import OpenAI
client = OpenAI(
base_url='https://openrouter.ai/api/v1',
api_key='sk-or-v1-your-key-here',
)
response = client.chat.completions.create(
model='nvidia/nemotron-3-ultra-550b-a55b:free',
messages=[
{'role': 'user', 'content': 'Explain the difference between MoE and dense transformer architectures in two sentences.'}
],
)
print(response.choices[0].message.content)
No OpenRouter-specific SDK, no custom client library. If your code already talks to the OpenAI API, changing base_url and the model string is the entire migration.
Understanding Free Model IDs and Endpoint Behavior
Every free model has the suffix :free at the end of its model ID. That suffix is the only thing that makes it free. The base URL is still https://openrouter.ai/api/v1, the authentication is still the same API key, and the request format is the same as the OpenAI-compatible interface. If you remove the suffix from a model ID, the same model may become a paid listing, so the suffix is not decorative. It is a routing tag that tells OpenRouter which pricing tier to apply.
The openrouter/free router does not carry the suffix because it is not a model in the traditional sense. It is an alias that resolves to a random free model that supports your request's required features. This is useful for quick experiments, but it makes behavior less predictable. You cannot assume which model will answer, and some free models are much slower than others.
The Free Models collection on OpenRouter is generated from the same API data that is used for the model list, so it is more reliable than a blog post that was written a month ago. Bookmark that page if you are planning to depend on free models.
Context Windows and Output Limits
Free models do not all have the same context window. The table above shows that several top models offer 1M tokens on their free endpoints, while others like Gemma 4 stop at 262K tokens. Context window is not the same as output limit. A model with a 1M context can still cap the number of tokens it generates in one response. For example, NVIDIA Nemotron 3 Ultra allows up to 65,536 output tokens on its free endpoint. That is generous, but it is not infinite. If you send a prompt that asks for many separate tasks, you may hit the output cap even though the context window has room.
When you use the OpenAI SDK, you can control the output size with max_tokens or with the newer max_completion_tokens parameter. For an OpenRouter request, max_tokens is the safer choice because many providers on the platform still use it. If you request more output tokens than the endpoint allows, the provider may reject the request or truncate it depending on the model. The response object includes a finish_reason field. A finish_reason of length means the model reached its token limit before completing the message.
response = client.chat.completions.create(
model='nvidia/nemotron-3-ultra-550b-a55b:free',
max_tokens=1024,
messages=[
{'role': 'user', 'content': 'Write a detailed design document for a rate-limited API gateway.'}
],
)
if response.choices[0].finish_reason == 'length':
print('Response was truncated by the output token limit.')
This matters more on free models because you do not want to waste a request on a response that gets cut off at the wrong place. If you need longer outputs, retry with a higher max, use a model with a larger output budget, or ask the model to continue from the last sentence.
Rate Limit Headers and Backoff
When you exceed the per-minute limit or the daily limit, OpenRouter responds with HTTP 429 and a set of X-RateLimit-* headers. The headers tell you which limit was hit and when it resets. A robust client should read those headers and back off instead of retrying immediately.
Here is a minimal Python retry loop that respects the reset time:
import time
import requests
url = 'https://openrouter.ai/api/v1/chat/completions'
headers = {
'Authorization': 'Bearer sk-or-v1-your-key-here',
'Content-Type': 'application/json'
}
payload = {
'model': 'nvidia/nemotron-3-ultra-550b-a55b:free',
'messages': [{'role': 'user', 'content': 'Hello from a rate limited client.'}]
}
for attempt in range(5):
resp = requests.post(url, json=payload, headers=headers)
if resp.status_code == 200:
break
if resp.status_code == 429:
reset_time = int(resp.headers.get('X-RateLimit-Reset', '0'))
wait_time = max(1, reset_time - int(time.time()))
time.sleep(wait_time)
else:
resp.raise_for_status()
X-RateLimit-Reset may be a Unix timestamp. If the header is not present, fall back to a fixed sleep. Do not hammer the endpoint; that can trigger Cloudflare's DDoS protection and get your IP blocked.
Handling Rotation and Rate Limits with Fallback Models
The single most important production tip for the free tier: do not hardcode one free model. Free variants get pulled or repriced without much warning. Between July and late October 2026, qwen/qwen3-coder:free, openai/gpt-oss-120b:free, tencent/hy3:free and nvidia/nemotron-3-super-120b-a12b:free have all disappeared, and any code pinned to them now fails. OpenRouter's models array lets you list several candidates in priority order in one request:
{
"models": [
"nvidia/nemotron-3-ultra-550b-a55b:free",
"google/gemma-4-31b-it:free",
"nvidia/nemotron-3.5-lightning:free"
],
"messages": [
{"role": "user", "content": "Summarize this changelog in three bullet points."}
]
}
By default any error can send the request to the next model, including context-length errors, moderation flags, rate limiting and provider downtime. You are billed for whichever model answered, and its ID comes back in the response's model field, so you can log which fallback fired. Keep every entry a :free model: if the list falls through to a paid one, you pay that model's rate.
The exact configuraton of your fallback list will depend on what capabilities you need. If you need tool calling or structured outputs, check the model page for each candidate before adding it. Not every free model supports every feature. A router model can help here, but it is not a replacement for a fallback strategy.
If you would rather not manage a list at all, openrouter/free is a router that picks a free model at random from the ones that support what your request needs, such as tool calling, structured outputs or image input. It trades predictability for convenience: you do not control which model answers, but your code keeps working as the free lineup changes.
How Free Models Leave OpenRouter
Three months ago the free list looked different. In July, Nemotron 3 Ultra, Gemma 4, Owl Alpha, Tencent Hy3, Qwen3 Coder and gpt-oss-120b were all free. Only the first two still are, and the other four show the different ways a free listing ends.
Owl Alpha turned out to be Meituan's LongCat-2.0. It was a stealth model, a prerelease checkpoint OpenRouter serves for free under a codename while the lab collects real-world usage. At the end of June, Meituan's LongCat team introduced LongCat-2.0 as the full model behind Owl Alpha: 1.6 trillion parameters, about 48B active per token, and a 1M-token context. The weights are on Hugging Face under the MIT license, and on OpenRouter meituan/longcat-2.0 costs $0.30/M input and $1.20/M output, currently shown as a discounted price.
The same pattern occured again this fall. A stealth model called Space Bunny left OpenRouter on October 5 and came back on October 19 as MiniMax M3.1 Flash, free for 72 hours and now paid, from $0.143/M input. As of October 27 there is no stealth model on the list, so do not plan around one.
Tencent Hy3's free window closed. Tencent had set July 21 as the end date for the free listing, and Hy3 is now paid only, from $0.0825/M input and $0.33/M output through Tencent's own endpoint.
Qwen3 Coder and gpt-oss-120b lost their :free variants. Both are still on OpenRouter as paid models: Qwen3 Coder from $0.22/M input, and gpt-oss-120b from $0.03/M input and $0.15/M output across about two dozen providers. At that price gpt-oss is close to free anyway. Smaller free models from July went the same way: the free Llama 3.3 70B, Llama 3.2 3B and Hermes 3 405B variants are gone, and NVIDIA's Nemotron 3 Super lost its free endpoint in late October. DeepSeek still has no free model, though V4.1 Flash is listed at $0.14/M input and $0.42/M output.
This churn is not a bug. Free endpoints exist to promote labs, gather telemetry, and push adoption. Once a model has enough traction, the free tier goes away. The best defense is to treat the free catalog as a pool of interchangeable endpoints rather than a set of permanent providers.
How to Keep Up With Rotation
Because free model lists change quickly, a weekly review is reasonable. Open an issue in your repo or use a scheduled job that queries the model list and filters by :free. Keep the list in your README so other contributors know not to hardcode a model that might disappear.
Another practical habit is to add a comment next to each free model ID in your config file with the date it was verified. When the list changes, you know exactly which entries need to be updated. This has saved many debugging sessions.
If you use a shared team account, tell everyone to check the OpenRouter Free Models collection before they start a new integration. It only takes a minute and it prevents the most common failure mode: a hardcoded model that was removed from the free tier overnight.
The Free Model Catalog Right Now
OpenRouter's free lineup is a moving target: models get added when labs promote a launch, and pulled when the promotion ends. On October 27, 2026, the API lists 28 model IDs ending in :free: 16 chat models, seven embedding and reranking models, two text-to-speech models and three 'decision' models that return scored answers instead of free text. By last week's usage, OpenRouter's Free Models page ranks Nemotron 3 Ultra, Nemotron 3.5 Super VL and Nemotron 3.5 Lightning as the most used. Five of the chat models are worth calling out individually.
Thinking Machines Inkling (975B-A41B)
Inkling is the biggest model on the free list. Thinking Machines Lab released it on July 15, 2026, trained from scratch with the full weights available: a Mixture-of-Experts with 975B total parameters and 41B active, text, image and audio input, and up to 1M tokens of context. The weights are on Hugging Face under Apache 2.0. On OpenRouter the free endpoint serves the full 1M context, while the paid listing ($1.00/M input, $4.05/M output) tops out at 524K. The lab is frank about where it stands: Inkling is not the strongest overall model available today, open or closed, and it pitches itself as a base for customization.
Read the notice at the top of the model page before you wire it in. The free endpoint is only available for use with agentic harnesses, and Thinking Machines logs its prompts and outputs to improve its models, after separating them from your account. Use it for coding-agent experiments, not confidential work. Its smaller sibling, thinkingmachines/inkling-small:free (276B total, 12B active), is free as well.
NVIDIA Nemotron 3 Ultra (550B-A55B)
NVIDIA Nemotron 3 Ultra, released June 4, 2026, is one of the two July picks that is still free. It is a 550B-parameter MoE with 55B active per token, built on a hybrid Transformer-Mamba architecture that NVIDIA designed for high-throughput agent pipelines. NVIDIA serves the free endpoint itself, with a 1M-token context and up to 65,536 output tokens. The paid endpoints, from $0.40/M input and $1.76/M output, stop at 262K context, so on this model the free tier is the bigger one. NVIDIA's notice on the page says use of the free endpoint is logged for security purposes and to improve NVIDIA products and services.
NVIDIA Nemotron 3.5 Super VL (120B-A12B)
Nemotron 3.5 Super VL is the newest model in this guide, released October 15, 2026. It is a 120B-parameter MoE with 12B active that takes text, images, documents, GUI screenshots and video and returns text, with a 1M-token context and reasoning switched on by default. You can turn it off or give it a token budget. That makes it the free pick for document extraction, screenshot-driven agents and video understanding. The same NVIDIA logging notice sits on its page. Paid endpoints start at $0.06/M input. For speed over size, nvidia/nemotron-3.5-lightning:free (30B total, 3B active, text only, 1M context) is the high-throughput option in the same family.
Google Gemma 4 (31B and 26B-A4B)
Google DeepMind's Gemma 4 family, released April 2, 2026, is the other July pick that is still free, and both variants survived. google/gemma-4-31b-it:free is the 30.7B dense model: no MoE routing, so it is the slower of the two, but it is the one to reach for when you want the best single answer. google/gemma-4-26b-a4b-it:free is the MoE sibling, with 25.2B total and 3.8B active parameters, landing close to the 31B model's quality while responding faster. Google AI Studio serves both for free with a 262K context, up to 32,768 output tokens, image and video input, configurable thinking, native function calling and 140+ languages, under the Apache 2.0 license. Unlike the NVIDIA and Thinking Machines pages, Gemma's free page shows no logging notice.
Poolside Laguna S 2.1 - Going Away October 31
Laguna S 2.1 is Poolside's coding-agent model: 118B total parameters, 8B active, open-weight under the OpenMDW-1.1 license, with a 262K context on the free endpoint. Poolside reports 70.2% on Terminal-Bench 2.1 and 40.4% on DeepSWE. Those are vendor numbers, but strong ones for a model with 8B active parameters, and of everything on the free list it is the one most directly built for coding agents. That is exactly the problem: the model page says going away October 31, 2026, and the smaller poolside/laguna-xs-2.1:free (33B total, 3B active) expires the same day. Poolside also says it may use free-tier inputs and outputs to train its models. It is not only the free tier that is ending: the paid listing ($0.09/M input, $0.18/M output, 1M context) shows the same going away date, as does the paid Laguna XS 2.1.
We are calling it out because free-tier listicles go stale within weeks. After October 31, 2026, check its current listing before you use it.
The Rest of the Current Free Roster
Beyond those five, the free chat models are Inkling Small; NVIDIA's Nemotron 3.5 Lightning, Nemotron 3 Nano Omni (30B-A3B, with text, image, audio and video input) and the 4B Nemotron 3.5 Content Safety guardrail model; Cohere's North Mini Code (30B, 3B active), its first agentic coding model; Recursive's Flint (40B, 2.5B active), built for coding agents and added on October 21; China Telecom's Xing4.0 29B-A4B; Dots Studio's Dots3-Note Preview (280B, 16B active), free until December 31, 2026; and LiquidAI's LFM2.5-2.6B for small, fast jobs. Outside chat, there are free embedding and reranking models from NVIDIA and LiquidAI, and free text-to-speech from Fish Audio and HeyGen. HeyGen's free text-to-speech listing ends November 30, 2026.
For open-weight models you can run on your own hardware instead of depending on a rotating free tier, see the rest of this blog for self-hosting options.
Free Embedding, Reranking and Speech Endpoints
Not every free endpoint is a chat model. OpenRouter also exposes free embeddings and reranking models. The chat completion endpoint is the obvious way to use free AI, but the embedding endpoints are useful for private knowledge bases, semantic search, and retrieval-augmented generation. Most of these models also use the same :free suffix, and the API shape follows the OpenAI embeddings interface.
For reranking, you send a query and a list of candidate documents, and the model returns relevance scores. This is useful when you want to filter a large set of results before sending the best ones to a chat model. The free tier on these models is small, but it is enough for experiments and low-traffic retrieval pipelines.
Speech endpoints are a different story. Free text-to-speech models from Fish Audio and HeyGen let you generate audio from text without paying. Those endpoints consume the same daily free request budget, so a long-form audio generation task can burn through the quota quickly. The quality varies, so test the audio output before using it in a user-facing product.
'Decision' models on OpenRouter return scored answers instead of free text. They are less common, but they fit into classification and routing workflows where a structured score is more useful than a paragraph.
What the Free Endpoints Do With Your Prompts
Rate limits are the documented cost of the free tier. The less obvious one is data. Three of the five model pages above say the provider logs free-tier traffic or may train on it: NVIDIA and Thinking Machines log it to improve their models, and Poolside may train on it. That is the deal behind most free inference: you get the tokens, and the lab gets real-world usage.
OpenRouter lets you opt out, at a price. Your account's privacy settings have separate switches for paid and free models on whether to allow providers that may train on your data, and per OpenRouter's provider logging docs, if you opt out, OpenRouter will not route to providers that train. Every free model in this guide runs on a single provider, so opting out does not move you to a safer host; it takes those models off the table for your account. If a free model works for everyone else but fails for you, check that setting first.
Privacy compliance is an important part of the decision. If your company has a policy that prohibits sending customer data to providers that may retain it, you need to review each free model's data notice before using it. The free tier is convenient, but it is not a place for secrets, personal data, or proprietary code.
The Business Model Behind Free Inference
Even though the price is $0, there is a cost. The labs behind these models need real-world usage, feedback, and performance data. Free inference is a form of evaluation at scale. When a lab like NVIDIA or Thinking Machines offers a free endpoint, it is not giving away a commodity. It is using the free tier to stress-test a new architecture, gather quality signals, and build a community of developers who will move to paid infrastructure when the project becomes serious.
OpenRouter also benefits because free models attract developers to its API, and once they are comfortable, the paid tier is a short step away. The free tier can be seen as an extended trial of both the model and the routing platform.
This business logic explains why models rotate. A free listing is not a guarantee. It is a promotional window, and the window closes when the lab decides that the promotion has served its purpose.
Free Tier vs. Paying: What You Actually Give Up
The free tier is not a stripped-down demo. The biggest free models are frontier-scale open-weight releases, and on Inkling and Nemotron 3 Ultra the free endpoint offers a bigger context window than the paid listing. What you give up by staying free:
- Proprietary flagships. Free models on OpenRouter are open-weight releases or temporary promotions. You will not find free access to Claude, GPT or Gemini's flagship tiers.
- Throughput. 50 or 1,000 requests a day is fine for personal projects and prototyping. It is not enough for a production app with real traffic, and OpenRouter itself warns that free models can be rate limited or slower at peak times.
- Privacy. Many free endpoints log or may train on what you send.
Once you outgrow it, pay-as-you-go charges each provider's list price with no markup on tokens, plus the 5.5% fee when you buy credits. If you already have keys with OpenAI, Anthropic or Google, bring your own key routes through them with no OpenRouter fee on the first $25,000 of list-price inference each month and 5% after that. For gateways beyond OpenRouter, tooling like Portkey and LiteLLM can help with routing, caching and retries, and our other OpenRouter production posts cover what breaks when you move paid traffic onto it.
Error Codes You Might See
OpenRouter uses standard HTTP status codes, but the meaning can be confusing if you are new to the free tier.
| Status | Meaning | What to do |
|---|---|---|
| 401 | Invalid API key | Regenerate the key in your OpenRouter dashboard and update your config |
| 402 | Negative credit balance | Add credits; free models can also be blocked by this condition |
| 404 | Model not found | Check the model ID and the :free suffix |
| 429 | Rate limit hit | Read the X-RateLimit-* headers and back off |
| 5xx | Provider error | Retry with exponential backoff or use a fallback model |
A 5xx error is different from a rate limit. It usually means the provider had a transient issue, and a fallback model can keep your agent moving. A 429 means you are being throttled, and no amount of fallback switching will help until the reset time arrives.
A Realistic Way to Use This
The pattern that holds up over time looks like this: build against the OpenAI-compatible endpoint so you are never locked into one provider's SDK, put two or three free models in a models fallback array instead of trusting any single one, check free_model_daily_requests before long runs, and keep confidential data on paid endpoints whose data policy you have read. Treat stealth models and time-limited listings like Laguna S 2.1 as bonus capacity, not something a workflow depends on.
A practical example of a healthy integration:
import requests
api_key = 'sk-or-v1-your-key-here'
url = 'https://openrouter.ai/api/v1/chat/completions'
payload = {
'models': [
'nvidia/nemotron-3-ultra-550b-a55b:free',
'google/gemma-4-31b-it:free',
'nvidia/nemotron-3.5-lightning:free'
],
'messages': [
{'role': 'user', 'content': 'Explain the tradeoffs of free LLM APIs.'}
]
}
resp = requests.post(
url,
json=payload,
headers={'Authorization': f'Bearer {api_key}'}
)
print(resp.json())
This request uses Python's requests library and passes the fallback array directly. The response will tell you which model handled the call, and you can log it for later analysis.
Using Free Models in Agent Loops
An agent loop can consume the daily free quota very quickly. Each tool call, each retry, and each intermediate step can generate a new chat completion. A task that takes 20 steps can eat 20 requests in minutes. To make the quota last, consider using a larger context and packing multiple steps into one prompt. When you can, reuse previous completions instead of asking the model to re-read the whole transcript.
Another approach is to route only the final decision to a large free model and use a smaller model for simpler subtasks. For example, use nvidia/nemotron-3.5-lightning:free for extraction and nvidia/nemotron-3-ultra-550b-a55b:free for the final synthesis. The fallback array still applies, but you can choose different fallback lists for different task classes.
Coding agents like OpenCode ship OpenRouter as a built-in provider, so you can point them at the free tier without writing a custom integration. The same request caps apply, though, so an agent that makes many small calls will still exhaust the daily limit quickly. If you use a coding agent, set a low request budget and fall back to a paid model for long sessions.
Monitoring Free Usage
The key endpoint gives you the daily usage numbers, but not a historical view. For a long-running project, log the model field from every response and count requests by model ID. You can also check the OpenRouter activity page to see recent requests and errors across your account. A simple cron job that runs once an hour can hit the key endpoint and write the remaining count to a log file.
A logging line does not need to be complicated. Capture the timestamp, the selected model, the status code, and the finish_reason. That is enough to detect when a particular model starts failing or when your fallback order is not working as intended.
Practical Example: Daily Newsletter Summarizer
Imagine you want a bot that reads a set of tech newsletters every morning and produces a one-paragraph summary. With the free tier, you can do this with a small Python script. The script fetches the articles, truncates each one to the context limit, sends the content to a free model, and stores the summary. A daily run uses maybe 10 to 20 requests, which fits comfortably in the 50 request daily tier.
First, choose a fallback list with two free models. Second, call the chat completion endpoint. Third, check finish_reason and store the output. Finally, schedule it with cron. This is a good example because it uses the free tier for a bounded task rather than building a production API that needs thousands of calls per day.
The same pattern applies to other scheduled jobs: log summarization, test report generation, issue triage, and personal research digests. Keep the scope small, monitor the daily remaining count, and you can get real value from an API that costs nothing per token.
Frequently Asked Questions
Is OpenRouter's free tier actually unlimited?
No. The tokens are free, but the requests are capped. The daily cap is 50 or 1,000 requests depending on your all-time credit purchases, and the per-minute cap is always 20. If you stay under those limits, you can send very large prompts and receive very long completions without token billing.
Why did my free model stop working?
Free listings rotate. Labs use free inference to promote launches, collect telemetry, or test a model under real traffic. When the promotion ends, the model either disappears from the free list or becomes paid. Always have a fallback list and check the OpenRouter model pages before a deploy.
Can I use free models in production?
You can, but only for low-traffic internal tools, personal projects, and experiments. The request caps and the data logging notices make them unsuitable for customer-facing products that need privacy and consistent throughput. For production use, the paid tier or bring-your-own-key route is a better fit.
Does using a free model with a huge context count as one request?
Yes. A request is one API call, regardless of token count. That is why free models with 1M context are attractive for document processing, but you still have to respect the daily request limit.
Should I pay the $10 to unlock 1,000 requests?
If you are using free models every day or iterating on prompts for hours, yes. The $10 is a one-time threshold that raises your free daily ceiling, and it also gives you pay-as-you-go access to paid models if you need them. If you only need a handful of requests for a weekend experiment, skip it.
Conclusion
'Free AI API with unlimited tokens' is a catchy search phrase, but the accurate description is more useful once you understand it: OpenRouter gives you free, per-token-uncapped access to a strong and changing set of open-weight models, gated by a daily request limit rather than a token limit. Right now the lineup includes Inkling, Nemotron 3 Ultra, Nemotron 3.5 Super VL and Gemma 4. Fifty requests a day costs nothing and needs no card; $10 of credits, bought once, raises that to a thousand. The discipline it asks for has not changed since July: build for rotation from day one, read each free endpoint's data notice, and recheck model pages before you rely on them.
Top comments (1)
The model churn is the part that gets me. Free in July, paid by October, so I'd never wire a shipped product to one of these, they're experiment tier at best. Does the 20 req/min apply per model or per account? Spreading calls across a few free ones would stretch that a lot