DeepSeek

Overview

DeepSeek is a Hangzhou-based AI lab that ships frontier-class language models through three channels: free web/app chat at chat.deepseek.com, a pay-as-you-go API at api.deepseek.com, and MIT-licensed open weights on Hugging Face. The current flagship line is DeepSeek-V4 Preview (released 24 April 2026): deepseek-v4-pro (1.6T total / 49B active MoE) and deepseek-v4-flash (284B total / 13B active MoE). Both support a 1M-token context window, up to 384K max output, dual thinking / non-thinking modes, tool calling, and JSON output.

DeepSeek’s pitch is cost-efficient frontier performance: official API rates land far below typical closed-source competitors, automatic context caching makes agent and coding loops cheap, and the same models can be self-hosted under MIT when data residency or offline control matters. Developers often drop DeepSeek into OpenAI or Anthropic SDKs by swapping base_url, and agent harnesses such as Claude Code, OpenClaw, and OpenCode list official integrations.

Key features

• DeepSeek-V4-Pro & V4-Flash — MoE flagships with hybrid sparse attention (CSA/HCA + DSA). Pro activates ~49B of 1.6T parameters; Flash activates ~13B of 284B. Pre-trained on more than 32T tokens with a two-stage post-training pipeline (domain experts + on-policy distillation).
• 1M context by default — Official services and open weights target a 1-million-token context with drastically lower KV-cache and FLOPs than DeepSeek-V3.2 on long prompts (DeepSeek claims ~10% KV cache and ~27% single-token FLOPs for Pro vs V3.2 at 1M).
• Thinking modes — Non-thinking for fast answers; thinking (default on API) for multi-step reasoning; “Max” effort for hardest math/coding/agent tasks. Thinking mode is documented separately from model IDs so you can switch without changing models.
• OpenAI- and Anthropic-compatible API — https://api.deepseek.com (OpenAI format) and https://api.deepseek.com/anthropic. Supports chat completions, streaming, JSON mode, tool/function calls, FIM completion (non-thinking only, beta), and chat prefix completion (beta).
• Context caching — Cache-hit input is billed at a small fraction of cache-miss input (e.g. $0.0028 vs $0.14 per 1M on Flash). Long system prompts, codebases, and multi-turn agent sessions become much cheaper when prefixes repeat.
• Free hosted chat — Instant Mode maps to V4-Flash; Expert Mode maps to V4-Pro. Web, mobile app, document upload, and long-context chat without per-token billing for interactive use.
• MIT open weights — Base and instruct weights for Flash and Pro (plus quantized variants) are published on Hugging Face under MIT. Self-host, fine-tune, or serve commercially without a separate model license fee.
• Agent harness fit — Official notes integration with Claude Code, OpenClaw, and OpenCode; strong scores on coding/agent benches (e.g. LiveCodeBench, SWE-bench Verified in DeepSeek’s V4 report tables).
• user_id isolation — Optional user_id for content-safety isolation, KV-cache isolation, and per-user scheduling under one account.

Pricing

DeepSeek’s commercial API is pure usage-based (no monthly seat). Prices below are the official public rates per 1M tokens as listed on DeepSeek’s Models & Pricing page (verified mid-July 2026). Product prices can change; confirm on the docs before large spends.

Model ID	Input (cache hit)	Input (cache miss)	Output	Context / max out	Concurrency
deepseek-v4-flash	$0.0028	$0.14	$0.28	1M / 384K	2,500
deepseek-v4-pro	$0.003625	$0.435	$0.87	1M / 384K	500

• Billing — Tokens × price, deducted from topped-up or granted balance (granted first). Keys and balance live at platform.deepseek.com.
• Legacy aliases — deepseek-chat and deepseek-reasoner map to Flash non-thinking / thinking and are scheduled for full retirement on 2026-07-24 15:59 UTC. Migrate to deepseek-v4-flash / deepseek-v4-pro explicitly.
• Higher concurrency — Expansion is request-based at no extra concurrency fee; default caps are account-level (not per key).
• Free chat — chat.deepseek.com and the mobile app remain free for interactive use; heavy automation should use the API or self-host.
• Self-host — MIT weights mean no per-token fee; cost is GPU, power, and ops. Full Pro is large; Flash is the practical self-host default for many teams. Third-party hosts (OpenRouter, DeepInfra, etc.) reprice V4 independently.

Limits & gotchas

• Concurrency caps — 2,500 concurrent for Flash, 500 for Pro per account. Excess returns HTTP 429. A request holds a slot until the full response finishes (long thinking jobs hold longer).
• Keep-alive / queue — Server may send empty lines or SSE keep-alive comments before tokens; clients must tolerate them. Idle wait before inference starts can close after ~10 minutes.
• Preview vs GA messaging — V4 shipped as “Preview” on 24 Apr 2026; community still tracks a fuller GA refresh and possible peak/off-peak pricing discussions. Treat production rollouts as “verify today’s docs,” not frozen 2025 V3 numbers.
• Hosted data residency — Official API and chat are operated by a Chinese company. Regulated or highly sensitive data often needs self-host or a jurisdiction-controlled third-party host, not the default API.
• Censorship & refusal style — Hosted models may refuse or soft-filter some political/sensitive topics differently than US labs; open weights allow local uncensoring/fine-tunes, but that is your compliance burden.
• Hardware for local Pro — 1.6T MoE with FP4/FP8 mixed weights is not a laptop toy. Quantized community builds and Flash are the realistic local path; Pro often wants multi-GPU or specialized inference stacks.
• FIM only in non-thinking — Fill-in-the-middle is beta and limited to non-thinking mode; don’t assume thinking + FIM in one call.
• Tool-call + thinking — Multi-step tool loops require correct handling of reasoning content / tool messages per the thinking-mode guide; naive OpenAI ports sometimes drop fields and degrade quality.
• Peak load — Free chat and popular API windows can feel slower or flaky during global peaks; build retries and timeouts for production agents.

Community sentiment

On Hacker News and Reddit (r/DeepSeek, r/LocalLLaMA, r/LLMDevs), DeepSeek V4 is repeatedly praised for price-to-quality: users report agent and coding workloads at a small fraction of Claude/GPT spend, especially when context caching hits. Several HN threads call V4-Pro “almost frontier” on coding and instruction following, with cache effectiveness as the standout (e.g. multi-million-token sessions billed in cents-to-dollars when prefixes reuse).

LocalLLaMA users celebrate MIT weights and Flash efficiency but note that full Pro is heavy to run and that V4 is still labeled preview—some prefer other open MoEs (Kimi, GLM variants) on specific benches or for smaller self-host footprints. Reddit coding threads often pair DeepSeek as the cheap execution model with a stronger closed model for planning/review. Common complaints: free-chat capacity hiccups, UI/design quality for pure front-end tasks, and caution about sending proprietary data to the hosted Chinese API.

Use Flash + caching for volume; Pro thinking for hard reasoning; open weights when the data cannot leave your network.

Who should use it

• Startups and indie builders who need strong coding/math/agent models without Anthropic/OpenAI token bills.
• Teams with OpenAI/Anthropic-compatible stacks that can flip base_url and model IDs with minimal code change.
• Agent and coding harness users (Claude Code, OpenCode, OpenClaw, custom tool-call loops) that burn huge context and benefit from cache-hit pricing.
• Researchers and platform teams who want MIT weights to fine-tune, evaluate, or serve privately.
• High-volume backends (classification, extraction, batch rewrite) where Flash non-thinking is “good enough” and cost is the bottleneck.

Skip or limit hosted DeepSeek if you need vendor SLAs from a US/EU hyperscaler, guaranteed enterprise data processing agreements in your jurisdiction, or absolute peak UI/creative writing polish from the latest closed frontier models.

Alternatives

• Claude — Stronger default for careful writing, long software-engineering agents, and enterprise trust when budget allows.
• ChatGPT — Best ecosystem (plugins, memory, consumer UX) if you want OpenAI’s product surface more than raw $/token.
• Gemini — Google’s long-context multimodal stack; often preferred when you already live in Google Cloud / Workspace.
• Mistral — European open-weight + API alternative with a different compliance story and model mix.
• Ollama — Local runner for open weights (including DeepSeek quantizations) without writing your own inference stack.
• OpenAI API — Drop-in if you need GPT-class models, Assistants/tools ecosystem, and US-vendor procurement paths.

Verdict

In mid-2026, DeepSeek is one of the highest-leverage defaults for cost-sensitive LLM work: free Expert/Instant chat for humans, an OpenAI/Anthropic-compatible API with aggressive cache-aware pricing for agents, and MIT open weights when you must own the stack. V4-Pro approaches closed frontier quality on coding and hard reasoning for a fraction of the token price; V4-Flash is the volume workhorse. The tradeoffs are real—preview-era product maturity, China-hosted data path for the official API, and serious hardware for full local Pro—but for most developers who can accept those constraints, DeepSeek is no longer a “budget backup.” It is a primary model provider.