DeepSeek Cost Optimization: Cache-Aware Prompt Patterns

DeepSeek's pricing is 10-50x cheaper than Claude and GPT — but only if you design prompts for cache hits. DeepSeek's disk-based KV cache is automatic and enabled by default, but it uses prefix-exact-match. The order of content in your messages directly determines whether a request costs $0.14/M or $0.0028/M.

The Cache-Aware Prompt Pattern

DeepSeek's context cache matches on full prefixes. Each request creates a "cache prefix unit" at the end of user input and model output. Subsequent requests hit the cache only if they EXACTLY match a previously persisted prefix.

Correct: Static Content First

Request 1: [System Prompt] + [Document X] + "Summarize document X"
Request 2: [System Prompt] + [Document X] + "What are the key risks in document X?"
Request 3: [System Prompt] + [Document X] + "Extract all dates from document X"

Request 1 creates a cache unit for System Prompt + Document X. Requests 2 and 3 hit this cache — the static content (System Prompt + Document X) is cached, and only the new question costs input tokens.

Wrong: Variable Content Mixed In

Request 1: [System Prompt] + "Analyze [Document X]" + [Document X content]
Request 2: [System Prompt] + "Analyze [Document Y]" + [Document Y content]

No cache hits — the prefix differs between requests. The system eventually detects the common System Prompt prefix and persists it, but you lose cache benefits for 2+ requests before this kicks in.

Cache-Aware Design Principles

1. Push Static Content to the Beginning

MESSAGE ORDER (cache-optimal):
1. System prompt (unchanging across requests)
2. Long static document (reused across queries)
3. Few-shot examples (consistent format)
4. User's specific question (variable, short)

MESSAGE ORDER (cache-hostile):
1. User's specific question (variable every time)
2. System prompt
3. Document content

2. Batch Queries Against the Same Document

Instead of interleaving queries against different documents (which breaks cache prefix matches), group all queries against one document, then move to the next:

BATCH PATTERN:
Session 1: Load Document A → Query 1, Query 2, Query 3 (high cache hits)
Session 2: Load Document B → Query 1, Query 2, Query 3 (new cache, high hits)

ANTI-PATTERN:
Query 1 against Doc A → Query 2 against Doc B → Query 3 against Doc A (low cache hits)

3. Use Identical System Prompts Across Requests

Even minor changes to the system prompt break cache prefix matches. Parameters, dates, counters — anything dynamic — should go in the user message, not the system prompt:

STABLE (cache-friendly):
System: "You are a financial analyst. Analyze the attached report."

VARIABLE (cache-hostile):
System: "You are a financial analyst. Today is June 12, 2026. Analyze the attached report."

4. Monitor Cache Hit Rates

Check usage.prompt_cache_hit_tokens and usage.prompt_cache_miss_tokens in API responses. Track the ratio over time:

cache_hit = response.usage.prompt_cache_hit_tokens
cache_miss = response.usage.prompt_cache_miss_tokens
hit_rate = cache_hit / (cache_hit + cache_miss)
print(f"Cache hit rate: {hit_rate:.1%}")

Target >80% cache hit rate for document Q&A workloads. Below 50%, restructure your prompt ordering.

When DeepSeek Can Replace Claude/GPT

For routine tasks (classification, extraction, summarization, Q&A), DeepSeek Flash matches or exceeds quality at 90-95% lower cost. Reserve Claude/GPT for tasks where marginal accuracy improvements justify 20-50x higher cost.

Batching Patterns

DeepSeek's concurrency limits (2,500 for Flash) enable massive parallelization:

import asyncio
from openai import AsyncOpenAI

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

async def process_batch(documents, question):
    tasks = []
    for doc in documents:
        tasks.append(client.chat.completions.create(
            model="deepseek-v4-flash",
            messages=[
                {"role": "system", "content": "You are a document analyst."},
                {"role": "user", "content": f"{doc}\n\n{question}"}
            ]
        ))
    return await asyncio.gather(*tasks)

# Process 1,000 documents with a single question
# Cost: ~$14 for 1M input tokens
results = await process_batch(documents, "Extract key entities")

Related Pages

• Flash vs Pro — Model selection is the prerequisite to cost optimization. Choose the right model before optimizing prompts.
• Context Caching — Deep dive into the cache mechanics that make these cost savings possible.