OpenRouter Free Tier Tested: 16 Free Models, One API Key

On this page
  1. Free Models to Start With
  2. Using the API with Python
  3. Connect OpenRouter to OpenClaw (Free AI Agent)
  4. Which free models answered (tested September 29, 2026)
  5. OpenRouter vs Going Direct
  6. OpenRouter vs Other Free AI APIs
  7. Handling Rate Limits
  8. Frequently Asked Questions
  9. Final Thoughts
Quick answer: OpenRouter is a unified API gateway that reaches 400+ AI models — including 16 free ones with a :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 IDContextStrengths
nvidia/nemotron-3-ultra-550b-a55b:free1M550B parameters, 1M context
nvidia/nemotron-3-super-120b-a12b:free262KGeneral-purpose MoE — our default pick
google/gemma-4-31b-it:free262KMultilingual; returned 429 on Sept 29 (upstream rate limit)
cohere/north-mini-code:free256KCoding-focused — our code pick
thinkingmachines/inkling:free1MOnly works inside an agentic harness (403 on a plain API call)
openrouter/free200KRouter 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 IDResult
nvidia/nemotron-3-super-120b-a12b:freeAnswered (200)
nvidia/nemotron-3-ultra-550b-a55b:freeAnswered (200)
nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:freeAnswered (200)
cohere/north-mini-code:freeAnswered (200)
inclusionai/ling-3.0-flash-sante:freeAnswered (200)
dots-studio/dots-3-note-preview:freeAnswered (200)
liquid/lfm-2.5-2.6b:freeAnswered (200)
poolside/laguna-xs-2.1:freeAnswered on retry (429 first)
qwen/qwen3.8-27b:free429 "Provider returned error", twice
poolside/laguna-s-2.1:free429 "Provider returned error", twice
google/gemma-4-26b-a4b-it:free429 "Provider returned error", twice
google/gemma-4-31b-it:free429 "Provider returned error", twice
thinkingmachines/inkling:free403 — only available on agentic harnesses
thinkingmachines/inkling-small:free403 — only available on agentic harnesses
nvidia/nemotron-3.5-lightning:freeInconclusive — the connection dropped on our side, twice
nvidia/nemotron-3.5-content-safety:freeNot 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

FeatureOpenRouterDirect (e.g., DeepSeek)
Number of models400+1 provider's models
API endpointsOne endpointDifferent URL per provider
Free models16 listed, 8 answered (Sept 29, 2026)Only that provider's free tier
Automatic fallbackYesNo
Rate limits (free)50 req/day (1,000 after a one-time $10 top-up)Varies — often higher per model
Measured speed38 tok/s (we tested, Aug 31, 2026)33 tok/s on the identical model (NVIDIA direct)
Data privacyRoutes through OpenRouterDirect 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.

RouteFirst tokenGeneration
OpenRouter (free)2.6 s38.1 tok/s
NVIDIA direct3.5 s33.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

FeatureOpenRouterGemini FreeGroq FreeDeepSeek Free
Model variety400+ modelsSeveral Gemini models4 chat models2 models (v4-flash, v4-pro)
Free daily limit50/day (1,000 after $10)Not published1,000 req/day (chat models)None — top-up required
Free model to start withNemotron 3 SuperGemini 3.5 Flashgpt-oss-120bNone (prepaid only)
Reasoning modelYes (Nemotron 3 Nano Omni Reasoning, free)Yes (thinking models)Yes (gpt-oss)Yes (v4 thinking mode)
Multi-providerYesNoNoNo
Credit cardNoNoNoPrepaid 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.