NVIDIA Nemotron API Pricing Guide: Models, Token Costs, and Best Tier to Use
Nemotron tier | Example models | Approx. input cost per 1M tokens | Approx. output cost per 1M tokens | Typical use |
Nano | Nemotron Nano 9B, Nemotron Nano 30B | $0.04 to $0.05 | $0.16 to $0.20 | High-volume, low-cost text tasks |
Nano Vision | Nemotron Nano 12B VL | Around $0.20 | Around $0.60 | Image and video understanding |
Super | Nemotron Super 49B, Nemotron Super 120B | Around $0.08 to $0.10 | Around $0.40 | Reasoning, agents, general AI apps |
Flagship | Llama-3.1-Nemotron-70B | Around $1.20 | Around $1.20 | Advanced instruction following |
Ultra | Nemotron Ultra-class models | Around $0.50 to $0.60 | Around $2.20 to $2.40 | Heavy reasoning and complex workloads |
The key pricing pattern is clear: output tokens usually cost more than input tokens. That matters because verbose applications can become expensive even when the prompt is short.
That distinction matters because the same model family can have different economics depending on the route you choose.
Some AI APIs have a simple public price table. Nemotron is more flexible than that, which is useful technically but less tidy for budgeting.
There are three major reasons.
Models vary by size and capability
A 9B or 12B-class model needs less compute than a 70B or Ultra-class model. That affects price.
Smaller models can be a good fit for:
Tagging support tickets
Cleaning data
Routing user requests
Summarizing short text
Detecting topic or sentiment
Extracting fields from documents
Larger models are more useful when the task requires more judgment, longer reasoning, better instruction following, or more detailed generation.
Providers set their own rates
NVIDIA models may be available through different platforms, and those platforms do not always use the same pricing.
A provider may charge by:
Input tokens
Output tokens
Total tokens
Requests
GPU time
Reserved capacity
Dedicated endpoint usage
Enterprise contracts
A low headline token price may not tell the whole story. Rate limits, latency, uptime, private networking, and support can matter just as much in production.
Self-hosting changes the cost model
If you run Nemotron yourself, you may not pay a per-token API price to a hosted provider. Instead, you pay for the infrastructure and people needed to run it.
That can include:
GPU instances or physical GPUs
Storage
Networking
Container hosting
Monitoring
Scaling
Security
Load balancing
Model updates
Engineering support
Self-hosting can reduce marginal token cost at high scale, but it adds fixed cost and operational work. Hosted APIs are often cheaper to start because you pay only for what you use.
How token pricing works
Most hosted AI APIs price usage by tokens. A token is a chunk of text. It can be a word, part of a word, punctuation, or formatting. The exact count depends on the tokenizer used by the model.
For simple planning, think of tokens as pieces of text sent to and returned by the model.
There are usually two billable parts:
Input tokens
These are the tokens you send to the model. They include system instructions, developer instructions, user messages, retrieved context, examples, tool schemas, and any quoted source text.
Output tokens
These are the tokens the model generates. They include the answer, reasoning traces if exposed and billable, structured JSON, tool calls, and other generated content.
Output tokens often cost more because generation uses more compute step by step. This is why a chatbot that gives long answers can cost much more than a classifier that returns one short label.
You can estimate token cost with a basic formula:
`estimated cost = input token cost + output token cost`
More specifically:
`input cost = input tokens / 1,000,000 × provider input price`
`output cost = output tokens / 1,000,000 × provider output price`
Then add them together.
Example using a Nano model
Say a Nano model costs about $0.05 per 1 million input tokens and $0.20 per 1 million output tokens.
A task uses:
20 million input tokens per month
5 million output tokens per month
Estimated monthly cost:
Token type | Usage | Price | Estimate |
Input | 20M tokens | $0.05 per 1M | $1.00 |
Output | 5M tokens | $0.20 per 1M | $1.00 |
Total | 25M tokens | Mixed | $2.00 |
That is why Nano-class models can be attractive for high-volume background tasks.
Example using an Ultra-class model
Now take an Ultra-class model at about $0.60 per 1 million input tokens and $2.40 per 1 million output tokens.
A heavier workflow uses:
20 million input tokens per month
5 million output tokens per month
Estimated monthly cost:
Token type | Usage | Price | Estimate |
Input | 20M tokens | $0.60 per 1M | $12.00 |
Output | 5M tokens | $2.40 per 1M | $12.00 |
Total | 25M tokens | Mixed | $24.00 |
The usage volume is the same, but the tier changes the estimate by a lot.
Your real bill can differ if the provider rounds requests, applies minimum charges, bills cached tokens differently, charges for tool calls, or uses a different model variant.
The main Nemotron model tiers explained
Nemotron tiers are not just price buckets. They also reflect different tradeoffs in speed, quality, reasoning depth, multimodal support, and operating cost.
Nano models are best for volume and simple automation
Nano models are usually the lowest-cost option in the Nemotron family. They are a good starting point when the task is repetitive, narrow, and easy to check.
Common Nano use cases include:
Short summarization
Topic classification
Intent detection
Basic extraction
Data normalization
Drafting short replies
Routing requests to other systems
Nano models make sense when the cost per task matters more than maximum answer quality. If you need to process millions of short records, the difference between Nano and a larger model can be meaningful.
A good pattern is to use Nano models as a first pass. For example, a support system might use Nano to classify a ticket, detect the language, and decide whether the issue needs escalation. Only the hard cases go to a larger model.
This approach can keep cost low without forcing every request through the most expensive model.
Nano Vision models are for visual inputs
Nano Vision models, such as Nemotron Nano 12B VL, are designed for workloads that include visual content. These models can be useful when text alone is not enough.
Common use cases include:
Image description
Visual question answering
Chart or screenshot interpretation
Product image review
Frame-level video understanding
Document image inspection
Vision workloads often cost more than simple text tasks because visual inputs require extra processing. Providers may also count image inputs differently from text tokens. Some convert visual data into token-like units, while others use request-based or image-based pricing.
Before choosing a vision model, check how the provider bills:
Images
Video frames
Resolution
File size
Repeated inputs
Batch requests
Output text
A Nano Vision model can be cost-effective if the task is focused. For example, extracting simple labels from product images is usually a better fit than asking for long visual reasoning over many frames.
Super models are the middle ground for reasoning and agents
Super-class models sit in the practical middle for many applications. They cost more than Nano models, but they can handle broader instructions and more complex tasks.
They are often a better fit for:
Agent workflows
Multi-step reasoning
Tool calling
Data analysis explanations
More reliable instruction following
Longer answers
Complex classification
Moderate code-related tasks
If Nano gives inconsistent answers but Ultra feels too expensive, Super is often the next tier to test.
For many production systems, the best setup is not one model. A Super model might handle the main response while a Nano model handles preprocessing, routing, or validation.
Flagship 70B models are for strong general instruction following
The Llama-3.1-Nemotron-70B class sits closer to a high-capability general model than a small utility model. It can be useful when answer quality, instruction following, and reliability matter more than the lowest possible cost.
Good fits include:
Customer-facing assistants with careful guardrails
Complex writing and transformation tasks
Detailed summarization
Policy-aware response generation
Conversational agents
Broad internal knowledge assistants
Tasks where smaller models miss nuance
Based on the representative range in this guide, this tier can have a much higher input cost than Nano or Super. That means it should earn its place in the architecture.
A smart way to test it is to compare it against a Super model on your own prompts. Do not rely only on benchmark claims. Measure:
Accuracy
Refusal behavior
Format compliance
Latency
Average output length
Human review pass rate
Total cost per successful task
Sometimes a cheaper model wins because it is good enough. Sometimes the larger model wins because it reduces retries, corrections, or human review.
Ultra models are for hard reasoning and complex workloads
Ultra-class models are the high-capability tier for demanding workloads. They are usually not the first model to use for every request, because output costs can be much higher than Nano or Super tiers.
They make sense when the task is hard enough to justify the cost.
Examples include:
Complex analytical reasoning
Long-context synthesis
Multi-step agent planning
High-value research assistance
Difficult code analysis
Workflows where wrong answers are expensive
Tasks that need stronger reasoning before tool use
The best use of Ultra models is often selective. Use them when confidence is low, the task is high value, or a cheaper model fails validation.
For example, an AI system might use:
Nano to classify the request
Super to produce the first answer
Ultra only when the answer fails checks or the task is tagged as high complexity
That structure can save money while preserving quality for the hardest requests.
Hosted API, NVIDIA endpoints, or self-hosting
The provider choice can matter as much as the model tier. Nemotron models can appear in several deployment paths, each with a different cost profile.
Hosted third-party APIs are fastest to start
A hosted API provider gives you an endpoint, keys, usage tracking, and billing. This is usually the simplest path for testing and early production.
Benefits include:
Fast setup
No GPU management
Usage-based pricing
Easier experimentation across models
Built-in rate limiting and logs on many platforms
Tradeoffs include:
Provider markup
Less control over infrastructure
Possible model availability changes
Shared capacity limits
Data handling terms that need review
Hosted APIs are best when you want to test Nemotron quickly, keep engineering effort low, and pay only for actual usage.
NVIDIA API Catalog and NIM help bridge testing and deployment
NVIDIA has positioned Nemotron models as part of its broader AI software and inference ecosystem. Depending on availability, developers may encounter Nemotron through NVIDIA-hosted model endpoints, the NVIDIA API Catalog, or NVIDIA NIM.
NIM, short for NVIDIA Inference Microservices, is designed to package and serve models in a way that can run across supported environments. It can be useful for teams that want more control than a public hosted API gives, but do not want to build the full serving stack from scratch.
The exact cost depends on the deployment model. You may need to account for:
NVIDIA software access or licensing terms
Cloud GPU instances
On-premises GPU hardware
Kubernetes or container infrastructure
Operations and monitoring
Support requirements
This route makes sense when you need stronger control over security, latency, data location, or scaling.
Self-hosting can pay off at scale
Self-hosting looks attractive because you avoid per-token API prices from a hosted provider. But the cost does not disappear. It moves.
Self-hosted cost includes both fixed and variable parts.
Fixed costs may include:
GPU capacity
Setup time
Deployment tooling
Security review
Monitoring systems
Model operations work
Variable costs may include:
Power or cloud runtime
GPU utilization
Network transfer
Storage
Scaling overhead
Incident response
Self-hosting is usually better when usage is high and predictable. Hosted APIs are usually better when usage is uncertain, low volume, or changing quickly.
A practical rule: if your monthly hosted bill is small, self-hosting may not be worth the added complexity. If the bill is large and stable, start comparing GPU utilization and operations cost.
Hidden cost factors that affect the final bill
Token price is only part of the budget. Real applications often cost more because prompts expand, users ask for longer answers, retries happen, and tool calls add work.
Prompt length can grow quietly
A simple prompt might be only a few hundred tokens during testing. In production, it can grow quickly.
Input tokens may include:
System instructions
Safety rules
Brand or style rules
User history
Retrieved documents
Tool definitions
Few-shot examples
JSON schemas
Conversation memory
A retrieval-augmented generation system can be especially token-heavy. If each request injects several long documents into the prompt, input cost will rise even if output stays short.
To control this, limit retrieved context to what the model actually needs. Shorter context can be cheaper and sometimes more accurate.
Long outputs can dominate cost
Since output tokens often cost more, response length has a big effect.
A model that gives 1,000-token answers will cost far more than one that returns concise structured output. This is especially true in Ultra-class workloads, where output token rates can be several times higher than input rates.
Use clear output limits when possible:
Ask for a short answer
Set a maximum token limit
Request structured JSON
Avoid unnecessary explanations
Summarize only what changed
Return labels instead of paragraphs when labels are enough
For background automation, short outputs are usually better. For user-facing experiences, give the model enough room to be helpful, but not unlimited space.
Retries and validation can double usage
A failed model response is not free. If your app retries the same request, asks another model to check it, or sends the result to a repair prompt, each step adds tokens.
This is common in structured-output workflows. A model may return invalid JSON, miss a field, or use the wrong enum value. The repair step may be cheap once, but expensive at scale.
You can reduce this with:
Clear schemas
Shorter prompts
Strict output instructions
Better examples
Provider features for structured generation when available
Validation before downstream actions
The best pricing plan includes expected retries, not just successful first attempts.
Latency can change infrastructure cost
A model with a low token price is not always the lowest-cost choice if it is slow for your workload.
Slow responses can affect:
User experience
Queue length
Worker count
Timeout rates
Concurrent requests
Downstream system load
For self-hosted systems, latency and throughput directly affect how many GPUs you need. A faster model can lower infrastructure cost even if it is slightly less capable.
Measure cost per completed task, not only cost per token.
How to choose the best Nemotron tier
The best Nemotron tier is the cheapest one that meets your quality, latency, and reliability bar. That sounds simple, but you need a repeatable test to find it.
Start with the task type
Match the tier to the job.
Task type | Suggested starting tier | Why it fits |
Classification, tagging, routing | Nano | Short outputs and high volume favor low-cost models |
Basic extraction | Nano | Works well when fields are clear and validation is easy |
Image understanding | Nano Vision | Designed for visual inputs when available |
General chatbot or assistant | Super | Better reasoning and instruction following than smaller models |
Agent workflow with tools | Super | Stronger fit for multi-step tasks |
Advanced instruction following | Flagship 70B | Better for nuanced user-facing responses |
Complex reasoning or high-value analysis | Ultra | Higher cost can be justified by harder work |
Start lower than you think. Move up only when the smaller tier fails your tests.
Test with real prompts
Small differences in prompts can change model performance. Build a test set from real examples, not only ideal sample prompts.
Include:
Easy requests
Common requests
Ambiguous requests
Long requests
Edge cases
Malicious or unsafe requests if relevant
Examples where format must be exact
Examples where the model should say it does not know
For each model, track:
Success rate
Average input tokens
Average output tokens
Retry rate
Latency
Human review rate
Cost per successful result
This prevents a common mistake: choosing a model because it has a low price per million tokens while ignoring failed responses.
Use routing to avoid overpaying
A single model for everything is simple, but often wasteful.
A routed setup can reduce cost:
Nano handles basic classification
Nano or Super handles standard requests
Flagship or Ultra handles complex requests
Vision models handle only visual inputs
A validation step catches poor outputs before users see them
Routing works best when you can define complexity signals.
Useful signals include:
Prompt length
User intent
Confidence score
Missing information
Tool use needed
Risk level
Expected answer length
Prior failure on a cheaper model
This lets you reserve high-cost models for the work that needs them.
Compare total workflow cost
Do not compare tiers only by token price. Compare the full workflow.
A cheaper model may need:
More retries
More validation
More human review
More prompt engineering
More fallback calls
A more expensive model may reduce those costs.
The right metric is often cost per accepted answer.
For example, if a Nano model costs very little but only passes validation 70% of the time, while a Super model costs more but passes 95% of the time, the Super model may be cheaper once you include retries and review.
Practical tier recommendations
Here is a plain-English way to choose.
Use Nano when volume matters most
Pick Nano if the task is narrow, repetitive, and easy to verify.
Good examples include:
Classify documents by type
Extract simple fields
Route tickets
Generate short descriptions
Summarize short notes
Normalize messy text
Nano is also a strong default for preprocessing. Even when your final answer uses a larger model, Nano can reduce the load by cleaning or sorting inputs first.
Use Nano Vision for image and video-like tasks
Pick Nano Vision when the input includes visual content and the goal is focused.
Good examples include:
Describe an image
Detect visible objects
Answer simple questions about a screenshot
Extract information from a chart
Review image content before routing
Check visual billing carefully. Vision workloads can behave differently from text-only pricing.
Use Super for most serious AI applications
Super is a good first test for many production apps because it balances cost and capability.
Use it for:
Agents
Internal assistants
Tool calling
Support workflows
Data interpretation
Moderate reasoning
Long-form answers with some complexity
If you are unsure where to start, test Super against Nano. If Nano is good enough, use Nano. If not, Super may be the practical middle.
Use Flagship 70B when instruction quality matters
Choose a 70B-class model when the task needs stronger writing, better instruction following, or more reliable interaction.
Good examples include:
Customer-facing assistant responses
Complex summaries
Detailed transformations
Knowledge assistant answers
More nuanced conversational flows
Because representative pricing can be higher, reserve this tier for places where quality improves the product enough to justify the cost.
Use Ultra only where the work is hard enough
Ultra-class models should usually be selective tools, not default tools.
Use them for:
Difficult reasoning
Complex planning
High-value analysis
Workflows where errors are costly
Requests that fail cheaper tiers
Tasks that need careful synthesis across many inputs
If the request is simple, Ultra is usually overkill. If the request is complex, Ultra may save time and reduce failed attempts.
Hosted API pricing versus self-hosted economics
The API-vs-self-hosting decision is one of the biggest pricing questions.
Hosted API
Best for testing, early production, variable usage, and small teams. You pay by usage and avoid GPU operations.
Self-hosting
Best for high, steady volume or strict control needs. You manage infrastructure, scaling, and uptime.
Hosted APIs are simpler. They are usually the fastest way to learn which Nemotron model fits your task. You can test several models, measure cost, and ship without managing GPU servers.
Self-hosting can make sense when:
Usage is high and predictable
Latency requirements are strict
Data control requirements are strict
You already have GPU infrastructure
Your team can operate model serving reliably
Provider pricing is high relative to your volume
The break-even point is specific to your workload. To estimate it, compare:
Monthly hosted API bill
GPU cost for equivalent throughput
Expected utilization
Engineering cost
Operations cost
Support and reliability requirements
Cost of downtime
Security and compliance work
If GPU utilization is low, self-hosting can be expensive. Idle GPUs still cost money.
A simple decision framework
Use this sequence before committing to a provider or tier.
Define the unit of work
Start by defining what one task means.
Examples:
One chat turn
One document summary
One ticket classification
One image review
One agent run
One report generation
Then measure average input and output tokens for that unit.
Estimate monthly volume
Estimate how many units you expect each month. Include peak periods, not just the average.
Ask:
How many users will make requests?
How many requests will each user make?
How long will the average prompt be?
How long should the answer be?
How many retries should you expect?
How much context will retrieval add?
Test at least two tiers
Do not assume the largest model is required. Test the smallest reasonable model and one stronger model.
For many teams, that means:
Nano versus Super for text automation
Super versus Flagship for assistants
Super versus Ultra for reasoning-heavy tasks
Nano Vision versus a stronger multimodal model if available
Use the same test set and scoring method.
Calculate cost per successful task
This is the number that matters.
Include:
First attempt cost
Retry cost
Repair prompts
Validation prompts
Fallback model calls
Human review if needed
Tool call overhead
Hosting or infrastructure cost
The lowest token price does not always produce the lowest task cost.
Decide how much control you need
If speed to launch matters most, use a hosted provider. If control matters more, evaluate NIM or self-hosting.
Control questions include:
Do you need private networking?
Do you need specific data residency terms?
Do you need a dedicated endpoint?
Do you need predictable latency?
Do you need custom scaling rules?
Do you need to run in your own cloud account?
The answers may matter more than a small difference in token price.
Common pricing mistakes to avoid
Nemotron pricing can look simple in a table, but several mistakes can distort estimates.
Using demo prompts for cost forecasts
Demo prompts are often short. Production prompts are longer because they include instructions, context, history, schemas, and safety rules.
Measure with real prompts before forecasting.
Ignoring output length
A short prompt can still produce a long answer. Since output tokens often cost more, uncontrolled answers can raise the bill quickly.
Set output limits where the product allows it.
Sending too much retrieved context
Retrieval can improve answers, but dumping full documents into every prompt is expensive and can confuse the model.
Use only the most relevant passages.
Choosing the biggest model by default
Large models are useful, but they are not always needed. Many tasks do not require deep reasoning.
Start with the smallest model that might work, then move up based on measured failures.
Forgetting about retries
Invalid JSON, poor formatting, timeouts, and weak answers can all trigger retries. Forecast them.
A model with a lower retry rate may lower the full workflow cost.
Treating provider prices as permanent
Provider pricing can change. Model availability can change. Context windows and rate limits can change.
Review pricing before large launches and build your app so you can switch models if needed.
For most teams, the best path is to test Nemotron pricing from the bottom up.
Start with Nano for high-volume text tasks. Use Nano Vision when visual inputs are required. Move to Super when the task needs stronger reasoning or agent behavior. Test Flagship 70B when instruction quality matters in user-facing flows. Reserve Ultra for the hardest, highest-value work.
The most useful pricing number is not the listed cost per 1 million tokens. It is the cost per successful task after prompts, outputs, retries, validation, and provider choice.
If you measure that number across several tiers, the right Nemotron model becomes much easier to choose.
Comments