If you have ever pasted a long brief into DeepSeek and seen “Length Limit Reached, Start a New Chat”, you have run into the practical edge of DeepSeek character limits. The honest answer is that DeepSeek does not measure characters at all — it measures **tokens**, and every limit you care about (prompt size, conversation length, response length, file uploads) is enforced in tokens, not characters. That distinction matters because one English word is roughly 1.3 tokens, while one Chinese character is roughly 0.6 tokens. This guide gives you the exact numbers for the current DeepSeek V4 family, shows how to convert characters to tokens for planning, and explains how to recover when a chat hits the wall.

The short answer: DeepSeek limits tokens, not characters

DeepSeek has no “maximum characters per message” setting. Instead, the model counts tokens — sub-word units that the tokenizer produces from your text. The same hard limit applies to your input, the system prompt, any uploaded file content, and the model’s reply combined. When the running total approaches the model’s context window, you see truncation, the “length limit reached” banner, or a 400-class API error.

For planning, use these working ratios:

• English: 1 token ≈ 4 characters ≈ 0.75 words. A 1,000-token prompt is roughly 3,300–4,000 characters or 600–900 words.
• Chinese, Japanese, Korean: 1 Chinese character ≈ 0.6 tokens. A 1,000-token prompt is roughly 1,650 Chinese characters.
• Code: ~2–3 tokens per character in dense languages; a useful shortcut is ~4 tokens for a simple line, ~8–12 for a real-world line with indentation, names and comments. At that pace, 1M tokens holds somewhere around 80K–150K lines of code, depending on style and language.

If you need exact numbers, run your text through the DeepSeek token counter before you paste it into a long-running session.

Current DeepSeek V4 limits at a glance

The current generation is DeepSeek V4, released April 24, 2026, shipped as two open-weight Mixture-of-Experts models under the MIT license. Both V4 tiers share the same context architecture.

DeepSeek-V4-Pro has 1.6T parameters (49B activated) and DeepSeek-V4-Flash has 284B parameters (13B activated) — both supporting a context length of one million tokens. The context window is 1,048,576 tokens with a maximum output of 384,000 tokens. For Think Max reasoning mode, DeepSeek recommends setting the context window to at least 384K tokens.

One subtlety worth internalising: the 1M context is for input. Most answers fit in 2,000 output tokens. The 1M context is for input, not output. If you expect to generate a 50K-token response, you are capped by max_tokens, not by the context window. In other words, the million-token figure is the headroom, but the 384K output cap and your own max_tokens parameter usually bite first.

How the API counts tokens

DeepSeek’s chat surface is a thin wrapper around the OpenAI-compatible POST /chat/completions endpoint at https://api.deepseek.com. The total length of input tokens and generated tokens is limited by the model’s context length. Every token in your messages array — system prompt, prior assistant turns you replay, the new user message, and the model’s response — counts against the same window.

Here is the minimal Python pattern using the OpenAI SDK:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.deepseek.com",
    api_key="YOUR_KEY",
)

resp = client.chat.completions.create(
    model="deepseek-v4-flash",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Summarise this contract in 5 bullets."},
    ],
    max_tokens=2000,
    temperature=1.3,
)

print(resp.usage.prompt_tokens, resp.usage.completion_tokens)

The usage object on the response gives you the authoritative count: prompt_tokens, completion_tokens, plus prompt_cache_hit_tokens and prompt_cache_miss_tokens for billing. That is the only count that matters — tokenizer estimates from third-party libraries can drift by a few percent.

Two things to know about the API surface relative to the chatbot:

• The API is stateless. DeepSeek does not remember prior turns on its side; you must resend the full conversation history with every request. The web chat and mobile app, by contrast, keep session history for you.
• DeepSeek also exposes an Anthropic-compatible surface at the same base URL, so the Anthropic SDK works by swapping base_url and api_key.

For background on getting authenticated and a working request, see the DeepSeek API getting started tutorial.

Legacy model IDs and the migration window

If your code still uses deepseek-chat or deepseek-reasoner, you have a deadline. The model names deepseek-chat and deepseek-reasoner will be deprecated in the future. For compatibility, they correspond to the non-thinking mode and thinking mode of deepseek-v4-flash, respectively. The legacy IDs are fully retired on 2026-07-24 at 15:59 UTC; after that they fail.

Migration is a one-line change. Keep base_url, just update model to deepseek-v4-flash or deepseek-v4-pro. The token limits in this guide already apply to your traffic today, since legacy IDs route to V4-Flash.

Web chat and mobile app: where users actually hit the wall

On DeepSeek chat in the browser and on the mobile DeepSeek app, you do not see token counts. You see a banner: “Length Limit Reached, Start a New Chat” appears when a conversation exceeds the system’s maximum token or context capacity. To solve it, you must begin a new chat and, if needed, transfer or summarize previous content to continue working without losing context.

The chatbot tracks the cumulative token usage across the entire thread, not per message. That means:

• A single huge paste can fill the window in one turn.
• Many small turns can also fill it — every prior user/assistant pair stays in context until you start a new chat.
• Uploaded PDFs, images and documents are extracted to text and added to the same budget.

The system must consider both your inputs and the AI’s responses. Length accumulates silently over time, which is why the message may appear suddenly.

Why “characters” is the wrong unit to think in

Users reach for “character limit” because that is the language Twitter and SMS taught us. Inside an LLM, the budget is tokens, and tokenization depends on the script, the language, and how rare a word is. “Antidisestablishmentarianism” is one English word but several tokens; “你好世界” is four Chinese characters and roughly two-and-a-bit tokens. Reasoning in characters will mislead you. Reason in tokens, and use a counter when the gap matters.

What happens when you hit the limit

Three failure modes, in order of how often they show up in practice:

1. Truncation in the middle of a long answer. The response object’s finish_reason comes back as "length". The message content may be partially cut off if finish_reason=”length”, which indicates the generation exceeded max_tokens or the conversation exceeded the model’s context length. Fix by raising max_tokens (up to 384,000 on V4) or splitting the task.
2. Prompt rejection. The API returns a 400 error before generation starts because the input alone overflows the window. Fix by trimming history, summarising, or moving large reference material into a retrieval index.
3. “Length Limit Reached” in the chatbot. Start a new chat. Paste in a tight summary of where you left off rather than the full transcript.

Practical strategies to stay under the limit

1. Cache the static prefix

Context caching is automatic when DeepSeek detects a repeated prefix across requests. If two requests share a common prefix (e.g., system prompt or few-shot examples), DeepSeek applies context caching. Those repeated tokens are not billed at the full rate. You will see this reflected in the usage object, under fields like prompt_cache_hit_tokens and prompt_cache_miss_tokens. Tokens are cached in 64-token chunks. Move your system prompt and few-shot examples to the start of messages, and keep them byte-identical across calls. The cache cuts cost dramatically; it does not, however, expand the window. See the DeepSeek context caching reference for the exact rules.

2. Summarise instead of replaying

For long-running threads, ask the model to produce a 200–400 token summary of the conversation so far, then start fresh with the summary as the system prompt. You trade some fidelity for a much larger working budget for the next phase.

3. Use retrieval for big corpora

A million tokens is enough to hold a medium codebase or a stack of contracts, but feeding everything in degrades precision. Retrieve only the chunks that matter using embeddings; the DeepSeek RAG tutorial walks through a working pipeline.

4. Set max_tokens deliberately

If you ask for a 50,000-token report, set max_tokens=60000, not the default. If you only need a tight answer, set it to 1,500 — that protects you from runaway JSON outputs and from the model padding into thinking traces you never read.

Thinking mode changes your token math

V4 supports three reasoning-effort settings on either model: non-thinking (default), reasoning_effort="high" with extra_body={"thinking": {"type": "enabled"}}, or reasoning_effort="max" for the most intensive thinking. When thinking is enabled, the response returns reasoning_content alongside the final content. Both fields count toward your output billing.

Two operational consequences:

• Token burn is higher. Reasoning traces can run thousands of tokens before the final answer appears. Budget output accordingly.
• Do not replay reasoning_content. When you continue a multi-turn thread, send only the assistant’s final content back. Replaying reasoning text in the next prompt wastes tokens and confuses the model.

For thinking-max workloads, allocate at least 384K tokens of context, otherwise the reasoning chain truncates silently.

Worked example: costing a long-document workflow

Suppose you are running 10,000 contract reviews per month against deepseek-v4-flash. Each call has a 4,000-token system prompt (cached after the first request), a 50,000-token contract (uncached, varies per call), and a 5,000-token structured response. V4-Flash rates: $0.028 cache-hit / $0.14 cache-miss / $0.28 output per 1M tokens.

Cached input:    4,000  × 10,000 =     40,000,000 tokens × $0.028/M =  $1.12
Uncached input: 50,000  × 10,000 =    500,000,000 tokens × $0.14/M  = $70.00
Output:          5,000  × 10,000 =     50,000,000 tokens × $0.28/M  = $14.00
                                                                       ------
Total                                                                  $85.12

Run the same job on deepseek-v4-pro at $0.145 / $1.74 / $3.48 per 1M and the bill becomes $5.80 + $870.00 + $174.00 = $1,049.80 — a useful reminder that tier choice dwarfs everything else when prompts are long. The DeepSeek pricing calculator handles the arithmetic for you.

How DeepSeek compares to other providers on context

A 1M-token context is competitive at the top of the market as of April 2026, but window size alone is not the whole story — retrieval accuracy at depth and output cap both matter. MRCR 8-needle accuracy stays above 0.82 through 256K tokens and holds at 0.59 at 1M. Practically, that means V4 is reliable up to a few hundred thousand tokens and progressively softer at the extreme. For head-to-head context comparisons, see DeepSeek vs Claude and DeepSeek vs Gemini.

Files, images and audio

In the consumer DeepSeek app you can upload documents, images and PDFs; the system extracts text from each and uses it as input. That extracted text counts against the same context window — a 30-page PDF with diagrams might land around 15,000–25,000 tokens of extracted prose. Plan for that when you upload alongside a long question. For step-by-step file workflows, see the DeepSeek features reference.

Quick reference: planning your prompts

• Short question, no history: any model, any tier — limits are not in play.
• Long document review (≤ 200K tokens): V4-Flash, non-thinking. Budget 4–8K output.
• Repository-scale code analysis (200K–800K tokens): V4-Pro, thinking high. Stage the prompt; do not dump everything at once.
• Hard reasoning over a small input: V4-Pro, thinking max. Allocate 384K context.
• Multi-turn agent loops: cache the system prompt; summarise older turns at every milestone.

For the broader picture of what each model can do, browse the DeepSeek beginner guides hub.

Last verified: 2026-04-25. DeepSeek AI Guide is an independent resource and is not affiliated with DeepSeek or its parent company. Model IDs, pricing and API behaviour change; check the official DeepSeek documentation and pricing page before committing to a production decision.