DeepSeek vs Kimi AI: Which AI Model Should You Use in 2026?

Reviewed July 28, 2026: This page has been rebuilt for Kimi K3 and DeepSeek V4. It uses current first-party documentation and a dated DeepSeek test. We did not have an authenticated Kimi API account, so no Kimi output, latency, or quality score is presented as independently tested.

Current DeepSeek documentation rechecked August 24, 2026. DeepSeek’s hosted catalog now contains three IDs: text-only deepseek-v4-flash and deepseek-v4-pro, plus experimental deepseek-v4-flash-vision-exp for text-and-image input with text output. The July 28 DeepSeek test and the no-Kimi-access boundary remain unchanged.

DeepSeek V4 and Kimi K3 are both large mixture-of-experts model families with million-token context, reasoning, tool use, and published weights for applicable releases, but their product tradeoffs are now sharply different. DeepSeek publishes much lower hosted API prices and offers two text routes—Flash and Pro—plus experimental Vision Exp for image understanding with text output. Kimi K3 combines a much larger active parameter count with native visual understanding, long-horizon agent behavior, and an API that is always in thinking mode.

For most text-only applications with a strict cost ceiling, DeepSeek is the more practical first benchmark. For image understanding, test DeepSeek Vision Exp and Kimi K3 on the same images; Kimi K3 remains on the shortlist when native video input, complex agent workflows, or K3-specific coding behavior could justify a higher token bill. Neither should be selected from model size or vendor benchmark charts alone: run the same tasks, tools, evidence, and scoring rules through both.

DeepSeek vs Kimi: the short answer

Requirement	Better starting point	Reason
Lowest published hosted API cost	DeepSeek V4	Flash and Vision Exp share the lower DeepSeek tier; Pro is the higher DeepSeek tier.
Native image understanding	Test both	K3 documents native visual input; DeepSeek Vision Exp now also accepts images and returns text.
Native video understanding	Kimi K3	K3 documents native video input; DeepSeek’s current API does not document native video input.
Choice among text and image routes	DeepSeek V4	Flash and Pro cover text workloads; experimental Vision Exp covers image understanding.
Always-on long-horizon reasoning	Kimi K3	K3 always thinks and provides low, high, and max reasoning-effort controls.
Permissive model license without K3-specific scale conditions	DeepSeek V4	Applicable DeepSeek V4 releases use MIT; this page makes no open-weight claim for Vision Exp. K3 uses a bespoke license with conditions for some large services.
Private long-context coding or agent workload	Test both	Specifications do not predict repository-level correctness, tool recovery, or cost per successful task.

What changed with Kimi K3

An older DeepSeek-versus-Kimi comparison centered on Kimi K2.x is no longer adequate. Kimi K3 is a new 2.8-trillion-parameter mixture-of-experts model with 104 billion active parameters, 1,048,576-token context, native multimodal input, and an agent-oriented API. Moonshot AI describes 93 layers, Kimi Delta Attention, Gated Multi-Head Latent Attention, attention residuals, and a routing design that activates 16 of 896 experts.

The commercial details changed as well. Moonshot’s July 25, 2026 price page lists $0.30 per million cached input tokens, $3.00 per million uncached input tokens, and $15.00 per million output tokens. K3’s weights are available, but the license is not simply “MIT” or “Apache.” Large-scale consumer services and model-as-a-service businesses need to examine K3’s attribution and commercial-use conditions.

That means a current comparison must replace K2-era model names, prices, context advantages, and license claims rather than appending a short update note. The sections below use K3-specific data throughout.

What we tested, and what remains untested

On July 28, 2026, we queried DeepSeek’s live models endpoint and ran a controlled constraint-reasoning task in DeepSeek Chat and through the API. The task tested source grounding, exact JSON structure, reasoning-token headroom, and finish-reason handling. The same evidence is useful here because it shows how DeepSeek behaved beyond its specification sheet.

We did not have access to a funded Kimi API account. Kimi’s quickstart states that API access requires a successful top-up of at least $1, and rate limits depend on the top-up tier. We did not bypass that requirement, use a third-party proxy, or present a model-card score as our own result. K3 capabilities in this article are clearly identified as officially documented until an authenticated test can be added.

The exact DeepSeek test prompt

Use only the source pack below. Return valid JSON with exactly three keys:
decision, risks, and next_step. The decision must be one sentence.
risks must be an array of exactly two strings. next_step must be one sentence.

SOURCE PACK:
- Project Falcon budget cap: $12,000.
- Vendor A costs $10,800 and can deliver May 18, 2026.
- Vendor B costs $11,500 and can deliver May 12, 2026.
- Launch deadline is May 15, 2026.
- Security review takes two business days after delivery.

Question: Which vendor, if any, can support the May 15 launch?

Vendor B is the correct decision. It costs less than the cap, arrives May 12, and leaves two business days for the security review before the May 15 launch. Vendor A arrives too late.

DeepSeek route	Observed result	What it demonstrates
Chat, Instant	Valid requested JSON shape, but the decision was incorrect and contradicted the dates.	Structured output can still contain a reasoning error.
Chat, Expert	Valid requested shape and the correct Vendor B decision.	The higher-reasoning route was more reliable on this one task.
V4 Flash API	HTTP 200; correct decision; 2,160 ms; 162 prompt tokens and 205 completion tokens, including 127 reasoning tokens.	Flash completed this small source-grounded task successfully.
V4 Pro API, 500-token limit	HTTP 200, but reasoning consumed all 500 completion tokens; no final content; finish_reason: length.	Thinking tokens must be included in the completion budget.
V4 Pro API, 1,600-token retest	HTTP 200; correct decision; 12,259 ms; 701 completion tokens, including 574 reasoning tokens.	The larger ceiling allowed Pro to return the final JSON.

The live GET /models response contained deepseek-v4-flash and deepseek-v4-pro. The legacy deepseek-chat and deepseek-reasoner aliases also returned HTTP 200 and resolved to deepseek-v4-flash on that date. This is a dated compatibility observation, not a guarantee. New production integrations should use current IDs and monitor provider changes.

DeepSeek V4 vs Kimi K3 specifications

Feature	DeepSeek V4 Flash	DeepSeek V4 Pro	DeepSeek Vision Exp	Kimi K3
Current hosted status	V4-Flash-0731 Public Beta	V4-Pro-0813 GA	V4-Flash-Vision-Exp Experimental	See Moonshot’s current K3 status
Published parameters	284B total / 13B active	1.6T total / 49B active	Not stated in the hosted Vision announcement	2.8T total / 104B active
Context	1M tokens	1M tokens	1M tokens	1,048,576 tokens
Published maximum output	384K tokens	384K tokens	384K tokens	max_completion_tokens up to 1,048,576; default 131,072, subject to request and service limits
Input modalities	Text	Text	Text and images in; text out	Text, images, and video
Image delivery	Not an image-understanding route	Not an image-understanding route	Public URL, Base64/Data URL, or image file_id; Files is image-only	Base64 or Moonshot file IDs; not arbitrary public image URLs
Reasoning control	Thinking/non-thinking; low → Low; medium/high/xhigh → High; max → Max	Thinking/non-thinking; low → Low; medium/high/xhigh → High; max → Max	Thinking/non-thinking; no model-specific effort mapping claimed here	Always thinking; low, high, or max effort
Responses API	Supported; stateless	Supported; stateless	Supported; stateless	See Moonshot’s current API contract
Structured output and tools	Chat json_object; Responses json_schema; function tools; Responses server-side web_search	Chat json_object; Responses json_schema; function tools; Responses server-side web_search	Chat json_object; Responses json_schema; function tools; Responses server-side web_search	Strict JSON Schema, tool choice, and dynamic tool loading
Account concurrency	2,500	500	2,500	See Moonshot’s current account tier
Published weights license	MIT	MIT	No open-weight claim here for Vision Exp	Bespoke Kimi K3 license

K3’s 104B active parameters make it substantially larger per generated token than the published Flash or Pro route on paper; the hosted Vision announcement does not publish a parameter count. That may provide capacity for difficult coding, visual, and agentic tasks, but it may also increase serving requirements and does not guarantee fewer errors. Compare Flash, Pro, Vision Exp, and K3 on the applicable completed-task rate, not raw parameter count.

API pricing and an illustrative cost calculation

Model and effective period	Cached input / 1M	Uncached input / 1M	Output / 1M
DeepSeek Flash — current off-peak	$0.007	$0.22	$0.66
DeepSeek Flash — current peak, Mon–Fri only	$0.014	$0.44	$1.32
DeepSeek Vision Exp — current off-peak	$0.007	$0.22	$0.66
DeepSeek Vision Exp — current peak, Mon–Fri only	$0.014	$0.44	$1.32
DeepSeek Pro — current off-peak	$0.022	$0.66	$1.98
DeepSeek Pro — current peak, Mon–Fri only	$0.044	$1.32	$3.96
DeepSeek Flash — through Aug 16, 15:59 UTC	$0.0028	$0.14	$0.28
DeepSeek Pro — through Aug 16, 15:59 UTC	$0.003625	$0.435	$0.87
Kimi K3 — July 25 list	$0.30	$3.00	$15.00

Historical calculation retained unchanged: the next paragraph preserves the July 28 arithmetic and its boundary; it is not a current price quote.

For an illustrative request with one million uncached input tokens and 200,000 output tokens, list-price arithmetic gives approximately $0.196 on V4 Flash, $0.609 on V4 Pro, and $6.00 on Kimi K3. If the full input qualified for the published cache-hit rate, the same arithmetic would be about $0.0588, $0.177625, and $3.30 respectively.

Historical boundary: that arithmetic is intentionally preserved from July 28 and uses the pre-cutover DeepSeek rates. It is not a quote for requests billed after August 16 at 16:00 UTC.

This is not a prediction of the cost of one identical job. Models tokenize differently, may use different numbers of reasoning and visible-output tokens, and may need different retry counts. Cache eligibility also has provider-specific rules. Measure cost per accepted result, including failed tool calls and repeated context, rather than comparing only the price of one million tokens.

Coding and agent workflows

Moonshot positions K3 for long-horizon coding and agent tasks. Its API supports explicit tool choice, strict JSON Schema, and dynamic tool loading, which can reduce the number of tool definitions sent on every turn. The quickstart also warns developers to retain the complete assistant message during multi-turn and tool-call workflows rather than saving only visible content. Reasoning state and tool metadata can be necessary for the next step.

DeepSeek V4 supports thinking, tool calls, and structured JSON across the three current IDs. Flash and Pro are text routes; experimental Vision Exp adds image understanding with text output. Our July 28 Pro run exposed an important agent-engineering detail: a request can succeed at the HTTP layer yet produce no user-visible answer when the completion limit is consumed by reasoning. Every agent loop should inspect finish_reason, validate the schema, cap retries, and preserve an idempotency key for external actions.

Current endpoint boundary: that July 28 run used Chat Completions with Flash and Pro only. The current stateless Responses API lists all three DeepSeek IDs, supports json_schema, and provides server-side web_search. This documentation update is not a live Vision test.

A fair coding test should use private or newly written tasks rather than well-known benchmark prompts. Include repository navigation, dependency constraints, failing tests, tool errors, ambiguous requirements, and a hidden test suite. Score successful builds and tests, security regressions, unnecessary edits, tool-call count, wall time, tokens, and total cost. Vendor-published benchmark scores can inform the shortlist but should not become your production acceptance test.

Multimodal input

DeepSeek is no longer text-only across its hosted V4 catalog. Experimental deepseek-v4-flash-vision-exp accepts text and supported images and returns text. Supply images by public URL, Base64/Data URL, or an image file_id. DeepSeek’s Files API is limited to JPEG, PNG, GIF, and WebP images; it is not PDF/DOCX/CSV/ZIP ingestion, Batch, RAG, or general file search, and Vision Exp does not generate images.

Kimi K3 retains a clear documented capability advantage when native video input is required. Moonshot describes native understanding of images and video. The API does not accept arbitrary public image URLs: use base64 data or Moonshot file IDs. That affects ingestion design, upload latency, storage, and data-governance review.

Potential evaluation cases include interpreting a product screenshot, tracing a diagram, comparing frames from a short video, extracting evidence from photographed forms, and combining visual evidence with a long text specification. Until those tasks are run with an authenticated account, this page treats multimodality as a documented K3 capability—not a measured accuracy claim.

Million-token context and caching

Both families now support approximately one million tokens of context, so Kimi no longer has a simple context-size advantage over DeepSeek V4. The meaningful questions are how accurately each model finds evidence across the window, how performance changes with distracting material, and what the request costs after caching.

Kimi documents automatic prefix caching when the prior prompt exceeds 256 tokens and the prefix remains unchanged. DeepSeek publishes separate cache-hit and cache-miss prices and exposes usage details. In both systems, place stable instructions and reference material before rapidly changing user content if the API semantics allow it. Record actual cached tokens rather than assuming a repeated request qualified.

Long context should not replace retrieval automatically. Retrieval can enforce permissions, keep facts fresh, produce citations, and reduce irrelevant input. Compare full-context, truncated-context, and retrieve-then-rerank variants on the same dataset. Include “answer not present” cases to detect confident invention.

Reasoning controls and API differences

K3 is always in thinking mode. Developers select reasoning_effort as low, high, or max, with max documented as the default. Moonshot fixes sampling controls such as temperature and top-p, so the quickstart says to omit them rather than trying to tune them like a conventional chat model. DeepSeek allows thinking and non-thinking operation, making a low-cost direct route possible when deep reasoning is unnecessary.

Kimi uses the OpenAI-style base URL https://api.moonshot.ai/v1, but “compatible” should never mean “behaviorally identical.” Test streaming events, message preservation, reasoning fields, tool-call IDs, schema enforcement, token reporting, errors, and retry behavior. Moonshot also says its web-search feature is being updated and is not recommended in the near term; do not design a production citation workflow around it without rechecking the current documentation.

Open weights and license differences

DeepSeek publishes applicable V4 text-model weights under the MIT license; this page makes no open-weight claim for the hosted experimental Vision route. Kimi K3 publishes full weights under its own model license. The K3 license says model-as-a-service businesses exceeding $20 million in aggregate revenue over any consecutive 12-month period need a separate agreement for commercial use. It also imposes prominent “Kimi K3” display conditions on products or services exceeding 100 million monthly active users or $20 million in monthly revenue.

The license includes exceptions concerning internal use and access through official or certified inference partners. This summary is not legal advice. Any company near those thresholds—or building a service for downstream model access—should have counsel read the complete license and confirm which entity, product, revenue, and deployment path the conditions cover.

Self-hosting either model also requires more than downloading weights. Evaluate hardware availability, quantization quality, context-memory requirements, serving throughput, upgrades, monitoring, abuse controls, and the operational cost of a 24/7 service. K3’s documented minimum serving requirements should be checked against the exact precision and throughput target before making a cost comparison with hosted APIs.

Privacy requires contractual clarification

Moonshot’s public Kimi OpenPlatform materials do not provide wording that we can reconcile into a simple “used for training” or “never used for training” conclusion. A narrow API help statement may be read as saying API content is not used for training, while the broader public privacy and model-use documents describe using submitted content and information to provide, maintain, develop, improve, and refine technology. The privacy page also states that servers are located in Singapore.

Because those statements differ in scope and context, a production team should obtain written contractual answers covering training, human review, retention periods, deletion, backups, subprocessors, transfer locations, security controls, incident notice, and data-processing terms. Do not send confidential or regulated data based on a marketing summary or an inference from one help page.

Apply the same standard to DeepSeek. Hosted API terms, account settings, and the contract govern hosted data handling; the open-weight MIT license does not. A self-hosted deployment changes the data path but transfers security and lifecycle responsibility to the operator.

Which model should you choose?

• Start with V4 Flash for high-volume text processing, extraction, classification, straightforward coding, and routing where unit economics matter.
• Escalate to V4 Pro for harder text reasoning or coding cases, while allocating enough completion tokens for thinking and the final response.
• Test Vision Exp when the task needs screenshot, chart, UI, document-photo, or other image understanding with text output; do not use it for image generation or native video.
• Evaluate Kimi K3 for native video input, complex tool-using agents, or workloads where its larger active capacity may improve completed-task rate enough to offset the higher token price; compare it with Vision Exp on matched image tasks.
• Prefer self-hosting only after a total-cost review that includes hardware, serving software, security, monitoring, and staff time.
• Pause procurement if privacy, data location, or K3 license obligations cannot be confirmed in writing for the intended use.

A reproducible Kimi K3 test plan

After funding a Kimi account, the following plan can create a real head-to-head result without changing the rules between providers.

1. Freeze a test set of at least 50 private or newly authored tasks across coding, source-grounded reasoning, structured output, tools, long context, and—where relevant—images or video.
2. Write an answer key, allowed evidence, expected schema, tool side effects, timeout, and pass threshold before running either provider.
3. Use current explicit DeepSeek IDs: deepseek-v4-flash, deepseek-v4-pro, and deepseek-v4-flash-vision-exp; record Kimi K3’s exact served ID from the funded account. Record the date, region, account tier, SDK version, parameters, and full raw response.
4. Run low and high reasoning settings where both APIs offer a meaningful equivalent. Run K3 at documented effort levels, but do not pretend its always-thinking behavior equals DeepSeek’s non-thinking route or extend the published Flash/Pro effort mapping to Vision without evidence.
5. For agent tasks, simulate recoverable tool errors and prevent real external side effects. Score tool selection, argument validity, recovery, duplicate actions, and final task success.
6. For long context, vary evidence position and add plausible distractors. Compare full-context and retrieval-based versions, and verify every cited passage.
7. For image tasks, use the same lossless source images and expected answers. Record whether DeepSeek used URL, Base64, or image file_id; record Kimi preprocessing and upload method because K3 does not accept arbitrary public image URLs. Test video separately because DeepSeek does not document native video input.
8. Measure accuracy, schema validity, groundedness, build and test success, p50/p95 latency, input, cached input, reasoning/output tokens, retries, and cost per accepted result.
9. Repeat nondeterministic tasks and conduct blinded human review. Publish failed cases as well as successful ones.

Limitations

• No Kimi K3 live output was produced for this revision because an authenticated funded account was not available.
• The DeepSeek prompt is one small structured reasoning task, not a comprehensive model benchmark.
• The two latency values are single observations and cannot support a general speed ranking.
• Published model sizes, contexts, and vendor benchmarks do not guarantee application-level accuracy.
• Pricing, rate limits, license terms, and privacy language can change. Recheck the official pages and contract before deployment.

Frequently asked questions

Is Kimi K3 better than DeepSeek V4?

There is no universal winner. K3 documents native image and video input, a larger active model, and agent-focused controls. DeepSeek publishes lower listed token rates, offers Flash and Pro for text, and adds experimental Vision Exp for image understanding with text output. Test matched text and image tasks separately, and treat video as a Kimi-only documented capability in this comparison.

How large is Kimi K3?

Moonshot’s model card lists 2.8 trillion total parameters and 104 billion active parameters, with 1,048,576 tokens of context. Parameter count is an architecture fact, not a direct quality score.

Which API is cheaper, DeepSeek or Kimi?

At the public rates checked July 28, 2026, DeepSeek V4 Flash and Pro are cheaper per input, cached-input, and output token than Kimi K3. Actual cost depends on reasoning length, cache hits, retries, and successful-task rate.

Can Kimi K3 process images and video?

Yes, Moonshot documents native image and video understanding. The API expects base64 input or Moonshot file IDs rather than arbitrary public image URLs. This capability was not independently tested for this revision.

Are DeepSeek V4 and Kimi K3 open source?

Applicable DeepSeek V4 text releases and Kimi K3 publish weights, but the licenses differ. DeepSeek’s applicable V4 weights use MIT; this page makes no open-weight claim for Vision Exp. Kimi K3 uses a bespoke license with conditions for certain very large products and model-as-a-service businesses. Read the complete licenses for the planned use.

Does Kimi use API data for training?

We could not reconcile the scope of Kimi’s public statements into a categorical answer. Obtain written contractual confirmation about training, retention, deletion, review, data location, and subprocessors before submitting sensitive data.

Does Kimi K3 support the OpenAI SDK?

Kimi exposes an OpenAI-style endpoint at https://api.moonshot.ai/v1. Provider-specific reasoning, tool, multimodal, message-preservation, and sampling behavior still requires integration tests; a compatible client does not guarantee feature parity.

Official sources

• DeepSeek models and pricing
• DeepSeek Vision Exp and Files release
• DeepSeek Vision guide
• DeepSeek Files API guide
• DeepSeek rate limit and isolation
• DeepSeek API updates
• DeepSeek Responses API
• DeepSeek V4 model card
• DeepSeek thinking mode
• Kimi K3 quickstart
• Kimi K3 model card
• Kimi K3 pricing
• Kimi K3 license
• Kimi model-use terms
• Kimi OpenPlatform privacy policy

Continue your evaluation

Check the current DeepSeek models and DeepSeek pricing, then reproduce the API behavior with the DeepSeek API guide. Our guides to thinking mode, tool calls, JSON output, context caching, and the evaluation framework provide the controls needed for a fair rerun. Browse the comparison hub for more alternatives.

Update log

• August 24, 2026: Updated only the current DeepSeek layer for the three-model catalog, Vision image input and image-only Files boundary, 1M/384K limits, Vision/Flash pricing and 2,500 concurrency, and Monday–Friday peak windows. Kimi facts and the July 28 DeepSeek test, images, and historical arithmetic remain unchanged.
• July 28, 2026: Replaced the obsolete K2-era comparison with Kimi K3 and DeepSeek V4 specifications, current pricing, K3 API behavior, native multimodal and agent capabilities, bespoke license conditions, privacy-document conflicts, live DeepSeek evidence, and a reproducible K3 test plan.
• August 14, 2026: Updated only the current DeepSeek layer for Pro-0813 GA, Flash-0731 public beta, Responses on both models, endpoint-specific structured output and search, reasoning mapping, and the August 16 pricing cutover. Dated test results and calculations are unchanged.