NVIDIA Nemotron 3 on OpenRouter: free API guide

NVIDIA Nemotron 3 is a family of open-weight models built for agentic workflows, long-context reasoning, tool use, and high-throughput inference. Several variants are available through OpenRouter, including free routes that you can call with an OpenAI-compatible API key.

This guide focuses on the practical questions: which Nemotron 3 model fits each workload, what the hosted free endpoints actually expose, how to connect them to an application, and which privacy and availability tradeoffs matter before you use them.

The Nemotron 3 lineup

The family spans efficient text models, a larger reasoning model, a multimodal variant, and a frontier-scale orchestration model. They share an emphasis on sparse activation: the checkpoint may contain many parameters, while only a smaller subset is active for each token.

NVIDIA's model cards describe Nano and Super as hybrid Mamba-2/Transformer mixture-of-experts models. Super adds LatentMoE and Multi-Token Prediction layers. Its official model card lists 120B total parameters, 12B active parameters, configurable reasoning, and support for context lengths up to one million tokens.

Nemotron 3 Nano: throughput first

Nano is the practical default for workflows that call a model repeatedly. Its sparse 30B checkpoint activates roughly 3B parameters per forward pass, which makes it a better fit for routing, extraction, short coding tasks, and multi-agent chains than a large dense model would be.

OpenRouter currently lists both paid and free Nano routes. The hosted context limit can be lower than the theoretical maximum in NVIDIA's model family documentation, so read the live route metadata rather than hard-coding a context size in your product.

Nemotron 3 Super: the balanced reasoning option

Super is the most broadly useful text model in the family. The 120B/12B design targets complex tool use, cross-document reasoning, planning, and agent coordination without paying the inference cost of activating all 120 billion parameters for every token.

The free OpenRouter route uses the model ID nvidia/nemotron-3-super-120b-a12b:free. OpenRouter also exposes paid providers for the same base model. That gives you a clean upgrade path: prototype on the free route, then remove :free or select a provider when you need predictable capacity and service levels.

Nemotron 3 Nano Omni: multimodal input

Omni accepts combinations of text, images, audio, and video. NVIDIA positions it for document understanding, transcription, media question answering, and multimodal agent pipelines. The NVIDIA technical overview is the best starting point for supported modalities and deployment details.

Use Omni when perception is part of the task—for example, turning a screenshot into a structured bug report. Do not choose it for a text-only pipeline merely because it is newer: Nano or Super will usually be simpler.

Why the hybrid architecture matters

Standard self-attention becomes expensive as an input grows. Nemotron's hybrid design combines different components instead of asking one mechanism to handle every token and every type of dependency.

1. Mamba-2 layers process sequences with memory and compute characteristics suited to long inputs.
2. Transformer attention remains available where exact token-to-token relationships matter, including code, structured reasoning, and tool arguments.
3. Mixture-of-experts routing activates only part of the network for each token, increasing total model capacity without matching the full dense-model inference cost.
4. Multi-Token Prediction is designed to improve training and generation efficiency by predicting more than one future token through auxiliary heads.

The result is especially relevant to agent systems. An agent may call its model dozens of times while planning, retrieving context, invoking tools, and validating the result. Lower cost per step and higher throughput can matter more than winning a single benchmark.

How to call the free route

Create an OpenRouter key, choose a model that currently has a free route, and call the standard chat-completions endpoint. Here is a minimal Python example using the OpenAI SDK:

from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="YOUR_OPENROUTER_KEY",
)

response = client.chat.completions.create(
    model="nvidia/nemotron-3-super-120b-a12b:free",
    messages=[
        {"role": "system", "content": "You are a careful Python engineer."},
        {"role": "user", "content": "Design an async scraper with retries and rate limiting."},
    ],
)

print(response.choices[0].message.content)

With TypeScript or Bun, the same request can be made directly with fetch:

const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "nvidia/nemotron-3-super-120b-a12b:free",
    messages: [
      { role: "user", content: "Review this API design and list the main risks." },
    ],
  }),
});

if (!response.ok) throw new Error(`OpenRouter ${response.status}`);
const data = await response.json();
console.log(data.choices[0].message.content);

Free-route limitations

• Availability is not guaranteed. A free route can be rate-limited, temporarily unavailable, or removed. Query OpenRouter's model API or keep a fallback model.
• Do not send sensitive data. OpenRouter's free-provider notice states that prompts and outputs may be logged and used to improve provider products. Treat the route as a public trial environment.
• Hosted limits can differ from model limits. The checkpoint may support a one-million-token context while an individual route exposes less.
• Benchmark leadership is workload-specific. Test tool calling, structured output, latency, and failure recovery with your own prompts before choosing a production model.

Which model should you choose?

Bottom line

Nemotron 3 is compelling because it offers more than one size of the same idea. Nano is optimized for repeated, latency-sensitive calls; Super is the practical reasoning model; Omni adds perception; and Ultra targets the most demanding agent workflows. OpenRouter's free routes make the family easy to evaluate without committing to infrastructure, provided you accept trial-grade availability and data handling.

Start with a small evaluation set from your real workload, record latency and structured-output failures, and keep the model ID configurable. That will tell you more than a generic leaderboard—and it lets you switch from a free route to a paid provider without redesigning the application.