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

Pricing as of 2026-11-17. DeepInfra’s Standard rate is promotional (5% off a $2.00 / $10.00 list price, no published end date). Budget against list if you’re planning past this quarter.
| Best For | Provider Recommendation | Why |
|---|---|---|
| Lowest price with a 0% error rate | DeepInfra Standard | $1.90 input / $9.50 output / $0.19 cached per 1M tokens: the lowest price among the endpoints Artificial Analysis measured with a 0% error rate. One endpoint is cheaper (PrimaLabs, $1.80 / $9.00), with a 15.4% error rate. |
| Batch jobs, evals and backfills | DeepInfra Flex | $1.52 / $7.60 / $0.152, 20% below Standard, for requests that can wait up to 10 minutes for capacity. |
| Agents and RAG with large repeated prompts | DeepInfra Standard | Cached input bills at 10% of the input rate ($0.19), and agent traffic is mostly cached prefix. |
| First-party access and Highspeed | Moonshot (Kimi API) | $2.00 / $10.00 / $0.20 at list, plus a Highspeed variant at $4.00 / $20.00 that only Moonshot serves. |
| Fastest responses at list price | DigitalOcean or Baseten | 200.8 and 183.0 output tokens per second, about 25 seconds to the first answer token, at $2.00 / $10.00. |
| One API across many hosts | OpenRouter | Routes Kimi K3.1 Pro across more than 15 providers at each provider’s own price, with failover. |
Verdict: for most production traffic, DeepInfra Standard is the lowest-cost endpoint that didn’t fail requests in Artificial Analysis’s tests, and Flex takes another 20% off anything that can wait. Pay list price elsewhere only when response speed is the product.
Kimi K3.1 Pro is Moonshot AI’s open-weight flagship, released on October 23, 2026 and on DeepInfra since November 2026. It is a Mixture-of-Experts model with 2.8T total and 104B active parameters, a 1,048,576-token context window, and text and image input. Moonshot post-trained it from Kimi K3 with much more compute and swapped K3’s full-attention layers for sparse attention to make long context cheaper to run. The weights ship under the Kimi K3.1-Pro License, an MIT-style license with two extra conditions for very large commercial operators (details below).
On Artificial Analysis, Kimi K3.1 Pro scores 46 on Intelligence Index v5.0.1, first of 29 open-weight models of its size (class median: 23). It is also a long-thinking model: it wrote 113M output tokens to run the index, against a 104M class median. That’s the pricing story in one line. The rate card is high for an open model, output is the expensive side of it, and this model writes a lot. The useful question is not whether it’s cheap, but which endpoint and which token mix keep your bill reasonable.
You pay for what you send, what the model writes, and, at a 90% discount, what you send again.
| Token type | What it is | Why it matters for Kimi K3.1 Pro |
|---|---|---|
| Input (uncached) | New prompt tokens: user text, retrieved documents, tool results, images | $1.90 per 1M on DeepInfra. A full 1M-token prompt costs about $1.99 uncached. |
| Cached input | Prompt prefix the provider has seen recently: system prompt, tool schemas, conversation history | $0.19 per 1M, 10% of the input rate. Agent loops resend history every turn, so this line carries most of the volume. |
| Output | Generated tokens, including reasoning | $9.50 per 1M, 5× the input rate. Reasoning tokens bill here too. |
| Max output | The cap on one response | Up to 943,718 tokens on DeepInfra. If you don’t set max_tokens, the default is 65,536, about $0.62 of output at most. |
| Context window | Prompt plus output, per request | 1,048,576 tokens. Long-context RAG fits without aggressive chunking, which is a capability, not a budget. |
What this means in practice:
reasoning_effort from none (thinking off) to max. Moonshot’s benchmark numbers use max. For extraction, classification and routing, a lower setting saves output tokens the task doesn’t need.prompt_cache_key so repeated prefixes stay cached.Artificial Analysis benchmarks Kimi K3.1 Pro on 16 endpoints from 14 providers. Most standard endpoints charge Moonshot’s list price, $2.00 / $10.00 / $0.20. DeepInfra is $0.10 below that on input and $0.50 below on output. Prices are per 1M tokens.
| Provider / route | Input | Output | Cached | Advantage | Disadvantage | Best fit |
|---|---|---|---|---|---|---|
| DeepInfra Standard (promo) | $1.90 | $9.50 | $0.19 | Lowest price among Artificial Analysis endpoints with a 0% error rate; zero data retention; JSON, structured output and tool calling | Promotional rate (list $2.00 / $10.00); lower measured cache hit rate on Artificial Analysis’s agent workload | Production apps, agents, RAG |
| DeepInfra Flex | $1.52 | $7.60 | $0.152 | 20% below Standard; a request Flex can’t place is rejected and not charged | Waits up to 10 minutes for capacity, then returns HTTP 429 | Batch jobs, evals, backfills |
| DeepInfra Priority | $2.85 | $14.25 | $0.285 | Priority capacity when demand peaks | 1.5× Standard, above Moonshot’s list price | Latency-sensitive paths where queueing costs more than tokens |
| PrimaLabs | $1.80 | $9.00 | $0.18 | Lowest price Artificial Analysis measured | 15.4% error rate on Artificial Analysis; OpenRouter lists its endpoint at $2.70 / $13.50 | Price-only workloads that can absorb failed requests |
| Moonshot (Kimi API) | $2.00 | $10.00 | $0.20 | First-party; Highspeed variant at $4.00 / $20.00 | 31.0 t/s and an 8.0% error rate on Artificial Analysis | Teams already on Moonshot’s platform |
| DigitalOcean, Baseten | $2.00 | $10.00 | $0.20 | Fastest standard-price endpoints: 200.8 and 183.0 t/s | List price on every token | Interactive products where speed is the requirement |
| Fast tiers (Amazon Bedrock High Speed, LithosAI ULTRA, Inco FAST) | $4.00–$6.00 | $20.00–$30.00 | $0.20–$0.60 | Up to 258.5 t/s | 2–3× the standard price | Latency at any cost |
| OpenRouter | Varies by provider | Varies | Varies | One key, failover; some hosts Artificial Analysis doesn’t benchmark list lower prices | The routed provider sets price, speed and cache behavior | Multi-provider fallback |
| Self-hosting | GPU cost | GPU cost | n/a | Full control over a 2.8T-parameter model | A multi-GPU cluster and an inference team; MaaS operators above $20M revenue need a separate agreement with Moonshot | Very large, steady volume |
Source: Artificial Analysis providers page, OpenRouter and the DeepInfra model page, accessed 2026-11-17.
Takeaways by workload:
Cost trap to avoid: a broken cache. In Scenario 1 below, a cache hit rate of 80% instead of 90% raises the monthly bill from $1,653.00 to $2,166.00, with no change in traffic. Timestamps or request IDs at the top of a system prompt, or reshuffled tool definitions, are the usual culprits.
On speed: DeepInfra’s endpoint measured 46.9 tokens per second and 109.82 seconds to the first answer token at max reasoning. If response speed is your product, test DigitalOcean or Baseten at list price; for batch, agents and cost-sensitive work, the per-token gap compounds.
| Model / listing | Best use case | Context | Input (per 1M) | Output (per 1M) |
|---|---|---|---|---|
| Kimi K3.1 Pro, Standard | Agents, coding, long-context RAG, document and image understanding | 1,048,576 | $1.90 ($0.19 cached) | $9.50 |
| Kimi K3.1 Pro, Flex | Batch jobs, evals, backfills | 1,048,576 | $1.52 ($0.152 cached) | $7.60 |
| Kimi K3.1 Pro, Priority | Latency-sensitive production paths | 1,048,576 | $2.85 ($0.285 cached) | $14.25 |
Kimi K3.1 Pro on DeepInfra runs behind an OpenAI-compatible endpoint (https://api.deepinfra.com/v1/openai/chat/completions, model ID moonshotai/Kimi-K3.1-Pro, Authorization: Bearer $DEEPINFRA_API_KEY). It supports JSON mode, structured output, tool calling, image input and reasoning control, with zero data retention and no minimums. DeepInfra owns its GPU infrastructure, and the same account can deploy the model on a private endpoint when shared capacity stops being enough. The /api page lists every parameter. This request uses Flex and a lower reasoning effort:
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="moonshotai/Kimi-K3.1-Pro",
messages=[{"role": "user", "content": "Extract the parties and dates from this contract as JSON: ..."}],
max_tokens=2048,
response_format={"type": "json_object"},
extra_body={
"service_tier": "flex",
"reasoning_effort": "low",
},
)
print(response.choices[0].message.content)
Why this matters: most endpoints charge Moonshot’s $2.00 / $10.00 list price for this model. DeepInfra’s promotional rate is 5% below that on every token type. Among the endpoints Artificial Analysis benchmarks, only one is cheaper, and it failed 15.4% of requests. For a reasoning model where a failed request can waste thousands of tokens of work, a 0.0% error rate is part of the price.
All five scenarios use DeepInfra’s promotional Standard rate ($1.90 / $9.50 / $0.19) unless they say otherwise. Each compares the same workload at Moonshot’s list price ($2.00 / $10.00 / $0.20), which is also what most endpoints on Artificial Analysis charge and what DeepInfra charges if the promo ends. Token volumes are monthly. “M” means million.
| Volume | Model | Provider | Input tokens | Output tokens | Monthly cost |
|---|---|---|---|---|---|
| 25 developers, daily agent sessions | Kimi K3.1 Pro | DeepInfra Standard | 3,000M (2,700M cached, 300M uncached) | 60M | $1,653.00 |
Coding agents resend the repo map, tool schemas and conversation history on every turn, so input dwarfs output and most of it should hit the cache. This assumes a 90% cache hit rate and output at 2% of input. Moonshot reports 51.7 on SWE Marathon and 65.7 on Terminal-Bench 4.0 for this model (vendor-reported), which is the kind of long-horizon coding this loop needs.
Why DeepInfra fits: the cached prefix bills at $0.19, and the uncached input and output are at the lowest zero-error rate Artificial Analysis measured.
Cost breakdown – Uncached input: 300M × $1.90/M = $570.00 – Cached input: 2,700M × $0.19/M = $513.00 – Output: 60M × $9.50/M = $570.00 – Total: $1,653.00/month
Same workload at list price ($2.00 / $10.00 / $0.20): $600.00 + $540.00 + $600.00 = $1,740.00, or $87.00 more. At an 80% cache hit rate, the DeepInfra bill rises to $2,166.00.
| Volume | Model | Provider | Input tokens | Output tokens | Monthly cost |
|---|---|---|---|---|---|
| 100,000 queries | Kimi K3.1 Pro | DeepInfra Standard | 6,000M (5,000M cached, 1,000M uncached) | 80M | $3,610.00 |
Each query sends a 60,000-token prompt: a 50,000-token cached prefix of instructions and core documents, plus 10,000 tokens of freshly retrieved passages. It returns an 800-token answer. The 1M-token window leaves room to grow the prefix before you need to chunk harder.
Why DeepInfra fits: the cached prefix is 83% of input but only $950 of the bill. The uncached retrieval tokens are where the 5% rate gap shows up.
Cost breakdown – Uncached input: 1,000M × $1.90/M = $1,900.00 – Cached input: 5,000M × $0.19/M = $950.00 – Output: 80M × $9.50/M = $760.00 – Total: $3,610.00/month (about $0.036 per query)
Same workload at list price: $2,000.00 + $1,000.00 + $800.00 = $3,800.00, or $190.00 more.
| Volume | Model | Provider | Input tokens | Output tokens | Monthly cost |
|---|---|---|---|---|---|
| Nightly eval sweeps and data backfills | Kimi K3.1 Pro | DeepInfra Flex | 2,000M (1,600M cached, 400M uncached) | 100M | $1,611.20 |
Regression suites for an agent product, synthetic-data generation and re-processing old tickets can all wait a few minutes for capacity. That’s exactly what Flex is for: the same model at 0.8× the price, in exchange for a queue of up to 10 minutes.
Why DeepInfra fits: Flex is one request field ("service_tier": "flex"), and a request it can’t place within 10 minutes returns a 429 without a charge.
Cost breakdown (Flex) – Uncached input: 400M × $1.52/M = $608.00 – Cached input: 1,600M × $0.152/M = $243.20 – Output: 100M × $7.60/M = $760.00 – Total: $1,611.20/month
On DeepInfra Standard, the same jobs cost $760.00 + $304.00 + $950.00 = $2,014.00, so Flex saves $402.80. At list price: $800.00 + $320.00 + $1,000.00 = $2,120.00, or $508.80 more than Flex.
| Volume | Model | Provider | Input tokens | Output tokens | Monthly cost |
|---|---|---|---|---|---|
| 500,000 requests | Kimi K3.1 Pro (reasoning_effort low) | DeepInfra Standard | 1,500M (1,000M cached, 500M uncached) | 200M | $3,040.00 |
A backend turns tickets, invoices and form submissions into validated JSON and tool calls. Each request carries a 2,000-token cached prefix (instructions and JSON schema) and 1,000 new tokens, and returns 400 tokens. Reasoning effort is set low because extraction gains little from long thinking.
Why DeepInfra fits: structured output and tool calling are supported, and output, two-thirds of this bill, is at the lowest zero-error rate measured.
Cost breakdown – Uncached input: 500M × $1.90/M = $950.00 – Cached input: 1,000M × $0.19/M = $190.00 – Output: 200M × $9.50/M = $1,900.00 – Total: $3,040.00/month
Same workload at list price: $1,000.00 + $200.00 + $2,000.00 = $3,200.00, or $160.00 more. The bigger lever is the reasoning setting: every extra 1,000 reasoning tokens per request adds 500M output tokens, or $4,750.00 a month.
| Volume | Model | Provider | Input tokens | Output tokens | Monthly cost |
|---|---|---|---|---|---|
| 80% of traffic | Kimi K3.1 Pro | DeepInfra Standard | 6,400M (5,600M cached, 800M uncached) | 240M | $4,864.00 |
| 20% of traffic (interactive) | Kimi K3.1 Pro | DeepInfra Priority | 1,600M (1,400M cached, 200M uncached) | 60M | $1,824.00 |
| Total | 8,000M | 300M | $6,688.00 |
A customer-facing agent platform runs most work on Standard and routes the interactive slice, where users are watching a spinner, to Priority.
Why DeepInfra fits: both tiers use the same model ID, endpoint and integration, so moving traffic between them is a request field, not a migration. A private endpoint is available on the same account if you later need dedicated capacity.
Cost breakdown – Standard: 800M × $1.90 + 5,600M × $0.19 + 240M × $9.50 = $1,520.00 + $1,064.00 + $2,280.00 = $4,864.00 – Priority: 200M × $2.85 + 1,400M × $0.285 + 60M × $14.25 = $570.00 + $399.00 + $855.00 = $1,824.00 – Total: $6,688.00/month
Everything on Standard would cost $1,900.00 + $1,330.00 + $2,850.00 = $6,080.00, so the Priority slice adds $608.00. At list price everywhere: $6,400.00. Priority sits above list, so use it where queueing costs you more than tokens do.
Kimi K3.1 Pro is the top-scoring open-weight model in its size class on Artificial Analysis, and one of the more expensive to run. Three decisions control the bill: where you run it, how much of each prompt hits the cache, and how much reasoning you let it do.
For where: DeepInfra’s $1.90 / $9.50 is the lowest price among the endpoints Artificial Analysis measured with a 0% error rate, and Flex ($1.52 / $7.60) is the cheapest way to run anything that can wait. Pay the $2.00 / $10.00 list price at a faster endpoint only when response speed is what you’re selling. For cache and reasoning: put stable content first, watch your cached-token share, and set reasoning_effort per task instead of leaving it at the maximum.
Moonshot’s license is MIT-style. Two conditions apply only to Model-as-a-Service operators with more than $20M in revenue and to products past 100M monthly users or $20M in monthly revenue, so read it before you build a hosted product on the weights.
If a step doesn’t need K3.1 Pro, a lighter model on the same API costs a fraction of the price. The best open-source models for coding roundup compares the options. For the previous generation’s numbers, see the Kimi K3 pricing guide, and for how Flex works, the Flex tier announcement. For speed and latency by provider, see the Kimi K3.1 Pro API benchmarks; for specs and parameters, the Kimi K3.1 Pro model overview.
Start with Kimi K3.1 Pro on DeepInfra, run your real prompt mix for a week, and read your cached-token share and output volume off the usage page before you commit to a forecast. Startups can apply for free credits through DeepStart.
Model Deprecation: Build LLM Apps That Last<p>Your model ID is the shortest-lived dependency in your stack and odds are it doesn’t have a maintenance schedule. On June 15, 2026, claude-sonnet-4-20250514 and claude-opus-4-20250514 stopped answering requests. Anthropic had posted the notice 62 days earlier. Teams with either string in a call site learned about it from an error rate, not an email. […]</p>
DeepInfra Raises $107M Series B to Scale Inference InfrastructureDeepInfra has raised $107 million in Series B funding to scale its inference cloud, expand global capacity, and support the next generation of open-source and agentic AI workloads.
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>
© 2026 DeepInfra. All rights reserved.