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

Updated November 2026.
Kimi K3 matters because it pushes an unusual combination into the same decision: open weights, a 1 million token context window, and frontier-class benchmark numbers, but at pricing still high enough to force real provider shopping. Released by Moonshot AI on July 16, 2026, it is a 2.8 trillion parameter Mixture-of-Experts model with 104 billion active parameters, native multimodal input, text output, and a 1,048,576-token context window. DeepInfra’s model page adds the implementation detail: 896 experts with 16 selected per token, Kimi Delta Attention, Attention Residuals, MoonViT-V2 for vision, and quantization-aware training using MXFP4 weights and MXFP8 activations. If you’re evaluating long-context reasoning or agentic coding workloads in production, this isn’t a model you price once and forget.
What makes Kimi K3 stand out is not just scale. Artificial Analysis has since deprecated Kimi K3 in favor of Kimi K3.1 Pro and no longer shows a current Intelligence Index score for it. DeepInfra’s benchmark table backs that up, with strong results across reasoning, coding, and agentic tasks, including 93.5 on GPQA Diamond, 88.3 on Terminal-Bench 2.1, and 95.0 F1 on DeepSearchQA. The catch is cost and runtime behavior: pricing starts at $3.00 per 1M input tokens and $15.00 per 1M output tokens at Kimi’s first-party rate, and, as measured by Artificial Analysis in July 2026 before it deprecated K3, the model was both slower and more verbose in evaluation output than its peers.
For developers and ML platform teams, that combination makes Kimi K3 a serious but selective choice, one that competes with systems benchmarked alongside Claude Fable 5, GPT-5.6 Sol, Claude Opus 4.8, GPT-5.5, and GLM-5.2, while remaining available as open weights through multiple API providers. The practical question isn’t whether Kimi K3 is capable, but whether your workload benefits enough from its long context, multimodal reasoning, and strong agentic and coding profile to justify its token pricing, latency profile, and provider-level tradeoffs. If you want to see how it stacks up against other leading open-weight options in the same tier, Kimi K3 vs DeepSeek V4 Pro vs GLM-5.2 breaks down the tradeoffs in detail.
Kimi K3 is priced in a wide band across providers. DeepInfra lists $2.85 / $14.25 per 1M tokens with $0.285 cached input (pricing as of 2026-11-17). Most providers Artificial Analysis lists charge Moonshot’s $3.00 / $15.00, and OpenRouter routes to 16 providers with listed output prices from $9.50 to $22.50 per 1M tokens. It is best suited for teams that actually need 1M-token context, multimodal reasoning, or strong coding and agentic benchmarks against model sets that include Claude Fable 5, GPT-5.6 Sol, Claude Opus 4.8, GPT-5.5, and GLM-5.2, not for budget-first inference where cheaper open-weight options are likely easier to justify.
| Best For | Provider | Why |
|---|---|---|
| RAG, document-heavy, or high-throughput use cases | DeepInfra | Combines the full 1,048,576-token context window with cached input pricing at $0.285 per 1M tokens, plus JSON output, function calling, multimodal input, and public or private endpoints. |
| Production multimodal and agentic workloads | DeepInfra | Exposes Kimi K3 with platform features that matter in production, JSON mode, function calling, multimodal input, and private deployment support, with the lowest output and cached-input price among the providers Artificial Analysis lists. |
| Shopping routes for the lowest listed price | OpenRouter | Routes to 16 providers with listed output prices from $9.50 to $22.50 per 1M tokens; the route you get decides the bill and the maximum output length. |
| Easiest onboarding / fastest time-to-first-call | OpenRouter | OpenAI-compatible API, so most SDKs work by swapping the base URL and model slug rather than rewriting the integration. |
| Proprietary or managed model access | Kimi first-party API | Artificial Analysis reports its TTFT and output-speed measurements specifically from Kimi’s own API, making it the clearest reference point for direct managed access. |
| Resilience across hosting providers | OpenRouter | Routes across multiple providers, offers Balanced, Nitro, and Exacto modes, and automatically retries on the next-best provider when one returns an error. |
If you’re choosing today, compare Kimi K3.1 Pro: $1.90 / $9.50 / $0.19 on DeepInfra, or $1.52 / $7.60 on Flex. Scenario 1 below would cost $380.00 on K3.1 Pro instead of $570.00. See the Kimi K3.1 Pro pricing guide.
Tokens are the billing unit for Kimi K3. A token is not the same thing as a word: in practice, tokens are chunks of text, parts of words, whole words, punctuation, numbers, code symbols, JSON structure, and sometimes whitespace patterns. Long prompts, large code files, tool call payloads, OCR text from images, and verbose model answers all turn into tokens.
With Kimi K3, token math matters more than usual because the model invites exactly the kinds of workloads that get expensive fast: long-context prompts, repository-scale coding, multimodal inputs, and reasoning-heavy outputs.
| Token Type | What It Is | Why It Matters |
|---|---|---|
| Input tokens | Everything you send to the model in the request: system prompt, user prompt, chat history, tool schemas, retrieved context, code, documents, and structured payloads. | This is your baseline cost on every call. With Kimi K3’s 1M-token context window, it is very easy to send far more context than you actually need. |
| Output tokens | Everything the model generates back: answers, reasoning-style responses, code, JSON, tool arguments, and long explanations. | Output is the expensive side with Kimi K3. Output pricing runs about 5x input pricing across providers, so verbose responses can wreck your budget faster than prompt size. |
| Cached input tokens | Input tokens the provider can reuse from prior requests instead of charging full input price again. | Cache pricing is where repeated long prompts become survivable. If you reuse large instructions, repos, or documents, cached rates can materially change total cost. |
| Context tokens | The combined tokens the model has to hold in working memory for the request, including current input and prior conversation state. | Context window size is not the same as cost, but larger context usually means larger bills. It fits does not mean it is cheap. |
Artificial Analysis described it as very verbose in evaluation output in July 2026, before it deprecated K3. That matters because output pricing is high: $14.25 per 1M output tokens on DeepInfra and $15.00 at most providers Artificial Analysis lists. If your app allows open-ended reasoning dumps, chain-of-thought style sprawl, or giant JSON blobs, output cost will usually dominate.
The headline prices are close. The real differences come from cache handling, routing behavior, and how much integration work you want to own.
| Provider | Input Price | Output Price | Cached Input Price | Token-Cost Notes |
|---|---|---|---|---|
| OpenRouter | Varies by route | $9.50–$22.50 / 1M | Varies by route | Routes to 16 providers. A few list lower output prices than DeepInfra and others charge far more, so the route you get decides the bill and the maximum output length. |
| DeepInfra | $2.85 / 1M | $14.25 / 1M | $0.285 / 1M | Best documented token economics for repeated large prompts. Cached input is 10x cheaper than standard input, output and cached-input prices are the lowest among the providers Artificial Analysis lists, and prompt cache retention (5-minute or 1-hour writes) is available. |
| Kimi first-party API | $3.00 / 1M | $15.00 / 1M | $0.30 / 1M | Moonshot’s list price and the cleanest reference implementation. Artificial Analysis’s model-level speed figures come from this endpoint. |
| Other providers Artificial Analysis lists | $3.00 / 1M (Makora $1.00) | $15.00 / 1M | $0.30 / 1M (Makora $0.50) | Baseten, Nebius, Databricks, Modal, Parasail, Amazon Bedrock and DigitalOcean match Moonshot’s list price, and Artificial Analysis measures their speed. Makora lists the lowest input price but a higher cached rate. |
This is a 1M-context model. Teams evaluating it often send large static context: repo maps, long instructions, policy packs, reference docs, or multimodal assets. Without cache discounts, those workloads get expensive quickly. With cache discounts, repeated sessions become much easier to justify. On DeepInfra you can also set prompt cache retention: cache writes bill at $3.5625 per 1M tokens for 5-minute retention or $5.70 for 1 hour, and reuse within the window bills at the $0.285 cached rate.
One mildly painful truth about Kimi K3 pricing: the spread between providers is not huge on paper, but the spread in real cost can become huge once output verbosity and cache hit rates enter the picture. If the model tends to answer long, shaving a few cents off input matters less than controlling output tokens and getting cache reuse right.
If you want a sense of how these same provider dynamics played out with the previous generation of the model family, the analysis of the best API for Kimi K2.5 walks through the same tradeoffs across speed, price, and reliability that matter here.
If you want to run Kimi K3 seriously, DeepInfra is the kind of provider that makes sense for power users. DeepInfra owns its GPU infrastructure, which helps keep both performance and cost under control at production load. That is why it tends to appeal to developers, high-volume API users, and cost-conscious teams that care about unit economics. For Kimi K3 specifically, it pairs that infrastructure story with production-ready features instead of just cheap access.
| Model | Best Use Case | Context Window | Input ($/1M) | Output ($/1M) |
|---|---|---|---|---|
| Kimi K3 | Long-horizon coding, agentic workflows, multimodal reasoning | 1,048,576 tokens | $2.85 | $14.25 |
DeepInfra lists Kimi K3 at $2.85 per 1M input tokens and $14.25 per 1M output tokens. That is 5% below Moonshot’s $3.00 / $15.00 and the lowest output and cached-input price among the providers Artificial Analysis lists (pricing as of 2026-11-17; there is no promotion, Flex or Priority tier on Kimi K3). Output can run to the full 1,048,576-token context (65,536 by default if max_tokens is unset), and reasoning_effort accepts none through max, with none turning thinking off. You also get a documented $0.285 per 1M cached input rate, which is where repeated long-context workloads get much easier to justify. If your app reuses large prompts, repos, or document context, that cache discount can matter more than tiny differences in base token price.
For teams planning high-volume or prompt-reuse-heavy workloads, DeepInfra is a strong place to start if you want Kimi K3 with fewer compromises on both platform capability and cost control. You can also explore the full DeepInfra model catalog if you are evaluating Kimi K3 alongside other coding and reasoning models.
Below are practical developer scenarios where DeepInfra is an especially strong fit for Kimi K3, not just because of base pricing, but because its combination of 1,048,576-token context, $0.285 per 1M cached input, JSON output, function calling, multimodal input, and public or private endpoints lines up well with the kinds of workloads Kimi K3 is actually good at.
A developer tools team is building a coding agent that keeps a large repo map, architecture notes, and tool schemas in prompt context across many turns. This is exactly the kind of workload where DeepInfra’s cached-input pricing matters, because the expensive part is often re-sending the same large prompt structure over and over.
| Input Tokens | Output Tokens | Provider | Monthly Cost |
|---|---|---|---|
| 500M cached input + 50M fresh input | 20M | DeepInfra | $570.00 |
Cost breakdown: 500M cached input × $0.285/1M = $142.50; 50M fresh input × $2.85/1M = $142.50; 20M output × $14.25/1M = $285.00. The same token profile on Kimi’s first-party API ($0.30 cached / $3.00 input / $15.00 output) would cost $600.00, so DeepInfra is $30.00 less per month.
A platform team is using Kimi K3 for internal support and ops workflows where each request may include large retrieved context from product docs, incident notes, deployment runbooks, and compliance material. The workload is not just big, it is repetitive, with the same core instruction stack and overlapping document sets showing up constantly.
| Input Tokens | Output Tokens | Provider | Monthly Cost |
|---|---|---|---|
| 800M cached input + 120M fresh input | 30M | DeepInfra | $997.50 |
Cost breakdown: 800M cached input × $0.285/1M = $228.00; 120M fresh input × $2.85/1M = $342.00; 30M output × $14.25/1M = $427.50. The same workload on Kimi’s first-party API would cost $1,050.00, so DeepInfra is $52.50 less per month.
A developer platform team wants one model that can reason across text plus images: UI screenshots, architecture diagrams, error screenshots, and attached documentation. Kimi K3’s native multimodal design is a better match here than forcing separate OCR and reasoning steps, and DeepInfra exposes that with production-friendly API features.
| Input Tokens | Output Tokens | Provider | Monthly Cost |
|---|---|---|---|
| 150M | 25M | DeepInfra | $783.75 |
Cost breakdown: 150M input × $2.85/1M = $427.50; 25M output × $14.25/1M = $356.25. The same workload on Kimi’s first-party API would cost $825.00, so DeepInfra is $41.25 less per month.
A product engineering team is deploying an agent that plans tasks, calls tools, inspects outputs, and returns typed results to the application. This is where DeepInfra’s feature set matters as much as token price: function calling for actions, JSON output for reliable downstream parsing, and cached input for repeated session scaffolding.
| Input Tokens | Output Tokens | Provider | Monthly Cost |
|---|---|---|---|
| 300M cached input + 100M fresh input | 40M | DeepInfra | $940.50 |
Cost breakdown: 300M cached input × $0.285/1M = $85.50; 100M fresh input × $2.85/1M = $285.00; 40M output × $14.25/1M = $570.00. The same workload on Kimi’s first-party API would cost $990.00, so DeepInfra is $49.50 less per month.
A team evaluating prompts, retrieval policies, and agent behavior runs large batches of test cases every month. This is a classic workload that looks cheap in staging and expensive in aggregate. DeepInfra is attractive here because its base pricing is below Moonshot’s list price and it gives a clear cache story for repeated harness prompts.
| Input Tokens | Output Tokens | Provider | Monthly Cost |
|---|---|---|---|
| 1B cached input + 250M fresh input | 60M | DeepInfra | $1,852.50 |
Cost breakdown: 1B cached input × $0.285/1M = $285.00; 250M fresh input × $2.85/1M = $712.50; 60M output × $14.25/1M = $855.00. The same workload on Kimi’s first-party API would cost $1,950.00, so DeepInfra is $97.50 less per month.
The pattern across these scenarios is pretty consistent: if you are using Kimi K3 in the ways that justify using Kimi K3 at all, large persistent context, repeated prompts, multimodal inputs, coding agents, and structured tool workflows, DeepInfra tends to look better than a simple sticker-price comparison suggests. Its base pricing is 5% below Moonshot’s list, and its documented cached-input discount and production-oriented API features make it especially compelling for developers building real systems instead of one-off demos.
Choosing a provider for Kimi K3 is not a one-time decision you make by comparing sticker prices. The model’s 1M-token context window, verbose reasoning output, and strong fit for agentic and coding workloads mean that caching behavior, feature support, and output cost control matter as much as the base per-token rate. Get those wrong and a small price difference on paper becomes a large one in production.
The criteria worth prioritizing are straightforward: how your workload handles prompt reuse, how much control you have over output length, and whether your integration needs function calling, JSON output, or multimodal support from day one. If most of your calls are short-lived and non-repetitive, shop OpenRouter’s routes, whose listed output prices run from $9.50 to $22.50. If you are building anything that sends large persistent context, repo maps, document stacks, long agent scaffolding, DeepInfra’s documented cached-input rate at $0.285 per 1M tokens is the number that actually changes your monthly bill. You can see how that plays out across model tiers and comparable alternatives in Kimi K3 vs Claude Opus 4.8 vs GPT-5.6 Sol, which puts the cost gap in concrete terms.
For a deeper look at the model itself, architecture, benchmark context, and how it stacks up across the provider landscape, DeepInfra’s Kimi K3 model analysis is a solid reference before you commit to a production integration. When you are ready to make your first call, the Kimi K3 API reference on DeepInfra has everything you need to get started quickly with an OpenAI-compatible endpoint, full multimodal support, and pricing that holds up at scale.
Best API Providers for GLM-5.1 in 2026<p>Updated November 2026. GLM-5.1 has been retired on DeepInfra. Its successor, GLM-5.3, is available now; see the best GLM-5.3 API providers for current options. The comparison below is kept for reference. GLM-5.1 is available across a growing number of API providers, and the choice between them materially affects cost, latency, and what features you can […]</p>
Best SaaS Tools and API Providers for GLM-5.2<p>Updated November 2026. GLM-5.2 represents a significant leap forward in open-weight models, particularly for complex reasoning, long-context processing, and agentic coding tasks. Deploying a model of this scale — especially with its massive 1-million token context window and Mixture-of-Experts (MoE) architecture — presents real infrastructure challenges. Managing memory bandwidth, optimizing time to first token (TTFT), […]</p>
Design Your Next Website With AI: A Prompting Guide for Ming-ImageLearn how to prompt Ming-Image, an open-weight model tuned for UI design, to turn a one-line brief into a real website mockup.© 2026 DeepInfra. All rights reserved.