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

Kimi K3.1 Pro Pricing: API Costs, Providers & Flex (2026)

Published on 2026.11.17 by DeepInfra
Kimi K3.1 Pro Pricing: API Costs, Providers & Flex (2026)

Kimi K3.1 Pro Executive Summary

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 ForProvider RecommendationWhy
Lowest price with a 0% error rateDeepInfra 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 backfillsDeepInfra 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 promptsDeepInfra StandardCached input bills at 10% of the input rate ($0.19), and agent traffic is mostly cached prefix.
First-party access and HighspeedMoonshot (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 priceDigitalOcean or Baseten200.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 hostsOpenRouterRoutes 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.

Understanding Tokens and How You’re Charged

You pay for what you send, what the model writes, and, at a 90% discount, what you send again.

Token typeWhat it isWhy 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 inputPrompt 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.
OutputGenerated tokens, including reasoning$9.50 per 1M, 5× the input rate. Reasoning tokens bill here too.
Max outputThe cap on one responseUp 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 windowPrompt plus output, per request1,048,576 tokens. Long-context RAG fits without aggressive chunking, which is a capability, not a budget.

What this means in practice:

  • Output is where the money goes. At 5× the input rate, and with a model Artificial Analysis rates “somewhat verbose”, output usually decides the bill even when it’s a small share of tokens.
  • Reasoning effort is a cost dial. DeepInfra accepts 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.
  • Cache hit rate matters as much as the cache price. On Artificial Analysis’s agentic Index workload, DeepInfra’s endpoint hit the cache 92.6% of the time, against 98–100% on several other endpoints. Even with lower token prices, that made DeepInfra’s cost per Index task $4.39, more than several $2.00 / $10.00 endpoints. Keep the stable parts of your prompt at the front and set prompt_cache_key so repeated prefixes stay cached.
  • Images bill as input. Kimi K3.1 Pro accepts images, which are tokenized and charged at the input rate.

Provider Token Cost Tradeoffs

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 / routeInputOutputCachedAdvantageDisadvantageBest fit
DeepInfra Standard (promo)$1.90$9.50$0.19Lowest price among Artificial Analysis endpoints with a 0% error rate; zero data retention; JSON, structured output and tool callingPromotional rate (list $2.00 / $10.00); lower measured cache hit rate on Artificial Analysis’s agent workloadProduction apps, agents, RAG
DeepInfra Flex$1.52$7.60$0.15220% below Standard; a request Flex can’t place is rejected and not chargedWaits up to 10 minutes for capacity, then returns HTTP 429Batch jobs, evals, backfills
DeepInfra Priority$2.85$14.25$0.285Priority capacity when demand peaks1.5× Standard, above Moonshot’s list priceLatency-sensitive paths where queueing costs more than tokens
PrimaLabs$1.80$9.00$0.18Lowest price Artificial Analysis measured15.4% error rate on Artificial Analysis; OpenRouter lists its endpoint at $2.70 / $13.50Price-only workloads that can absorb failed requests
Moonshot (Kimi API)$2.00$10.00$0.20First-party; Highspeed variant at $4.00 / $20.0031.0 t/s and an 8.0% error rate on Artificial AnalysisTeams already on Moonshot’s platform
DigitalOcean, Baseten$2.00$10.00$0.20Fastest standard-price endpoints: 200.8 and 183.0 t/sList price on every tokenInteractive 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.60Up to 258.5 t/s2–3× the standard priceLatency at any cost
OpenRouterVaries by providerVariesVariesOne key, failover; some hosts Artificial Analysis doesn’t benchmark list lower pricesThe routed provider sets price, speed and cache behaviorMulti-provider fallback
Self-hostingGPU costGPU costn/aFull control over a 2.8T-parameter modelA multi-GPU cluster and an inference team; MaaS operators above $20M revenue need a separate agreement with MoonshotVery large, steady volume

Source: Artificial Analysis providers page, OpenRouter and the DeepInfra model page, accessed 2026-11-17.

Takeaways by workload:

  • Output-heavy work: DeepInfra’s $9.50 output rate is the lowest of the zero-error endpoints Artificial Analysis measures. Every 100M output tokens costs $50 less than at list.
  • Batch and async work: Flex at $7.60 output is 24% below list and needs one request field.
  • Agent loops: the $0.19 cache rate helps only if requests actually hit the cache. Structure prompts for it, then check your cached-token share in usage before you trust a forecast.
  • Off-benchmark routes: OpenRouter lists a few hosts that Artificial Analysis doesn’t benchmark at lower token prices. That’s why every price claim in this guide is scoped to the endpoints Artificial Analysis measures.

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.

DeepInfra: The Lowest-Cost Zero-Error Route for Kimi K3.1 Pro

Model / listingBest use caseContextInput (per 1M)Output (per 1M)
Kimi K3.1 Pro, StandardAgents, coding, long-context RAG, document and image understanding1,048,576$1.90 ($0.19 cached)$9.50
Kimi K3.1 Pro, FlexBatch jobs, evals, backfills1,048,576$1.52 ($0.152 cached)$7.60
Kimi K3.1 Pro, PriorityLatency-sensitive production paths1,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)
copy

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.

Real-World Cost Scenarios for Developers

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.

Scenario 1: Repo-scale coding agent for a 25-person team

VolumeModelProviderInput tokensOutput tokensMonthly cost
25 developers, daily agent sessionsKimi K3.1 ProDeepInfra Standard3,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.

Scenario 2: Long-context RAG over a document library

VolumeModelProviderInput tokensOutput tokensMonthly cost
100,000 queriesKimi K3.1 ProDeepInfra Standard6,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.

Scenario 3: Nightly agent evals and backfills on Flex

VolumeModelProviderInput tokensOutput tokensMonthly cost
Nightly eval sweeps and data backfillsKimi K3.1 ProDeepInfra Flex2,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.

Scenario 4: JSON and tool-calling backend

VolumeModelProviderInput tokensOutput tokensMonthly cost
500,000 requestsKimi K3.1 Pro (reasoning_effort low)DeepInfra Standard1,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.

Scenario 5: Production agent platform with a Priority slice

VolumeModelProviderInput tokensOutput tokensMonthly cost
80% of trafficKimi K3.1 ProDeepInfra Standard6,400M (5,600M cached, 800M uncached)240M$4,864.00
20% of traffic (interactive)Kimi K3.1 ProDeepInfra Priority1,600M (1,400M cached, 200M uncached)60M$1,824.00
Total8,000M300M$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.

What these scenarios say about DeepInfra

  • The rate gap is small per token and steady in total. At 5% below list on every token type, DeepInfra saves $87 to $190 a month on the Standard scenarios here.
  • Flex is the larger saving. Moving schedulable work to Flex cut Scenario 3 by $402.80 against Standard, 24% below list.
  • Cache discipline beats provider choice. Scenario 1’s drop from a 90% to an 80% cache hit rate costs $513 a month, nearly six times what the rate gap saves.
  • Reasoning settings beat both. In Scenario 4, 1,000 extra reasoning tokens per request would cost more than the whole bill.
  • A 0% error rate is the condition on every “lowest price” claim. The one cheaper endpoint Artificial Analysis measures failed 15.4% of requests.

Conclusion

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.

Related articles
Model Deprecation: Build LLM Apps That LastModel 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. [&hellip;]</p>
DeepInfra Raises $107M Series B to Scale Inference InfrastructureDeepInfra 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 2026NVIDIA Nemotron API Pricing Guide 2026<p>While everyone knows Llama 3 and Qwen, a quieter revolution has been happening in NVIDIA&#8217;s labs. They have been taking standard Llama models and &#8220;supercharging&#8221; them using advanced alignment techniques and pruning methods. The result is Nemotron—a family of models that frequently tops the &#8220;Helpfulness&#8221; leaderboards (like Arena Hard), often beating GPT-4o while being significantly [&hellip;]</p>