On this page
:free suffix (8 of them answered our test call on September 29, 2026) — through one API key and one OpenAI-compatible endpoint. No credit card, just an email sign-up. Free models cost $0 per token; the account-wide cap is 20 requests/minute and 50 requests/day, rising to 1,000/day once you've bought $10 of credits (one time, ever).Instead of signing up separately for Nemotron, Gemma, Qwen, Cohere, and a dozen others, you manage everything in one place with automatic fallback if a provider goes down. This guide covers which free models answered, how to call them in Python, how to wire OpenRouter into OpenClaw for a free agent, and when going direct beats it.
Free Models to Start With
OpenRouter marks free models with the :free suffix — no per-token cost, but they carry rate limits:
| Model ID | Context | Strengths |
|---|---|---|
nvidia/nemotron-3-ultra-550b-a55b:free | 1M | 550B parameters, 1M context |
nvidia/nemotron-3-super-120b-a12b:free | 262K | General-purpose MoE — our default pick |
google/gemma-4-31b-it:free | 262K | Multilingual; returned 429 on Sept 29 (upstream rate limit) |
cohere/north-mini-code:free | 256K | Coding-focused — our code pick |
thinkingmachines/inkling:free | 1M | Only works inside an agentic harness (403 on a plain API call) |
openrouter/free | 200K | Router that picks a currently-free model for you (not part of our test) |
Free-model limits are account-wide, quoted from OpenRouter's docs: 20 requests/minute, and 50 requests/day until your account has bought $10 of credits at some point — after that, 1,000/day. Filter for all of them at openrouter.ai/models (":free"). To get a key: sign in at openrouter.ai with Google/GitHub/email, go to Keys, click Create Key. No credit card needed — you only add credits for paid models.
Using the API with Python
OpenRouter is fully OpenAI-compatible — just change base_url and api_key:
from openai import OpenAI
client = OpenAI(
base_url="https://openrouter.ai/api/v1",
api_key="YOUR_OPENROUTER_API_KEY"
)
response = client.chat.completions.create(
model="nvidia/nemotron-3-super-120b-a12b:free",
messages=[
{"role": "user", "content": "Explain the difference between REST and GraphQL"}
]
)
print(response.choices[0].message.content)
Swap models by changing one string. For production, add fallback so your app survives a provider outage:
response = client.chat.completions.create(
model="nvidia/nemotron-3-super-120b-a12b:free",
messages=[{"role": "user", "content": "Summarize the key features of Python 3.12"}],
extra_body={
"route": "fallback",
"models": [
"nvidia/nemotron-3-super-120b-a12b:free",
"nvidia/nemotron-3-ultra-550b-a55b:free",
"nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free"
]
}
)
print(response.choices[0].message.content)
print(f"Model used: {response.model}")
Streaming works the same way:
stream = client.chat.completions.create(
model="nvidia/nemotron-3-super-120b-a12b:free",
messages=[{"role": "user", "content": "Solve: What is 17 multiplied by 43, step by step"}],
stream=True
)
for chunk in stream:
if chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
Connect OpenRouter to OpenClaw (Free AI Agent)
Pair OpenRouter's free models with OpenClaw to build a free agent that uses tools and browses the web — switching models without code changes. Run npm install -g openclaw@latest && openclaw onboard, choose OpenAI-compatible, and enter the OpenRouter base URL and key. Or edit ~/.openclaw/openclaw.json:
{
"models": {
"mode": "merge",
"providers": {
"openrouter": {
"baseUrl": "https://openrouter.ai/api/v1",
"apiKey": "YOUR_OPENROUTER_API_KEY",
"api": "openai-completions",
"models": [
{
"id": "nvidia/nemotron-3-super-120b-a12b:free",
"name": "Nemotron 3 Super (Free)",
"reasoning": false,
"input": ["text"],
"contextWindow": 262144,
"maxTokens": 8192
},
{
"id": "nvidia/nemotron-3-ultra-550b-a55b:free",
"name": "Nemotron 3 Ultra (Free)",
"reasoning": false,
"input": ["text"],
"contextWindow": 1000000,
"maxTokens": 8192
},
{
"id": "cohere/north-mini-code:free",
"name": "North Mini Code (Free)",
"reasoning": false,
"input": ["text"],
"contextWindow": 256000,
"maxTokens": 8192
}
]
}
}
},
"agents": {
"defaults": {
"model": {
"primary": "openrouter/nvidia/nemotron-3-super-120b-a12b:free"
}
}
}
}
Now the agent uses Nemotron 3 Super for general tasks, Nemotron 3 Ultra when it needs the 1M-token context, and North Mini Code for coding — all three answered our test calls on September 29, 2026, and all are free.
Which free models answered (tested September 29, 2026)
We pulled the model list from /api/v1/models and sent every model ending in :free one minimal chat request, retrying the failures once. 16 models were listed; 8 answered.
| Model ID | Result |
|---|---|
nvidia/nemotron-3-super-120b-a12b:free | Answered (200) |
nvidia/nemotron-3-ultra-550b-a55b:free | Answered (200) |
nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free | Answered (200) |
cohere/north-mini-code:free | Answered (200) |
inclusionai/ling-3.0-flash-sante:free | Answered (200) |
dots-studio/dots-3-note-preview:free | Answered (200) |
liquid/lfm-2.5-2.6b:free | Answered (200) |
poolside/laguna-xs-2.1:free | Answered on retry (429 first) |
qwen/qwen3.8-27b:free | 429 "Provider returned error", twice |
poolside/laguna-s-2.1:free | 429 "Provider returned error", twice |
google/gemma-4-26b-a4b-it:free | 429 "Provider returned error", twice |
google/gemma-4-31b-it:free | 429 "Provider returned error", twice |
thinkingmachines/inkling:free | 403 — only available on agentic harnesses |
thinkingmachines/inkling-small:free | 403 — only available on agentic harnesses |
nvidia/nemotron-3.5-lightning:free | Inconclusive — the connection dropped on our side, twice |
nvidia/nemotron-3.5-content-safety:free | Not tested — a safety classifier, not a chat model |
How to read it: the 429s came back as "Provider returned error", meaning the upstream provider serving that free model was rate-limiting, not your account — those models may work at another time, which is why the retry succeeded for laguna-xs-2.1. The two Inkling models refuse plain API calls; OpenRouter only serves them through coding agents and apps on its agentic-harness list. And z-ai/glm-5.2:free, which earlier versions of this guide recommended, is no longer in the free list.
OpenRouter vs Going Direct
| Feature | OpenRouter | Direct (e.g., DeepSeek) |
|---|---|---|
| Number of models | 400+ | 1 provider's models |
| API endpoints | One endpoint | Different URL per provider |
| Free models | 16 listed, 8 answered (Sept 29, 2026) | Only that provider's free tier |
| Automatic fallback | Yes | No |
| Rate limits (free) | 50 req/day (1,000 after a one-time $10 top-up) | Varies — often higher per model |
| Measured speed | 38 tok/s (we tested, Aug 31, 2026) | 33 tok/s on the identical model (NVIDIA direct) |
| Data privacy | Routes through OpenRouter | Direct to provider |
We tested the "proxy overhead" assumption (August 31, 2026)
The obvious objection to any router is that the extra hop costs you latency. So we measured it, twice, on a like-for-like comparison: the identical model, nemotron-3-super-120b, on OpenRouter's free tier and on NVIDIA's own first-party endpoint, same machine, same prompt.
| Route | First token | Generation |
|---|---|---|
| OpenRouter (free) | 2.6 s | 38.1 tok/s |
| NVIDIA direct | 3.5 s | 33.3 tok/s |
OpenRouter was faster on both measures — and in an earlier run NVIDIA's endpoint returned an empty response for the same request while OpenRouter served it fine. Free capacity is shared and unevenly provisioned, so a router with spare headroom can beat the source. Measured 2026-08-31 with our open benchmark; see the full cross-platform results.
This doesn't make routing free in general — it means you should measure your specific model on both routes rather than assuming the vendor's own endpoint wins.
Verdict: OpenRouter fits prototyping, research, and multi-model apps. For high-traffic production on a single model, going direct usually gives higher per-model limits — but measure latency on both routes, since in our test the router was faster.
OpenRouter vs Other Free AI APIs
| Feature | OpenRouter | Gemini Free | Groq Free | DeepSeek Free |
|---|---|---|---|---|
| Model variety | 400+ models | Several Gemini models | 4 chat models | 2 models (v4-flash, v4-pro) |
| Free daily limit | 50/day (1,000 after $10) | Not published | 1,000 req/day (chat models) | None — top-up required |
| Free model to start with | Nemotron 3 Super | Gemini 3.5 Flash | gpt-oss-120b | None (prepaid only) |
| Reasoning model | Yes (Nemotron 3 Nano Omni Reasoning, free) | Yes (thinking models) | Yes (gpt-oss) | Yes (v4 thinking mode) |
| Multi-provider | Yes | No | No | No |
| Credit card | No | No | No | Prepaid balance required |
Handling Rate Limits
Free models run on shared upstream capacity, so throttling is common — on September 29, 2026 four of the 16 free models returned 429 "Provider returned error" on two attempts. Loop through fallbacks on a RateLimitError:
import time
from openai import OpenAI, RateLimitError
client = OpenAI(
base_url="https://openrouter.ai/api/v1",
api_key="YOUR_OPENROUTER_API_KEY"
)
FREE_MODELS = [
"nvidia/nemotron-3-super-120b-a12b:free",
"nvidia/nemotron-3-ultra-550b-a55b:free",
"nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free"
]
def chat_with_fallback(prompt, models=FREE_MODELS):
for model in models:
try:
response = client.chat.completions.create(
model=model,
messages=[{"role": "user", "content": prompt}]
)
return response.choices[0].message.content, model
except RateLimitError:
print(f"{model} rate limited, trying next...")
time.sleep(1)
return None, None
answer, used_model = chat_with_fallback("Explain async/await in Python")
print(f"Answer from {used_model}:\n{answer}")
Frequently Asked Questions
Are OpenRouter's free models really free?
Yes — models with the :free suffix cost $0 per token with no credit card required. The only limit is rate, and it's account-wide: 20 requests/minute and 50 requests/day, rising to 1,000/day once your account has ever bought $10 of credits.
Do I need a credit card?
No. An email sign-up is enough to use every free model. You only add credits if you want to call paid models.
Is OpenRouter OpenAI-compatible?
Yes. It drops into existing OpenAI code — change only base_url to https://openrouter.ai/api/v1 and your api_key. The SDK, streaming, and message format are unchanged.
When should I go direct instead?
For high-traffic production on a single model, going direct to the provider often gives higher per-model rate limits (latency can go either way — in our same-model test OpenRouter was faster). OpenRouter fits prototyping, benchmarking, and multi-model or fallback-dependent apps.
Final Thoughts
OpenRouter fits when you want multiple AI models without juggling keys and endpoints. It listed 16 free models on September 29, 2026 and 8 of them answered our test call — including Nemotron 3 Super, Nemotron 3 Ultra (550B) and Cohere's North Mini Code — at zero cost. The trade-offs are an account-wide cap of 50 requests/day (1,000 after a one-time $10 top-up) and free models that are sometimes rate-limited upstream, so build in a fallback list. Get started: openrouter.ai — sign up free, grab your key, and explore 400+ models in minutes.