DeepInfra raises $107M Series B to scale the inference cloud — read the announcement

Updated November 2026 for the DeepSeek-V4-Pro-0813 release.
DeepSeek-V4-Pro-0813 is the GA release of DeepSeek V4 Pro, an open-weight Mixture-of-Experts model with 1.6T total parameters, 49B active parameters and a 1M-token context window. DeepSeek released it on August 13, 2026, and it has been on DeepInfra since August 18. It ships under the MIT license and supports JSON mode, structured output and function calling. It replaces the preview DeepSeek first released on April 24, 2026.
On DeepInfra, DeepSeek V4 Pro costs $1.30 per 1M input tokens, $2.60 per 1M output tokens and $0.10 per 1M cached input tokens. There is no promo running; that is the list price. The Flex tier drops it to $1.04 / $2.08 / $0.08, and Priority raises it to $1.95 / $3.90 / $0.15.
Artificial Analysis now tracks 8 API providers for the 0813 model. DeepInfra has the lowest output price of the eight and the second-lowest blended price ($0.59 per 1M tokens, behind GMI at $0.55), with a 0.0% endpoint error rate. It is not the cheapest place for cached input, and DeepSeek’s own API is now cheaper than everyone during its off-peak hours. This guide covers both, plus five worked monthly cost scenarios.
For developers and ML teams, the question is not whether DeepSeek V4 Pro is capable. It is whether its price profile fits your workload: how much you send, how much it writes back, how much of your prompt repeats, and whether your jobs can wait.
DeepSeek V4 Pro is an open-weight reasoning model for coding, long-context analysis and agent workflows. If output tokens drive your bill, DeepInfra is the cheapest of the eight providers Artificial Analysis measures. If your traffic is mostly cache reads, or your batch jobs can run in DeepSeek’s off-peak window, other routes cost less per token. The table below maps each case to a route.
Pricing as of 2026-11-16.
| Best For | Provider Recommendation | Why |
|---|---|---|
| Output-heavy production workloads | DeepInfra (Standard) | $2.60 per 1M output tokens, the lowest output price among the 8 providers on Artificial Analysis. Most of the others charge $3.96. |
| Batch and non-urgent jobs | DeepInfra Flex, or DeepSeek off-peak | Flex bills $1.04 input and $2.08 output per 1M tokens. DeepSeek’s off-peak rate ($0.66 / $1.98) is lower still if you can schedule into its window. |
| Cache-heavy agents and RAG | DeepSeek API, or providers with a $0.044 cache rate | Cache reads cost $0.044 per 1M on DeepSeek (peak), DigitalOcean, Novita and SiliconFlow, against $0.10 on DeepInfra. DeepInfra’s lower output price wins back the gap once output is a real share of the bill. |
| Lowest blended price | GMI, with DeepInfra close behind | $0.55 vs $0.59 per 1M on Artificial Analysis’s 7:2:1 cache, input and output blend. |
| Fastest output and lowest answer latency | DigitalOcean | 140.0 tokens per second and 31.67 seconds to the first answer token, the best on both. Its error rate is 3.1%. |
| Reliability and compliance | DeepInfra | 0.0% error rate on Artificial Analysis, plus zero retention, SOC 2 and ISO 27001, and Priority ($1.95 / $3.90) when you need capacity at busy times. |
| Single API across many providers | OpenRouter | Lists 20 providers on the 0813 model and can fail over between them. |
Verdict: start with DeepInfra Standard for interactive traffic, move anything that can wait to Flex, and check DeepSeek’s off-peak rates if you run large scheduled batches. Pick a faster provider only when response time is the hard constraint.
Sources: Artificial Analysis providers page (DeepSeek V4 Pro 0813, Max reasoning effort), DeepSeek Models & Pricing, the DeepInfra model page and OpenRouter, accessed 2026-11-16.
0813 is the same base architecture as the April preview, with new post-training and a built-in speculative decoding module. DeepSeek’s own model name on its API, deepseek-v4-pro, now serves 0813. Here is what changed in the model, then in pricing and availability.
| Area | April preview | 0813 (GA) |
|---|---|---|
| Release | April 24, 2026 | August 13, 2026 |
| Reasoning control | Three modes (Non-think, Think High, Think Max) set by a special system prompt | reasoning_effort: low, high or max |
| Speculative decoding | None in the checkpoint | DSpark module built into the checkpoint |
Recommended top_p | 1.0 | 0.95 for agentic tasks, 1.0 otherwise |
| Max output (vendor guidance) | 384K context recommended for Think Max | 384K for high and max effort |
| Context window | 1M | 1M (unchanged) |
| Vision | Not supported | Not supported |
DeepSeek reports large gains on agentic and coding benchmarks. On its Hugging Face model card, DeepSWE rises from 12.8 to 62.7, Terminal Bench 2.1 from 72.1 to 87.9, and NL2Repo from 38.5 to 61.5. These are vendor-reported numbers run on DeepSeek’s own harness. On Artificial Analysis’s independent Intelligence Index, 0813 (Max) scores 23, level with the median of comparable open-weight models. See the DeepSeek V4 Pro model overview for the full benchmark table.
| Area | Earlier version of this guide | Current |
|---|---|---|
| DeepInfra model ID | deepseek-ai/DeepSeek-V4-Pro | deepseek-ai/DeepSeek-V4-Pro-0813 |
| DeepInfra input / output / cached (per 1M) | $1.74 / $3.48 / $0.145 | $1.30 / $2.60 / $0.10 |
| DeepInfra service tiers | Standard only | Standard, Flex (0.8×) and Priority (1.5×) |
| Serving precision on DeepInfra | FP4 | fp8 |
| Max output on DeepInfra | Not stated | 384K tokens (65,536 by default if max_tokens is unset) |
| DeepSeek first-party pricing | One flat rate | Peak and off-peak: $1.32 / $3.96 peak, $0.66 / $1.98 off-peak |
| Providers on Artificial Analysis | 6, then 10 | 8 |
| Blended price method | 3:1 input to output | 7:2:1 cache hit, input and output |
| DeepInfra blended price | $2.17 per 1M (3:1) | $0.59 per 1M (7:2:1) |
The two blended prices use different ratios, so they are not directly comparable. The current blend weights cache reads at 70%, which is why blended figures now sit well below list prices.
The original deepseek-ai/DeepSeek-V4-Pro ID is still live on DeepInfra at the same price. New integrations should use the 0813 ID.
If you have ever looked at a model bill and thought, “that prompt was not that long,” this is the part that explains why it was.
A token is a chunk of text the model reads or generates. It is not the same thing as a word. Short words may be one token. Longer words, code, JSON, whitespace patterns and odd punctuation can split into more. Pricing is based on tokens, so the shape of your workload matters more than the raw character count.
| Token type | What it is | Why it matters for DeepSeek V4 Pro |
|---|---|---|
| Input tokens | Tokens you send in the request | The largest cost for RAG, long-context and agent workloads. A full 1M-token prompt costs about $1.36 uncached on DeepInfra. |
| Output tokens | Tokens the model generates, reasoning included | Reasoning tokens bill at the output rate. This is where DeepInfra’s $2.60 rate saves the most. |
| Cached input tokens | Repeated prompt prefix billed at a discount | DeepInfra charges $0.10 (92% off its own input rate). Some providers charge $0.022 to $0.044. |
| Max output tokens | The cap on one response | Up to 384K on DeepInfra. If you leave max_tokens unset, the default is 65,536. |
| Blended tokens | A weighted mix of cache, input and output prices | Useful for ranking providers, unreliable for forecasting your own bill. |
What this means for 0813 specifically:
low, high and max change how many reasoning tokens the model produces before it answers, and every one of them bills as output.max_tokens to what the task needs.DeepSeek V4 Pro is one of those models where the headline price can mislead you if you don’t check how each provider bills input, output and cache reads separately. All prices are per 1M tokens.
| Provider / route | Input | Output | Cached | Advantage | Disadvantage | Best fit |
|---|---|---|---|---|---|---|
| DeepInfra Standard | $1.30 | $2.60 | $0.10 | Lowest output price on Artificial Analysis; 0.0% error rate; same rate around the clock | Cache read is 2–5× some other providers; 65.1 t/s output speed | Interactive apps, code generation, agents with real output volume |
| DeepInfra Flex | $1.04 | $2.08 | $0.08 | 20% off every line; a request Flex rejects is not charged | Waits up to 10 minutes for capacity, then returns HTTP 429 | Batch jobs, evals, backfills |
| DeepInfra Priority | $1.95 | $3.90 | $0.15 | Priority capacity when demand peaks | 1.5× the Standard rate | Latency-sensitive production paths |
| DeepSeek API, peak | $1.32 | $3.96 | $0.044 | The model creator’s own API; cheap cache reads | Highest output price here; peak runs 01:00–04:00 and 06:00–10:00 UTC on weekdays | Cache-heavy traffic during Asian and European business hours |
| DeepSeek API, off-peak | $0.66 | $1.98 | $0.022 | Lowest first-party rate; covers about 79% of the week, including the US Eastern working day | Price depends on the clock; 500-request concurrency limit | Scheduled batch work that fits the window |
| GMI | $1.056 | $3.168 | $0.035 | Lowest input price and lowest blended price ($0.55) on Artificial Analysis | Output costs 22% more than DeepInfra | Input-heavy, cache-heavy workloads |
| DigitalOcean | $1.32 | $3.96 | $0.044 | Fastest output (140.0 t/s) and first answer token (31.67 s) | 3.1% error rate; top-tier output price | Latency-critical user-facing features |
| Novita | $0.99 (OpenRouter) / $1.32 (Artificial Analysis) | $2.97 / $3.96 | $0.033 / $0.044 | Second-cheapest cost per Index task on Artificial Analysis ($1.86); 0.0% error rate | Price differs by route | Cache-heavy agent loops |
| Baseten | $1.32 | $3.96 | $0.132 | Second-fastest output (114.2 t/s) | Highest cache rate and blended price ($0.75) | Speed over cost |
| OpenRouter | $0.10 to $1.98 input across 26 endpoints | Varies by endpoint | Varies | One API key, automatic failover across 20 providers | The provider serving your request sets the price and cache behavior | Multi-provider fallback |
| Self-hosting (MIT weights) | GPU cost | GPU cost | n/a | Full control; weights are on Hugging Face | A 1.6T-parameter model needs a large multi-GPU cluster and an ops team | Very high, steady volume or strict data residency |
Source: Artificial Analysis providers page, OpenRouter (0813), DeepSeek Models & Pricing and the DeepInfra model page, accessed 2026-11-16. Artificial Analysis lists DeepSeek at its peak rate.
Output price is where DeepInfra leads.
Cached input is where DeepInfra does not lead.
DeepSeek’s peak and off-peak pricing changes the comparison.
Practical rule of thumb for DeepSeek V4 Pro billing
Cost trap to avoid: comparing providers on blended price alone. The 7:2:1 blend assumes 70% of your tokens are cache hits. If your app is output-heavy, the provider with the lowest blended price can be the most expensive one on your invoice.
0813 replaces the preview’s three prompt-based modes with one parameter, reasoning_effort, which takes low, high or max. DeepSeek describes low for simple tasks, high for daily agent workflows and max for complex tasks. On DeepInfra you can also send "none" to switch thinking off.
Reasoning tokens bill at the same rate as the final answer: $2.60 per 1M on DeepInfra Standard, $2.08 on Flex. A max request can cost several times what the same prompt costs at low. Artificial Analysis measured 119M output tokens at Max against 98.4M at High, about 21% more for one setting change.
If your app defaults to high effort for every request, check that the task needs it. Classification, extraction and short-answer tasks rarely benefit from max. Here is a batch-friendly request that sets effort, caps output and uses Flex:
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["DEEPINFRA_API_KEY"],
base_url="https://api.deepinfra.com/v1/openai",
)
response = client.chat.completions.create(
model="deepseek-ai/DeepSeek-V4-Pro-0813",
messages=[{"role": "user", "content": "Summarize this contract clause in three bullets: ..."}],
max_tokens=4096,
extra_body={
"reasoning_effort": "low",
"service_tier": "flex",
},
)
print(response.choices[0].message.content)
Drop "service_tier": "flex" for Standard pricing, or set it to "priority" for the Priority tier. The API reference lists every parameter.
DeepSeek V4 Pro is the largest model in the V4 family. It is no longer the top scorer, though. On Artificial Analysis’s Intelligence Index, DeepSeek V4.1 Flash 1017 scores 33 against 23 for V4 Pro 0813 (Max), and Artificial Analysis now calls V4.1 Flash DeepSeek’s flagship. V4.1 Flash costs $0.20 input and $0.60 output per 1M tokens on DeepInfra and accepts image input, which V4 Pro does not.
Use V4 Pro 0813 when your own evals show it does better on your tasks, for example on the long agentic coding runs where DeepSeek’s vendor-reported gains are largest. Otherwise, test V4.1 Flash first. The DeepSeek V4.1 Flash pricing guide has the full cost breakdown.
DeepInfra combines straightforward token pricing with infrastructure built for production. The platform runs on bare-metal infrastructure, which removes a layer of virtualization overhead that can affect both performance consistency and cost. Standard pricing is $1.30 per 1M input tokens, $2.60 per 1M output tokens and $0.10 per 1M cached tokens, with Flex and Priority tiers for jobs that need a lower price or faster service.
| Model / listing | Best use case | Context window | Input price (per 1M) | Output price (per 1M) |
|---|---|---|---|---|
| DeepSeek-V4-Pro-0813 (Standard) | Reasoning, coding and agent workflows | 1M | $1.30 | $2.60 |
| DeepSeek-V4-Pro-0813 (Flex) | Batch jobs, evals, backfills | 1M | $1.04 | $2.08 |
| DeepSeek-V4-Pro-0813 (Priority) | Latency-sensitive production paths | 1M | $1.95 | $3.90 |
The model runs at fp8 with a 1M-token context window and up to 384K output tokens. It supports JSON mode, structured output, function calling and reasoning control. The API is OpenAI-compatible: point your client at https://api.deepinfra.com/v1/openai, call /chat/completions and authenticate with Authorization: Bearer $DEEPINFRA_API_KEY. DeepInfra applies a zero-retention policy, holds SOC 2 and ISO 27001 certification, and offers private deployments when you need dedicated capacity.
Why this matters: on the $1.32 / $3.96 rate most Artificial Analysis providers list, every 1M output tokens costs $1.36 more than on DeepInfra. For a reasoning model that writes long answers, that difference is most of the bill.
On speed, DeepInfra’s endpoint measured 65.1 tokens per second and 2.17 seconds to first token on Artificial Analysis, mid-to-low in the field, so pick DigitalOcean or Baseten if raw throughput decides it. DeepInfra’s 0.0% error rate means fewer retries, and retries are output tokens you pay for twice. Teams comparing options across the broader model catalog can run V4 Pro and its lighter siblings on the same account and bill.
Below are five developer scenarios with monthly costs on DeepInfra, using Standard rates ($1.30 / $2.60 / $0.10) unless a scenario says otherwise. DeepInfra is not the cheapest route in every one of them, and each scenario says when it isn’t. Each one also prices the same workload on another route, using DeepSeek’s first-party API at its peak rate or the $1.32 / $3.96 rate that six of Artificial Analysis’s eight providers list.
If you are building a support copilot or internal docs assistant, you resend the same long system prompt, retrieval scaffold and tool instructions on every request. Caching is the main lever here, so this is the scenario where DeepInfra’s cache rate matters most. Our guide to prompt hygiene for cheaper, faster LLM calls covers how to keep that prefix cacheable.
Assumptions: 1,000 requests per month; 80,000 input tokens per request, of which 60,000 are cached and 20,000 bill at the normal input rate; 4,000 output tokens per request.
| Volume | Model | Provider | Input tokens | Output tokens | Monthly cost |
|---|---|---|---|---|---|
| 1,000 requests | DeepSeek-V4-Pro-0813 | DeepInfra | 20M standard + 60M cached | 4M | $42.40 |
Cost breakdown
Why DeepInfra fits: the cache discount cuts the 60M repeated tokens from $78.00 to $6.00, and the low output rate keeps answers cheap. JSON mode and function calling cover structured retrieval and tool use. On Flex, the same month costs $33.92.
Same workload on DeepSeek’s API at peak rates: 20M × $1.32 + 60M × $0.044 + 4M × $3.96 = $26.40 + $2.64 + $15.84 = $44.88, or $2.48 more than DeepInfra. DeepSeek’s cache line is $3.36 cheaper, but its output line costs $5.44 more. With a higher cache share and shorter answers, DeepSeek would win this scenario.
For a coding assistant that reads diffs, repository context and issue text, then emits structured review comments or patch suggestions, DeepSeek-V4-Pro-0813 is attractive on capability alone. DeepInfra makes it easy to run that workload with predictable pricing and tool-friendly output.
Assumptions: 10,000 requests per month; 12,000 input tokens and 2,000 output tokens per request.
| Volume | Model | Provider | Input tokens | Output tokens | Monthly cost |
|---|---|---|---|---|---|
| 10,000 requests | DeepSeek-V4-Pro-0813 | DeepInfra | 120M | 20M | $208.00 |
Cost breakdown
Why DeepInfra fits: DeepSeek reports 0813 at 62.7 on DeepSWE and 61.5 on NL2Repo (vendor-reported), up from 12.8 and 38.5 for the preview, which is the profile code-assistant builders want. JSON mode keeps review findings in a stable schema, and function calling lets the assistant trigger CI checks or repo lookups.
Same workload at $1.32 / $3.96: 120M × $1.32 + 20M × $3.96 = $158.40 + $79.20 = $237.60, or $29.60 more than DeepInfra.
Agent systems pay an invisible tax: they keep resending the same policy text, tool definitions and orchestration instructions. As DeepInfra’s role as a Hugging Face Inference Provider shows, chat completion on open-weight LLMs like DeepSeek V4 Pro is a first-class workload on the platform.
Assumptions: 50,000 requests per month; 10,000 input tokens per request (6,000 cached, 4,000 standard); 1,000 output tokens per request.
| Volume | Model | Provider | Input tokens | Output tokens | Monthly cost |
|---|---|---|---|---|---|
| 50,000 requests | DeepSeek-V4-Pro-0813 | DeepInfra | 200M standard + 300M cached | 50M | $420.00 |
Cost breakdown
Why DeepInfra fits: this is the classic agent loop with repeated scaffolding. Function calling and structured output are supported, and DeepSeek reports 74.1 on Toolathlon-Verified for 0813 (vendor-reported). A 0.0% error rate matters more here than anywhere else, because a failed step in a multi-step agent run wastes every token before it. Moving this job to Flex brings it to $336.00.
Same workload on DeepSeek’s API at peak rates: 200M × $1.32 + 300M × $0.044 + 50M × $3.96 = $264.00 + $13.20 + $198.00 = $475.20, or $55.20 more. DeepSeek’s cache line costs $16.80 less than DeepInfra’s; its output line costs $68.00 more.
Contract review, research summarization and policy extraction rarely need an answer in seconds. They can run overnight, which opens up two cheaper options: DeepInfra Flex and DeepSeek’s off-peak rate. This scenario compares both, on two batch shapes.
Assumptions (4a, document extraction): 2,000 documents per month; 100,000 input tokens and 5,000 output tokens per document; no caching. Assumptions (4b, generation-heavy batch): 20,000 jobs per month, such as synthetic data or test generation; 3,000 input tokens and 6,000 output tokens per job.
| Volume | Model | Route | Input tokens | Output tokens | Monthly cost |
|---|---|---|---|---|---|
| 4a: 2,000 docs | DeepSeek-V4-Pro-0813 | DeepInfra Standard | 200M | 10M | $286.00 |
| 4a: 2,000 docs | DeepSeek-V4-Pro-0813 | DeepInfra Flex | 200M | 10M | $228.80 |
| 4a: 2,000 docs | DeepSeek V4 Pro | DeepSeek API, off-peak | 200M | 10M | $151.80 |
| 4b: 20,000 jobs | DeepSeek-V4-Pro-0813 | DeepInfra Standard | 60M | 120M | $390.00 |
| 4b: 20,000 jobs | DeepSeek-V4-Pro-0813 | DeepInfra Flex | 60M | 120M | $312.00 |
| 4b: 20,000 jobs | DeepSeek V4 Pro | DeepSeek API, off-peak | 60M | 120M | $277.20 |
Cost breakdown, 4a (document extraction)
Cost breakdown, 4b (generation-heavy)
What the numbers say: on raw token price, DeepSeek’s off-peak rate wins both batches. How much depends on the shape. On input-heavy extraction (4a), off-peak is $77.00 below Flex, because its input rate ($0.66) is well under Flex’s ($1.04). On output-heavy generation (4b), the gap shrinks to $34.80, because Flex’s output rate ($2.08) is within 5% of off-peak’s ($1.98). Run either batch during DeepSeek’s peak hours and it costs $303.60 (4a) or $554.40 (4b), more than DeepInfra Standard.
Why DeepInfra Flex still fits: Flex prices are the same at any hour, so you don’t have to fit jobs into a time window or re-plan around holidays. A request Flex can’t place within 10 minutes returns a 429 and is not charged. You also keep DeepInfra’s zero-retention policy, SOC 2 and ISO 27001, and one bill across every model you run. If none of that matters and your batches fit the off-peak window, DeepSeek’s API is the cheaper route for this job.
Sometimes the main advantage is not raw throughput. It is running the model in a controlled setup while keeping pricing easy to forecast. Here DeepInfra’s compliance posture and private deployment option count for more than a leaderboard position.
Assumptions: 25,000 requests per month; 8,000 input tokens and 1,500 output tokens per request.
| Volume | Model | Provider | Input tokens | Output tokens | Monthly cost |
|---|---|---|---|---|---|
| 25,000 requests | DeepSeek-V4-Pro-0813 | DeepInfra | 200M | 37.5M | $357.50 |
Cost breakdown
Why DeepInfra fits: internal copilots, secure workflow assistants and engineering automation need zero retention, SOC 2 and ISO 27001, which DeepInfra has. JSON mode and function calling carry over to production integrations, and a private deployment is available if you need dedicated capacity. If part of this traffic is latency-sensitive, Priority runs the same month at $536.25.
Same workload at $1.32 / $3.96: 200M × $1.32 + 37.5M × $3.96 = $264.00 + $148.50 = $412.50, or $55.00 more than DeepInfra.
| Scenario | Monthly requests | DeepInfra Standard | DeepInfra Flex | Comparison route | Primary cost driver |
|---|---|---|---|---|---|
| 1. RAG support bot | 1,000 | $42.40 | $33.92 | $44.88 (DeepSeek peak) | Cached input |
| 2. Code review assistant | 10,000 | $208.00 | $166.40 | $237.60 ($1.32 / $3.96) | Input and output volume |
| 3. Agent workflow | 50,000 | $420.00 | $336.00 | $475.20 (DeepSeek peak) | Cache at scale, output |
| 4a. Batch document extraction | 2,000 | $286.00 | $228.80 | $151.80 (DeepSeek off-peak) | Input volume |
| 4b. Batch generation | 20,000 | $390.00 | $312.00 | $277.20 (DeepSeek off-peak) | Output volume |
| 5. Private enterprise tools | 25,000 | $357.50 | $286.00 | $412.50 ($1.32 / $3.96) | Output volume, compliance |
Picking a provider for DeepSeek V4 Pro 0813 comes down to matching its pricing to how your workload behaves. The model is the same wherever you run it. What differs is how you pay for its output, its cache reads and the hours you run it.
Three criteria matter most. First, output price: 0813 is a verbose reasoning model, and DeepInfra’s $2.60 per 1M output tokens is the lowest among the providers Artificial Analysis measures. Second, cache rate: if your app is mostly repeated context with short answers, providers charging $0.022–$0.044 for cache reads will undercut DeepInfra’s $0.10, so run the numbers for your traffic. Third, timing: anything that can wait should go to DeepInfra Flex ($1.04 / $2.08), or into DeepSeek’s off-peak window if the schedule and its 500-request concurrency limit suit you.
DeepInfra also covers what matters past the prototype: SOC 2 and ISO 27001, zero retention, private deployments, Priority capacity and a 0.0% measured error rate. If V4 Pro is more model than a task needs, DeepSeek V4.1 Flash 1017 scores higher on Artificial Analysis at a fraction of the price.
Start with DeepInfra and run your real prompt mix: the DeepSeek-V4-Pro-0813 model page has a demo, and the API reference shows every parameter. For speed and latency by provider, see the DeepSeek V4 Pro API benchmarks; for a ranked list, see the best DeepSeek V4 API providers.
DeepSeek-V4-Pro-0813 costs $1.30 per 1M input tokens, $2.60 per 1M output tokens and $0.10 per 1M cached input tokens on DeepInfra’s Standard tier. Flex costs $1.04 / $2.08 / $0.08 and Priority costs $1.95 / $3.90 / $0.15. Pricing as of 2026-11-16.
It is the GA release of DeepSeek V4 Pro, published by DeepSeek on August 13, 2026. It keeps the preview’s architecture and 1M context, adds a three-level reasoning_effort setting (low, high, max) and a built-in speculative decoding module, and posts large vendor-reported gains on agentic and coding benchmarks. On DeepInfra its model ID is deepseek-ai/DeepSeek-V4-Pro-0813.
It depends on the time of day. At peak (01:00–04:00 and 06:00–10:00 UTC on weekdays), DeepSeek charges $1.32 input and $3.96 output, so DeepInfra is cheaper on both. Off-peak, DeepSeek charges $0.66 and $1.98, below DeepInfra Standard and Flex. DeepSeek’s cache reads ($0.044 peak, $0.022 off-peak) are cheaper than DeepInfra’s at any hour.
It depends on which provider OpenRouter routes your request to. OpenRouter lists 26 endpoints for the 0813 model, including DeepInfra’s own Standard, Flex and Priority endpoints at the same prices. A few routes have lower output prices, mostly at DeepSeek’s off-peak rate. Most charge more for output than DeepInfra.
Yes. DeepInfra bills cached input at $0.10 per 1M tokens, 92% off its standard input rate. Several other providers charge less for cache reads, from $0.022 to $0.044 per 1M.
The context window is 1,048,576 tokens (1M). On DeepInfra, a single response can run to 384K tokens; if you don’t set max_tokens, the default is 65,536.
Yes. DeepSeek releases V4 Pro under the MIT license, with commercial use allowed. The 0813 weights are on Hugging Face.
No. DeepInfra applies a zero-retention policy: request data is not stored after the response is returned.
Kimi K2.6 is Now Available on DeepInfra<p>Kimi K2.6 can coordinate up to 300 sub-agents executing 4,000 steps in a single autonomous run — Moonshot AI’s answer to the gap between what frontier models can do in a chat window and what production agentic systems actually need. Built for long-horizon coding, deep research, and complex orchestration, the model is open source under […]</p>
NVIDIA Nemotron API Pricing Guide 2026<p>While everyone knows Llama 3 and Qwen, a quieter revolution has been happening in NVIDIA’s labs. They have been taking standard Llama models and “supercharging” them using advanced alignment techniques and pruning methods. The result is Nemotron—a family of models that frequently tops the “Helpfulness” leaderboards (like Arena Hard), often beating GPT-4o while being significantly […]</p>
Accelerating Reasoning Workflows with Nemotron 3 Nano on DeepInfraDeepInfra is an official launch partner for NVIDIA Nemotron 3 Nano, the newest open reasoning model in the Nemotron family. Our goal is to give developers, researchers, and teams the fastest and simplest path to using Nemotron 3 Nano from day one.© 2026 DeepInfra. All rights reserved.