Granite-4.2-8B Pricing Guide: Provider Comparison

Granite-4.2-8b is a practical pick for anyone shopping for a small open-weight reasoning model. It costs $0.06 per million input tokens and $0.25 per million output tokens. It also scores 11 on the Artificial Analysis Intelligence Index among small (4B to 40B) open-weight models.

Its input price sits below the $0.12 median for comparable models, and its output price matches the $0.25 median. You can reach it directly or through routed access across multiple providers.

Granite-4.2-8b is an 8-billion-parameter reasoning model from IBM’s Granite family, released in late August 2026 and post-trained from Granite-4.1-8B-Base. It is a decoder-only dense transformer with text-in, text-out support, an Apache 2.0 license, and public weights on Hugging Face.

Developers get a 131,072-token context window, tool calling, structured JSON output, and three reasoning modes: full thinking, low-effort, and non-thinking. The mode you pick sets how much deliberation you pay for. To test locally, the quantized Granite 4.2 8B build on Ollama is a convenient starting point.

The model’s appeal comes from the shape of its tradeoff. It combines open weights, a commercial-friendly license, and long context with an Intelligence Index score of 11, ranked 35th of 141 models. Artificial Analysis also calls it somewhat verbose, which matters because output-heavy reasoning models can look cheap on input and expensive in practice.

On speed, first-token latency is competitive at 0.85 seconds against a 1.17-second median. Provider-level throughput varies, so provider choice is part of the pricing decision.

Evaluating Granite-4.2-8b comes down to one practical question: do its cost profile, 131K context window, and provider mix fit your production constraints? This guide covers DeepInfra, CoreWeave, and OpenRouter’s routing layer.

Granite-4.2-8b Executive Summary

Granite-4.2-8b is priced for cost-conscious production use. It costs $0.06/M input, $0.25/M output, and $0.015/M cached tokens on DeepInfra. OpenRouter lists the same rates on its DeepInfra route, and CoreWeave offers $0.10/M input, $0.15/M output, and $0.05/M cached tokens.

It suits teams that want an Apache 2.0 reasoning model with long context, tool calling, and flexible deployment. DeepInfra is the strongest choice for low-cost direct access, while CoreWeave and OpenRouter are the main alternatives.

Best For	Provider Recommendation	Why
Lowest price and cost-sensitive workloads	DeepInfra	DeepInfra lists $0.06/M input, $0.25/M output, and $0.015/M cached tokens, the lowest input and cache prices among the providers covered.
Direct production deployment with API features	DeepInfra	It offers public API access, zero data retention, JSON output, function calling, private endpoints, and the full 131,072-token context window.
Easiest onboarding and fastest time to first call	OpenRouter	OpenRouter is OpenAI-compatible and adds automatic failover plus Balanced, Nitro, Floor, and Exacto routing modes, which reduces integration and operations friction.
RAG, document-heavy, or high-throughput use cases	DeepInfra	Artificial Analysis measures 120 output tokens per second on DeepInfra against 89 on CoreWeave, and DeepInfra also has the lower input price.
Managed model access with reliability safeguards	OpenRouter	OpenRouter lists 99.98% availability over the last 24 hours, compared with 99.03% without routing.
Tool-calling workloads	DeepInfra, or OpenRouter in Exacto mode	DeepInfra lists JSON output and function calling, and OpenRouter’s Exacto mode routes for the highest tool-calling accuracy.

Understanding Tokens and How You’re Charged

Token pricing looks simple until a reasoning model writes more than you expected. Granite-4.2-8b is cheap on input and reasonable on output, but Artificial Analysis rates it somewhat verbose. Plan for that and the pricing works well. Look only at the headline input rate and the bill can surprise you.

A token is a chunk of text that can be shorter or longer than a word. Short words may be one token. Longer words, punctuation, code, and JSON structure all count too.

You are typically billed separately for:

• tokens you send to the model
• tokens the model generates back
• cached prompt tokens, when a provider discounts repeated prompt prefixes

Token Type	What It Is	Why It Matters
Input tokens	The tokens in your prompt, system message, tool schema, chat history, and retrieved context	Granite-4.2-8b costs $0.06/M on DeepInfra. This helps with RAG, long instructions, and multi-turn agent state.
Output tokens	The tokens the model generates in its reply, including reasoning-heavy or structured responses	This is where costs creep up. Granite-4.2-8b costs $0.25/M output on DeepInfra, and Artificial Analysis rates it somewhat verbose.
Cached tokens	Reused prompt tokens that a provider serves from cache at a discount	Useful when you resend large system prompts, tool definitions, or repeated context. DeepInfra lists $0.015/M, a 75% discount from the base input rate.

For Granite-4.2-8b, the practical billing pattern looks like this:

• Long prompts are relatively cheap.
• Long answers matter more.
• Reused prompt prefixes are where caching pays off.

Artificial Analysis reports a blended rate of $0.05 per 1M tokens, using a 7:2:1 cache-hit, input, and output mix. This blended rate only applies if your traffic follows that mix.

• If your app produces long reasoning traces, verbose tool arguments, or bulky JSON, your real cost skews closer to output pricing.
• If your app repeatedly sends the same system prompt, tool schema, and document boilerplate, cache discounts do real work.

Provider Token-Cost Tradeoffs for Granite-4.2-8b

Provider choice changes the shape of your bill. DeepInfra is cheaper on input and cache, while CoreWeave is cheaper on output.

Provider	Input	Output	Cache	Token-Cost Advantage	Token-Cost Downside
DeepInfra	$0.06/M	$0.25/M	$0.015/M	Best fit for prompt-heavy workloads, RAG, long context, and reusable prompt prefixes	Higher output price, so verbose generations can erase the cheap-input advantage
OpenRouter via DeepInfra route	$0.06/M	$0.25/M	$0.015/M	Same token economics as DeepInfra, plus routing convenience	Same output-cost profile as DeepInfra
CoreWeave via OpenRouter	$0.10/M	$0.15/M	$0.05/M	Better fit for output-heavy workloads, especially when the model reasons at length	Input and cache cost more, so large prompts and repeated context add up
OpenRouter auto-routing	$0.06 to $0.10/M	$0.15 to $0.25/M	$0.015 to $0.05/M	Failover and routing modes, including Floor for the cheapest provider	Cost depends on which provider serves each request

The practical split looks like this:

• Choose DeepInfra if your app sends a lot of tokens into the model.
• Choose CoreWeave if your app gets a lot of tokens back from the model.
• Choose OpenRouter routing if you want operational flexibility and can accept variable per-request pricing.

Speed adds a second factor. Artificial Analysis measures 120 output tokens per second on DeepInfra and 89 on CoreWeave. A 500-token response takes 21.69 seconds on DeepInfra and 28.72 seconds on CoreWeave. Time to first chunk is close, at 0.77 and 0.74 seconds.

Benchmarked verbosity makes output cost a budgeting issue. Artificial Analysis measured 130M output tokens across its Intelligence Index runs, against an 82M median for comparable models. Price this model on more than input cost.

A few concrete patterns:

• RAG over long documents: DeepInfra usually has the cleaner cost profile because input and cache are cheap.
• Structured extraction with short answers: DeepInfra still tends to win because output stays bounded.
• Reasoning assistant with long responses: CoreWeave can be cheaper overall despite the higher input rate, though its measured output speed is lower.
• Agent workflows with repeated tool schemas and stable system prompts: DeepInfra benefits more from low cache pricing.
• Router-based deployments: OpenRouter can send traffic to either provider, so monitor the actual provider mix instead of trusting the top-line listing.

The safest way to estimate Granite-4.2-8b cost is to model three separate numbers:

• average input tokens per request
• average output tokens per request
• cache hit rate on repeated prompt prefixes

Skip the output estimate and the model can surprise you. Skip cache behavior and you can misprice repeated-agent workloads by a wide margin.

DeepInfra: Best Fit for Prompt-Heavy Workloads

DeepInfra is the lowest-cost option for running Granite-4.2-8b at production scale. The company says it built its service from the ground up, from GPU hardware to the API layer. That ownership gives it control over cost, performance, and reliability.

With this model, DeepInfra pairs low token pricing with practical deployment features: public API access, zero data retention, JSON output, function calling, and private endpoints.

Model Name	Best Use Case	Context Window	Input (per 1M)	Output (per 1M)
Granite-4.2-8b	Cost-efficient reasoning, tool use, and long-context API workloads	131,072 tokens	$0.06	$0.25

DeepInfra lists Granite-4.2-8b at $0.06 per 1M input tokens and $0.25 per 1M output tokens. This makes it an efficient option for teams optimizing token spend, especially on prompt-heavy and repeated-context workloads. DeepInfra also offers $0.015 per 1M cached tokens.

If you expect meaningful volume, DeepInfra is the provider to shortlist first for Granite-4.2-8b.

Real-World Cost Scenarios for Developers

Each scenario below runs Granite-4.2-8b on DeepInfra and compares CoreWeave at its listed rates. DeepInfra is strongest when a workload is prompt-heavy, context-heavy, or cache-friendly.

Scenario 1: RAG support assistant over large internal docs

You are building a developer-facing support bot that searches internal runbooks, SDK docs, incident notes, and architecture pages before answering. Each request carries a large prompt with retrieved context, while the answer stays moderate. RAG workloads spend more on input than on output, so low input pricing matters most.

Volume	Model	Provider	Input Tokens	Output Tokens	Monthly Cost
10M tokens/month	Granite-4.2-8b	DeepInfra	8M	2M	$0.98

Cost math:

• Input: 8M × $0.06/M = $0.48
• Output: 2M × $0.25/M = $0.50
• Total: $0.98/month

The same workload on CoreWeave costs $1.10/month, so DeepInfra is cheaper by $0.12.

Scenario 2: Agent workflow with repeated tool schemas and cached system prompts

You are shipping an internal coding or ops agent that sends the same system prompt, tool definitions, and response schema on every call. DeepInfra’s $0.015/M cached rate makes those repeated prefixes much cheaper than normal input tokens.

IBM says the Granite 4.2 models think about which tool to call, and why, before making the call. That behavior suits agent workflows with stable scaffolding.

Volume	Model	Provider	Input Tokens	Output Tokens	Monthly Cost
10M tokens/month	Granite-4.2-8b	DeepInfra	2M input + 7M cached	1M	$0.48

Cost math:

• Input: 2M × $0.06/M = $0.12
• Cached: 7M × $0.015/M = $0.105
• Output: 1M × $0.25/M = $0.25
• Total: $0.475, or $0.48/month rounded

The same token mix on CoreWeave costs $0.70/month ($0.20 input, $0.35 cached, and $0.15 output), so DeepInfra is cheaper by about $0.23.

Scenario 3: Long-context document triage with short structured outputs

Suppose you process product specs, contracts, tickets, or compliance documents. You ask Granite-4.2-8b to return compact JSON, such as classifications, extracted fields, risk flags, or summaries. The model reads a lot and writes a little. You get its long context window and structured output support without paying a premium to send large inputs.

Volume	Model	Provider	Input Tokens	Output Tokens	Monthly Cost
50M tokens/month	Granite-4.2-8b	DeepInfra	45M	5M	$3.95

Cost math:

• Input: 45M × $0.06/M = $2.70
• Output: 5M × $0.25/M = $1.25
• Total: $3.95/month

The same workload on CoreWeave costs $5.25/month, so DeepInfra is cheaper by $1.30.

Scenario 4: Multi-turn app with persistent conversation state

You are building a multilingual assistant where each turn includes prior chat state, policy instructions, and retrieved snippets. Granite-4.2-8b supports 12 languages, and low input pricing keeps repeated context affordable. This works best when answers stay short while the prompt grows over time.

Volume	Model	Provider	Input Tokens	Output Tokens	Monthly Cost
20M tokens/month	Granite-4.2-8b	DeepInfra	16M	4M	$1.96

Cost math:

• Input: 16M × $0.06/M = $0.96
• Output: 4M × $0.25/M = $1.00
• Total: $1.96/month

The same workload on CoreWeave costs $2.20/month, so DeepInfra is cheaper by $0.24.

Scenario 5: Cheap experimentation before private deployment

Many developers start with prototyping rather than volume. Granite-4.2-8b on DeepInfra lets you test tool calling, JSON output, and long prompts through a public API. You can move to private endpoints with zero data retention later. A small token budget covers meaningful experiments.

Volume	Model	Provider	Input Tokens	Output Tokens	Monthly Cost
5M tokens/month	Granite-4.2-8b	DeepInfra	4M	1M	$0.49

Cost math:

• Input: 4M × $0.06/M = $0.24
• Output: 1M × $0.25/M = $0.25
• Total: $0.49/month

The same workload on CoreWeave costs $0.55/month, so DeepInfra is cheaper by $0.06.

What These Scenarios Show

The pattern holds across all five scenarios:

• DeepInfra is the best fit when Granite-4.2-8b reads more than it writes.
• It gets better when you can reuse prompt prefixes and benefit from $0.015/M cached tokens.
• It is especially attractive for:
  • RAG
  • extraction pipelines
  • multi-turn assistants
  • tool-using agents with stable schemas
  • early-stage prototyping that may later need private deployment

If large prompts, repeated context, and controlled output length dominate your workload, DeepInfra offers the cleanest cost profile of the providers covered here.

Conclusion

Choosing a provider for Granite-4.2-8b comes down to where your token spend lives. The model is inexpensive to feed and reasonably priced on output. Its measured verbosity makes the output side of the bill matter more than the headline input rate suggests.

Get that ratio wrong and the provider that looks cheapest on paper can cost more in practice.

Prompt-heavy and cache-friendly workloads fit DeepInfra’s $0.06/M input and $0.015/M cached rates best. Examples include RAG pipelines, tool-calling agents with stable schemas, and document extraction.

If your workload is output-heavy and the model reasons at length, model CoreWeave’s lower $0.15/M output rate against your actual token ratios. Weigh its lower measured output speed too. If operational flexibility matters, OpenRouter’s routing layer adds failover and higher reported availability.

The practical checklist is short: estimate your average input length, estimate your average output length, and decide whether reusable prompt prefixes can earn cache discounts. Those three numbers predict your monthly cost better than any blended benchmark rate.

Granite-4.2-8b’s Apache 2.0 license and public weights keep you free of any single provider. Starting on a managed API and migrating later is a real option. The Granite 4.2 8B chat completions API reference covers integration details.

Run a few representative requests through DeepInfra’s API, measure your actual token ratios, and build from there. The entry cost is low enough that the experiment is cheap.