DeepInfra Pricing: Per-Token Rates, Dedicated GPU Cost & the Serving Caveats (2026)

DeepInfra Per-Token Pricing (July 2026)

All prices per million tokens (MTok), input / output, from deepinfra.com/pricing as of July 2026. Many models also list a cached-input rate, charged when a prefix has already been processed, typically 3-5x cheaper than the standard input price. Rates and model availability change often on DeepInfra, so verify before you build.

DeepInfra also resells proprietary models through the same API (Claude Sonnet 5 around $2.00 / $10.00, Claude Opus 4.8 around $5.00 / $25.00, Gemini 2.5 Pro around $1.25 / $10.00 per MTok). Those are pass-through rates set by the model owner, not DeepInfra's open-model economics, so they do not carry the FP4 caveat below.

DeepInfra Dedicated GPU Pricing

For workloads that need guaranteed capacity or a model DeepInfra does not serve on the shared pool, you rent a dedicated GPU by the minute. Rates below are the on-demand hourly prices from deepinfra.com/gpu-instances and the pricing page, July 2026. Billing is per minute with no egress fees.

The 8x B200 node at $29.52/hr works out to $3.69 per GPU, the same as a single unit, so there is no bulk discount at the node level on the self-serve page. Larger DGX H100, B200, and B300 clusters with 3.2 Tbps interconnect are quoted through dedicated@deepinfra.com, not the self-serve page.

Billing, Rate Limits, and Free Tier

DeepInfra's commercial model is postpaid and usage-based. There are no contracts, no upfront fees, no seat fees, and no idle-GPU charges on serverless. You pay per token, and invoices are issued automatically each month once usage crosses a tier threshold (roughly $20 to $10,000+, depending on account history).

The service-tier multipliers are worth knowing: Flex runs at 0.8x base price for latency-tolerant traffic, Standard at 1x, and Priority at 1.5x for lower-latency scheduling. If your traffic can absorb queue time, Flex cuts the already-low per-token rate by another 20%.

Embeddings, Image, and Audio Pricing

DeepInfra serves more than text models. The rates below are July 2026 from the pricing page.

Embeddings at $0.005-$0.01 per million input tokens are among the cheapest available, which is a real advantage for large-scale retrieval indexing where you embed millions of documents once. As with the text models, the low price reflects the same commodity-host positioning, so benchmark embedding quality on your own retrieval eval before standardizing on it.

The Serving-Quality Caveats the Sticker Price Hides

DeepInfra's prices are low because of specific serving choices, and those choices have tradeoffs the pricing page does not surface. This is not a knock on DeepInfra: FP4 serving is a legitimate, documented tradeoff that is right for many production workloads. It is a knock on comparing providers by sticker price alone. Here is what changes underneath the number.

DeepInfra's own DeepSeek V4 Pro benchmark reports ~33 tok/s output and a 1.19s time-to-first-token on its FP4 deployment, with a 66K served context. For batch and latency-tolerant work, that is fine. For an interactive coding agent where a human is waiting on each turn, 33 tok/s is the difference between staying in flow and context-switching away.

DeepInfra vs Morph vs OpenRouter on Open Coding Models

Three different shapes. DeepInfra is a commodity serverless host optimized for the lowest sticker price. OpenRouter is a router that fans requests out to third-party providers (frequently DeepInfra itself) and adds a routing layer. Morph serves a curated set of open coding models on custom kernels with speculators and prompt caching, tuned for the agent loop rather than the lowest unit price.

For reference, Morph's open coding models (per MTok, input / output): GLM-5.2 at $1.10 / $4.10 (1M context), Qwen 3.5 397B at $0.50 / $3.50 with $0.30 cached (262K), Qwen 3.6 27B at $0.289 / $2.40 (131K), MiniMax M3 at $0.60 / $2.40 (256K), and DeepSeek V4 Flash at $0.139 / $0.278 (1M). See the full lineup and live rates on the pricing page.

The unit prices are close on some models and lower on DeepInfra for others. That is the point: sticker price is a wash or a small DeepInfra win, and the decision comes down to what the token buys. DeepInfra optimizes for the cheapest FP4 token under load; Morph optimizes the serving stack (quantization disclosed, speculative decoding, prompt caching) so an agent finishes the same task in fewer turns and less wall-clock time. If your workload is offline batch or embedding, DeepInfra's price is hard to beat. If it is an interactive agent, the serving quality is where the real cost lives. More on picking the cheaper option per workload in the LLM cost optimization guide and the OpenRouter alternative breakdown.

When the Cheap Token Is Actually Cheaper

The trap in provider comparisons is treating the per-token price as the total cost. The real cost of running an agent is price-per-token multiplied by tokens-consumed multiplied by turns-to-completion, plus the developer time spent waiting. A cheaper token that needs more turns or generates slower can cost more, not less.

The pattern: DeepInfra is the right call when the developer is not waiting and the token quality only has to clear a bar you can verify once. It is the wrong call when a human is in the loop turn by turn, or when long context and exact outputs are load-bearing. That is a workload decision, not a "which provider is cheapest" decision, and most teams end up using more than one provider for exactly this reason.

Frequently Asked Questions

How much does DeepInfra cost per token?

As of July 2026, per MTok (input / output): DeepSeek-V4-Flash $0.09 / $0.18, DeepSeek-V4-Pro $1.30 / $2.60, DeepSeek-V3.2 $0.26 / $0.38, GLM-5.2 $0.93 / $3.00, GLM-4.7-Flash $0.06 / $0.40, Kimi-K2.7-Code $0.74 / $3.50, Qwen3.5-397B $0.45 / $3.00, and Llama-3.3-70B $0.10 / $0.32. Many models add a cached-input rate 3-5x cheaper than standard input. Rates from deepinfra.com/pricing.

How much does a dedicated GPU cost on DeepInfra?

On-demand, July 2026: A100 80GB $0.89/hr, H100 80GB $2.20/hr, H200 141GB $2.69/hr, B200 180GB $3.69/hr, B300 270GB $4.89/hr, billed by the minute with no egress fees. An 8x B200 node is $29.52/hr. Some third-party trackers cite older, lower H100/H200/B200 numbers; confirm on deepinfra.com/gpu-instances.

Does DeepInfra have a free tier?

No permanent free tier. Billing is postpaid per token with no upfront fees, no minimums, and no seat fees, invoiced monthly against tier thresholds. New accounts typically receive a small amount of trial credit to start.

What quantization does DeepInfra use?

FP4 by default on its flagship serverless models, which is the main driver of the low per-token price. FP4 trades numeric precision for lower memory bandwidth and steadier throughput under load. Outputs can differ subtly from an FP8 or FP16 build of the same model, so benchmark the served variant on your own data if bit-fidelity matters.

What are DeepInfra's rate limits?

Each account is limited to 200 concurrent requests as of July 2026. There is no published per-minute request or token cap; the concurrency ceiling is the binding constraint. The API is OpenAI-compatible at api.deepinfra.com/v1/openai. A dedicated GPU rental removes shared-pool contention for higher, guaranteed concurrency.

Is DeepInfra cheaper than OpenRouter?

For a model DeepInfra serves directly, usually yes, because OpenRouter routes to third-party providers (often DeepInfra itself) and adds a routing layer. OpenRouter's value is breadth and automatic failover across many providers, not the lowest unit price on any one model. See the OpenRouter alternative breakdown.

How fast is DeepInfra inference?

Model-dependent. DeepInfra's own benchmark reports DeepSeek V4 Pro at ~33 tok/s output with a 1.19s time-to-first-token on its FP4 deployment, plus a 66K served context. Premium hosts serving FP8 builds of the same models often deliver several times that throughput. DeepInfra optimizes for cost and stability under load rather than peak tokens-per-second.

Should I use DeepInfra for a coding agent?

For batch, background, or embedding work where no human is waiting, yes: the price is hard to beat. For an interactive coding agent where a developer waits on each turn, the ~33 tok/s FP4 throughput and truncated served context are real costs the sticker price hides. Most production systems use a fast, agent-tuned host for interactive turns and a commodity host like DeepInfra for offline batch. Morph serves open coding models on custom kernels tuned for the interactive loop.