DeepSeek Prompt Templates (Token-Efficient)

TL;DR: DeepSeek's current models are deepseek-v4-flash, deepseek-v4-pro and deepseek-v4-flash-vision-exp, all at 1M context. deepseek-chat and deepseek-reasoner were retired in July 2026. Thinking mode is on by default and silently ignores temperature. Cap output length first: it is the largest cost lever by a wide margin.

What are the best DeepSeek prompt templates?

The best DeepSeek prompt templates make three decisions explicit before you send anything: how long the answer may be, whether thinking mode is on, and what sits at the top of the prompt so the cache can match it. Those three choices account for almost the entire cost of a DeepSeek call. Everything else is rounding.

That is a different claim from the usual advice about prompt compression, and the arithmetic below is where it comes from. Twenty-five templates follow, but they only pay off once you know which dial each one turns.

Everything here was checked against DeepSeek's own API docs on August 26, 2026. Model names and prices there move on the order of weeks, so re-check the sources before building anything expensive on this.

Which DeepSeek model should you actually be calling?

One of three: deepseek-v4-flash, deepseek-v4-pro, or deepseek-v4-flash-vision-exp for image input. If a guide tells you to call deepseek-chat or deepseek-reasoner, it is out of date and the call will fail.

DeepSeek's V4 Preview note is explicit: "deepseek-chat & deepseek-reasoner will be fully retired and inaccessible after Jul 24th, 2026, 15:59 (UTC Time)." During the transition they routed to V4-Flash in non-thinking and thinking mode respectively. That window has closed.

This matters more than a normal rename, because those two IDs are what nearly every DeepSeek guide written in 2025 tells you to use. The base URL did not change. The model string did.

The base URL stays https://api.deepseek.com for OpenAI-format calls, and https://api.deepseek.com/anthropic for Anthropic-format calls.

What does a DeepSeek prompt actually cost?

Cheap, but not uniformly cheap. The spread between the most and least expensive token you can buy is roughly 500 to 1, and knowing which end your template sits on is the whole game.

DeepSeek's published table, per 1M tokens, on August 26, 2026:

Peak hours are 01:00 to 04:00 and 06:00 to 10:00 UTC, Monday through Friday. Every other hour is off-peak, at exactly half.

Now the part nobody publishes. Run the ratios and five cost levers fall out, in order of size:

1. Output length. An output token costs exactly 3x a cache-miss input token, and roughly 90x a cache-hit input token, on both models. Nothing else you control comes close.
2. Cache hits. A cache-hit input token costs about 3% of a cache-miss input token. Roughly a 30x saving on the input side.
3. Flash instead of Pro. V4-Pro costs exactly 3x V4-Flash on every row of the table. Not "roughly", exactly.
4. Off-peak scheduling. Exactly 2x between peak and off-peak. Free money for any batch job that does not need to run right now.
5. Compressing the prompt text itself. The smallest of the five, and the one every other guide leads with.

That ordering is the useful finding. Shaving 200 tokens off a prompt saves less than shaving 70 off the answer. A template with no explicit length constraint leaks money at the most expensive rate DeepSeek charges.

Does temperature work on DeepSeek?

Only if you explicitly turn thinking mode off. On a default call it is silently ignored. DeepSeek's own documentation says both things in different places, and the pages have never been reconciled. Here are all three sources.

The thinking mode guide. Verbatim: "Thinking mode does not support the temperature, top_p, presence_penalty, or frequency_penalty parameters. Please note that, for compatibility with existing software, setting these parameters will not trigger an error but will also have no effect." The same page states that "Thinking mode is enabled by default, with the default effort being high".

The temperature page. A page titled "The Temperature Parameter" is still live at api-docs.deepseek.com/quick_start/parameter_settings, still returns HTTP 200, and still publishes a per-use-case table: coding and math 0.0, data analysis 1.0, general conversation 1.3, translation 1.3, creative writing 1.5, default 1.0.

The API reference. A third answer again. /api/create-chat-completion documents temperature and top_p as live parameters with defaults of 1, while flatly marking frequency_penalty and presence_penalty as deprecated: "This parameter is no longer supported. It will not take effect if you pass it to the API."

All three are true in their own scope, and the resolution is datable. The temperature page carries a last-modified header of April 17, 2026, seven days before V4 Preview launched. It is absent from DeepSeek's current sitemap.xml, is unlinked from the current Quick Start navigation, and its own sidebar is frozen against a pre-V4 build of the docs. It is an orphan of the previous generation that survived the rewrite.

Both halves are stated rather than picking one, because a reader following only the temperature page tunes a parameter that does nothing, and a reader following only the thinking mode page concludes DeepSeek has no sampling controls at all. Neither is right. For the parameter surfaces at OpenAI, Anthropic and Google, none of which behave this way, see the LLM parameter cheat sheet. DeepSeek is not in that table, which is why it needed its own page.

Here is the toggle.

# Non-thinking mode: temperature applies, cheap, fast
response = client.chat.completions.create(
    model="deepseek-v4-flash",
    messages=messages,
    temperature=0.0,                 # now this actually does something
    max_tokens=300,
    extra_body={"thinking": {"type": "disabled"}}
)

# Thinking mode: temperature ignored, use effort instead
response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages,
    reasoning_effort="low",          # low | high | max are the real levels
    max_tokens=2000,
    extra_body={"thinking": {"type": "enabled"}}
)

Note the extra_body wrapper. DeepSeek's docs call this out: with the OpenAI SDK, thinking must be passed inside extra_body, because it is not part of the OpenAI schema.

How does DeepSeek's context caching actually work?

It is on by default for every account with no code change, and roughly 30x cheaper on input. But it stopped being simple prefix matching, and the new rule catches people out.

DeepSeek's caching page explains that under its Sliding Window Attention mechanism, "Each cached prefix is an independent, complete unit. A subsequent request can only hit the cache if it fully matches a cache prefix unit."

Units get persisted three ways: at request boundaries (the end of user input and the end of model output), at fixed token intervals for long inputs and outputs, and through common-prefix detection across requests.

The third surprises people. DeepSeek's worked example: you send a long financial report with three different questions about it. Requests one and two both miss. Only after those complete does the system identify the shared system message plus report body as a cache prefix unit and persist it. The third request hits.

Two more caveats from the same page. Caching is "best-effort" with no guaranteed hit rate, and unused caches are cleared "usually within a few hours to a few days", so an hourly job caches well and a weekly one probably does not.

Check your hit rate rather than assuming it. Every response carries prompt_cache_hit_tokens and prompt_cache_miss_tokens in usage:

u = response.usage
hit, miss = u.prompt_cache_hit_tokens, u.prompt_cache_miss_tokens
print(f"cache hit rate: {hit / (hit + miss):.1%}")
# Below ~50% on a repeated workload means your prefix is not stable.
# Common culprits: a timestamp, a request ID, or a shuffled list at the top.

One documented waste worth removing. When a request does not carry tools, DeepSeek's docs state that a previous turn's reasoning_content "does not need to participate in the context concatenation. If passed to the API in subsequent turns, it will be ignored." DeepSeek does not publish whether ignored content is billed, so treat it as dead weight and strip it. It also destabilises your prefix, costing cache hits regardless. The exception is strict: when the request does carry tools, reasoning_content must be passed back every turn or the API returns a 400.

How do you compress a DeepSeek prompt without losing quality?

By cutting what the model does not read, not what it does. Compression fails when people delete constraints and examples, which are exactly the parts carrying the quality.

Safe to cut, in rough order of payoff:

• Unbounded output. The largest by far. Add a length ceiling and a max_tokens cap.
• Politeness and preamble. "I hope you can help me with this" is billed and buys nothing.
• Restating the obvious. "You are an AI language model" tells the model nothing it does not already act on.
• Redundant framing. Saying the task three ways in case one lands. Say it once, precisely.

Do not cut few-shot examples, format specifications, or negative constraints. These are the highest-value tokens per byte in any prompt, and they sit on the cheap side of the bill once your prefix is stable enough to cache.

The compression that actually works is structural. Move every stable element into a fixed header block that never changes between calls, and put only the variable part at the bottom. That makes the prompt shorter to write and makes the top of it cacheable. The practical version is a personal prompt library holding the header once, with the variable slot filled per call.

25 token-efficient DeepSeek prompt templates

Fill the bracketed slots. Every template states its mode, because on DeepSeek that is a pricing decision as much as a quality one.

Structure and compression (1 to 5)

1. The token-budget harness. A hard ceiling on any task.

Answer in at most [N] words. No preamble, no restatement of the question,
no closing summary. If the answer needs more than [N] words to be correct,
say "NEEDS MORE" and give the single most important sentence instead.

Task: [TASK]

2. Lossless context compressor. Shrink a document before feeding it to a more expensive call.

Compress the text below to under [N] tokens while preserving every fact,
number, name, date and causal claim. Drop transitions, adjectives and
repetition. Output as terse bullet fragments, not sentences. Preserve
anything you are unsure about rather than dropping it.

TEXT:
[PASTE]

3. Reusable context header. The cache anchor. Send this block byte-identical every time.

[STABLE HEADER — never edit between calls]
Role: [ROLE]
Domain rules:
- [RULE 1]
- [RULE 2]
Output format: [FORMAT]
Constraints: [CONSTRAINTS]
Vocabulary: [TERMS THE MODEL MUST USE]
[END STABLE HEADER]

Task for this call: [VARIABLE PART GOES HERE, AND ONLY HERE]

4. The delta prompt. For iteration, send the change, not the world.

Previous output is in the assistant turn above. Change ONLY the following:
[CHANGE 1]
[CHANGE 2]
Return only the changed sections, labelled by their original heading.
Do not reproduce unchanged text.

5. Terse mode system prompt. Set once, saves on every call.

You are a terse technical assistant. Rules:
- No preamble, no "Certainly", no restating the question.
- No closing summary or offer of further help.
- Bullet fragments over sentences where meaning survives.
- If a one-word answer is correct, give one word.
- State uncertainty as "UNSURE: [reason]" in five words or fewer.

Cache-shaped templates (6 to 9)

6. Document analysis header. The stable prefix goes above the question, always.

SYSTEM: You are a [DOMAIN] analyst. Answer only from the document below.
Quote the source line for every factual claim. If the document does not
answer the question, say "NOT IN DOCUMENT".

DOCUMENT:
[FULL DOCUMENT — byte-identical across all calls in this batch]

QUESTION: [ONE QUESTION]

7. Batch question set. Amortise a document over many questions.

[SAME STABLE HEADER + DOCUMENT AS TEMPLATE 6]

Answer each question below independently. Number your answers to match.
Maximum [N] words per answer.
1. [Q1]
2. [Q2]
3. [Q3]

8. Cache warm-up call. One cheap throwaway to persist the prefix before a real batch.

[STABLE HEADER + DOCUMENT]

QUESTION: Reply with exactly the word "READY" and nothing else.

9. Multi-tenant isolation wrapper. Keep one customer's cache away from another's.

# user_id isolates KVCache, content safety and scheduling per end user.
# Must match [a-zA-Z0-9\-_]+ , max 512 chars, no personal data in it.
extra_body={"user_id": "tenant_04812", "thinking": {"type": "disabled"}}

Non-thinking mode, for mechanical work (10 to 15)

Turn thinking off for all six. None benefit from chain-of-thought, and all six get billed for it if you leave it on.

10. Classification.

Classify the input into exactly one of: [A] | [B] | [C] | UNCLEAR.
Output the label only. No explanation, no punctuation.

INPUT: [TEXT]

11. Field extraction.

Extract these fields from the text. Output valid JSON only, no prose,
no markdown fence. Use null for anything absent. Do not infer or guess.

Fields: [field_1: type], [field_2: type], [field_3: type]

TEXT: [PASTE]

12. Translation with register control.

Translate to [LANGUAGE]. Preserve register, idiom and formatting exactly.
Do not explain, annotate or add notes. Keep [PROPER NOUNS / CODE / URLS]
untranslated. Output the translation only.

TEXT: [PASTE]

13. Reformat and normalise.

Reformat the input into [TARGET FORMAT]. Change nothing about the content:
no rewording, no summarising, no fixing of apparent errors. Structure only.

INPUT: [PASTE]

14. Fixed-length summary.

Summarise in exactly [N] sentences. Each sentence must contain at least one
number or proper noun from the source. No sentence may begin with "The text"
or "This document".

SOURCE: [PASTE]

15. Boilerplate generation.

Generate [WHAT] in [LANGUAGE]. Follow the conventions in the example below
exactly: naming, error handling, import style, comment density. Output code
only, no explanation before or after.

EXAMPLE:
[PASTE ONE REPRESENTATIVE FILE]

NOW GENERATE: [SPEC]

Thinking mode, for work that earns it (16 to 20)

Keep thinking on for these five, and set reasoning_effort deliberately: low for most, max only when a wrong answer is expensive.

16. Debug with a stated hypothesis.

Bug: [SYMPTOM]
Expected: [EXPECTED]
Actual: [ACTUAL]
Reproduces: [ALWAYS / SOMETIMES / ONCE]
Already ruled out: [LIST]

Give exactly three candidate root causes ranked by likelihood. For each:
the mechanism in one sentence, and the single cheapest test that would
disprove it. No code until I pick one.

17. Architecture review.

Review the design below against: [CONSTRAINT 1], [CONSTRAINT 2],
[CONSTRAINT 3]. For each constraint state PASS, RISK or FAIL with one
sentence of justification. Then name the single change with the best
ratio of risk reduced to effort spent. Maximum [N] words total.

DESIGN: [PASTE]

18. Plan before executing.

Do not write any code yet. Produce a numbered plan of at most [N] steps
for: [GOAL]. Each step must be independently verifiable and name the file
it touches. Flag any step where you would be guessing at intent.
Stop after the plan.

19. Derivation with checkable steps.

Solve: [PROBLEM]

Show each step as: [operation] -> [result]. After the final answer, verify
it by substituting back into the original and state whether it holds.
If verification fails, say so rather than adjusting the answer.

20. Tool-use agent turn.

# When tools are present, reasoning_content MUST be passed back in every
# subsequent turn or the API returns 400. This is the opposite of the
# no-tools case, where it is ignored.
messages.append(response.choices[0].message)   # carries reasoning_content
response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages,
    tools=tools,
    reasoning_effort="high",
    extra_body={"thinking": {"type": "enabled"}}
)

Output control (21 to 25)

21. Strict JSON. DeepSeek requires the literal word "json" in the prompt and a worked example.

Output valid json matching the schema shown. No markdown fence, no prose.

EXAMPLE JSON OUTPUT:
{"id": "abc", "score": 0.0, "tags": ["x"], "notes": null}

INPUT: [PASTE]

Set response_format to type json_object, and max_tokens high enough that the object cannot truncate mid-string. DeepSeek's docs note the API "may occasionally return empty content" in JSON mode, so validate before parsing. The general case is covered in JSON prompts explained.

22. Diff only.

Return a unified diff and nothing else. Do not restate unchanged lines
beyond three lines of context. If the change touches more than [N] lines,
stop and say "TOO LARGE: [reason]" instead.

FILE: [PASTE]
CHANGE: [DESCRIPTION]

23. Table only.

Output a markdown table with exactly these columns: [C1] | [C2] | [C3].
One row per [UNIT]. No text before or after the table. Use "-" for any
cell you cannot fill from the source.

SOURCE: [PASTE]

24. Stop-sequence bounded.

# Hard stop the moment the useful part ends. Up to 16 sequences allowed.
response = client.chat.completions.create(
    model="deepseek-v4-flash",
    messages=messages,
    stop=["\n---", "\nNotes:", "\nIn summary"],
    max_tokens=400,
    extra_body={"thinking": {"type": "disabled"}}
)

25. Flash-or-Pro router. Run this once per task type, not per call.

Task: [DESCRIBE THE TASK]
Sample input: [PASTE ONE]
Sample of an acceptable output: [PASTE ONE]

Answer only: FLASH or PRO, then one sentence of justification.
Answer PRO only if the task needs multi-step reasoning where an early
wrong turn cannot be recovered. Answer FLASH for anything mechanical,
extractive, or verifiable at a glance.

When is V4-Flash genuinely enough?

Most of the time, and DeepSeek says so itself. Its V4 Preview note describes V4-Flash as having "reasoning capabilities closely approach V4-Pro" and performing "on par with V4-Pro on simple Agent tasks." Given Pro costs exactly 3x on every row, the burden of proof sits with Pro. Per the same note, Pro is 1.6T total and 49B active parameters; Flash is 284B and 13B.

Note the fourth row. If Flash usually succeeds and a retry is cheap, running Flash twice still costs less than running Pro once. Do that calculation per task type rather than assuming.

Where Prompt Architects fits, and where it does not

Straight answer: our extension does not natively support DeepSeek's web interface today. The 12 platforms it natively supports are ChatGPT, Gemini, Claude, Grok, Perplexity, v0.dev, Bolt, Lovable, Kimi, Base44, Merlin and NotebookLM. DeepSeek is not on that list.

What does carry over is model-agnostic. The prompt library, global variables and context library store the stable header blocks from templates 3, 6 and 7 once, so you fill a variable instead of retyping a 400-token preamble and accidentally breaking your cache prefix. The prompt template library and the MCP server work the same way whichever model receives the text. For a broader starting set, 100+ prompt templates is the general-purpose library, and the prompt engineering cheat sheet covers the technique layer underneath all of this.

There is a free plan, capped at 5 prompt enhancements per day, forever, per our FAQ. Current paid pricing is on the pricing page.

Sources and access dates

Every claim above traces to DeepSeek's own documentation, all accessed August 26, 2026:

• Models & Pricing: model IDs, 1M context, 384K max output, the price table, peak hours, concurrency limits.
• Thinking Mode: the unsupported-parameter statement, thinking on by default at high, the effort mapping, the reasoning_content rules.
• Context Caching: cache prefix units, the three persistence mechanisms, the three-request example, prompt_cache_hit_tokens.
• Create Chat Completion: temperature and top_p live; frequency_penalty and presence_penalty deprecated.
• JSON Output: the "json" keyword requirement and the empty-content caveat.
• V4 Preview Release, April 24, 2026: the deepseek-chat and deepseek-reasoner retirement date, parameter counts.
• V4-Pro GA Release, August 13, 2026: peak and off-peak pricing effective 16:00 UTC, August 16, 2026.
• The Temperature Parameter: the per-use-case table. Live, last-modified April 17, 2026, absent from the current sitemap and navigation.

The contradiction in the last two bullets is real, and is reported rather than resolved in DeepSeek's favour or against it. If those pages are reconciled after publication, trust the thinking mode page: it is the one in the current navigation.