Prompt Caching Claude API: Guide 2026

Q: Hvad er forskellen på cache_control og output_config?

cache_control styrer input-caching og placeres på content-blokke (eller på request-toplevel for automatisk placering). output_config styrer responsformat (såsom strukturerede JSON-outputs via format ) og påvirker ikke caching. De er fuldt kompatible og bruges typisk sammen.

Opdateret: 20. juni 2026

Prompt caching med Claude API er en server-side mekanisme, der lader dig genbruge store, stabile dele af din prompt på tværs af mange API-kald, og dermed reducere både omkostninger med op til 90% og latens med op til 85%. Du markerer en stabil prefix med cache_control: {"type": "ephemeral"}, og Anthropic gemmer den i 5 minutter (eller 1 time med ttl-feltet) som en gendannelig kontekst. Subsekvente requests, der starter med præcis samme bytes, betaler kun ~0,1× prisen for de cachede tokens. Resten af request afregnes normalt.

Prompt caching er en præfiks-match: enhver byte-ændring tidligt i prompten invaliderer hele cachen efter ændringen.
Cache reads koster ca. 0,1× input-pris; cache writes koster 1,25× (5 min TTL) eller 2× (1 time TTL).
Du behøver minimum 1024–4096 tokens i præfikset (modelafhængigt) før caching aktiveres. Kortere prompts cacher tavst ikke.
Render-rækkefølgen er tools, så system, så messages; placér volatilt indhold (timestamps, IDs) efter sidste breakpoint.
Bekræft cache hits via response.usage.cache_read_input_tokens. Nul betyder en tavs invalidator er på spil.
Maks. 4 cache_control-breakpoints per request; brug dem strategisk ved stabilitetsgrænser.

Hvad er prompt caching, og hvorfor matter det?

Så lad os komme i gang. Prompt caching er en optimeringsfunktion i Claude API, der lader Anthropic gemme den tokeniserede repræsentation af en stabil del af din prompt og genbruge den på subsekvente requests. I praksis betyder det, at et 50.000-token systemprompt med detaljeret kontekst, eksempler eller dokumentation kun betales fuldt pris én gang. Efterfølgende kald inden for cache-vinduet koster ca. 10% af normal input-pris for den cachede del.

For applikationer, der sender det samme store dokument, samme system-instruks eller samme tool-definition i hver request, er besparelsen substantiel. En kundesupport-bot, der inkluderer en 30.000-token manual i hver request, kan typisk reducere både omkostninger og time-to-first-token markant ved at cache manualen. Tilsvarende kan en kodeassistent, der inkluderer en stor codebase som kontekst, opnå betydelige besparelser per session.

Caching er ikke kun en omkostningsmekanisme. Det er også en latens-mekanisme. Når Claude læser fra cache, springer modellen tokenization og en del af forberedelsesfasen over. Det er især vigtigt for interaktive applikationer, hvor brugeren venter på et svar. Jeg implementerede det selv i en kundesupport-pipeline sidste kvartal, og besparelsen alene i første måned dækkede et helt års hosting. Hvis du ikke allerede har det i din RAG-pipeline med Python og ChromaDB eller dine AI-agenter bygget med LangGraph, så er det den enkleste optimering med højeste afkast, du kan lave i 2026.

Sådan virker præfiks-matching (og hvorfor det er kritisk)

Hele caching-systemet bygger på én enkel invariant: prompt caching er en præfiks-match. Anthropic udregner en cache-nøgle baseret på de eksakte bytes i din renderede prompt op til hvert cache_control-breakpoint. Hvis bare én byte er anderledes på position N (et timestamp, en omarrangeret JSON-nøgle, et tilføjet tool), invalideres cachen for alle breakpoints på position N og derefter.

Render-rækkefølgen er fastlagt: først tools, så system, så messages. Et breakpoint på den sidste system-blok cacher derfor både tools og system samlet. Et breakpoint i den sidste user-message cacher hele konversationen op til det punkt.

Det praktiske design-princip er enkelt: stabilt indhold skal fysisk komme før volatilt indhold. Hvis du interpolerer "current time: 2026-06-20T14:33:01Z" i begyndelsen af dit system prompt, har du netop sikret, at intet efter det punkt nogensinde cacher. Flyt dynamisk kontekst til efter dit sidste breakpoint, typisk som en separat tekst-blok i den seneste user-message.

Den anden konsekvens af præfiks-match er, at tools-listen ligger på position 0. At tilføje, fjerne eller omarrangere et tool invaliderer hele cachen, også selvom dit system prompt og dine messages er identiske. Serialiser tools deterministisk (sortér efter navn), og lad være med at bygge tools dynamisk per request, hvis du kan undgå det.

Kom i gang: Python-eksempel med Anthropic SDK

Det enkleste setup bruger top-level cache_control, som automatisk placerer breakpointet på den sidste cachebare blok i din request. Det fungerer for langt de fleste use-cases:

import anthropic

client = anthropic.Anthropic()

# Stort, stabilt system prompt der bliver cachet
SYSTEM_PROMPT = """Du er en ekspert dansk juridisk assistent. Du har adgang
til den fulde tekst af følgende lovgivning:

[... 30.000+ tokens af lovtekst, regulativer og eksempler ...]

Følg disse principper:
1. Citér altid den specifikke paragraf
2. Brug formelt dansk juridisk sprog
3. Markér tvivlsspørgsmål eksplicit
"""

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    cache_control={"type": "ephemeral"},  # auto-cacher sidste cachebare blok
    system=SYSTEM_PROMPT,
    messages=[
        {"role": "user", "content": "Hvad siger lov om databeskyttelse § 8?"}
    ],
)

# Verificer at cachen blev brugt
usage = response.usage
print(f"Cache write: {usage.cache_creation_input_tokens} tokens")
print(f"Cache read:  {usage.cache_read_input_tokens} tokens")
print(f"Ucached:     {usage.input_tokens} tokens")
print(f"Output:      {usage.output_tokens} tokens")

Det første kald vil rapportere cache_creation_input_tokens svarende til systempromptens størrelse. Du betaler 1,25× normal input-pris for at skrive cachen. Det andet kald inden for 5 minutter vil rapportere cache_read_input_tokens i stedet, og du betaler 0,1× normal pris for samme indhold.

For mere finkornet kontrol kan du placere cache_control manuelt på en specifik blok i en struktureret system-array:

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "Du er en ekspert dansk juridisk assistent."
        },
        {
            "type": "text",
            "text": LARGE_LEGAL_CORPUS,  # 30.000 tokens
            "cache_control": {"type": "ephemeral"}  # breakpoint her
        },
    ],
    messages=[
        {"role": "user", "content": "Hvad siger lov om databeskyttelse § 8?"}
    ],
)

Bemærk at max_tokens=1024 er valgt for at holde svaret koncist. For større responses (over ~16.000 tokens) bør du bruge streaming, ellers risikerer du SDK HTTP timeouts.

Prismodel og økonomi: hvornår betaler caching sig hjem?

For at vurdere om caching er værd at implementere, skal du forstå tre prispunkter relativt til normal input-pris:

Type	Pris (relativt til input)	Hvornår
Cache write (5 min TTL)	1,25×	Første gang en præfiks ses
Cache write (1 time TTL)	2,00×	Når du sætter `ttl: "1h"`
Cache read	0,10×	Hver subsekvent request inden for TTL
Uncached input	1,00×	Bytes efter sidste breakpoint
Output	Normal output-pris	Altid. Caching påvirker ikke output

Break-even for 5-minutters cache er to requests: 1,25× + 0,10× = 1,35× mod 2,00× uden caching. For 1-times cache er break-even tre requests: 2,00× + 0,20× = 2,20× mod 3,00×. I praksis betaler caching sig hjem næsten altid, hvis du har et stabilt præfiks på over 1024 tokens og to eller flere requests inden for vinduet.

Et konkret regnestykke. Et system prompt på 50.000 tokens med Claude Opus 4.8 (input-pris $5/1M tokens) koster normalt $0,25 per request. Med caching betaler du $0,3125 første gang og $0,025 hver efterfølgende gang. For 100 requests reduceres totalprisen fra $25 til $2,79, en besparelse på 89%.

Cache er bundet til den specifikke model, du bruger. Skifter du fra claude-opus-4-8 til claude-sonnet-4-6 i samme session, invalideres cachen helt. Sørg for konsistent modelvalg, hvis du vil maksimere hit-raten. Eller deleger sub-opgaver til billigere modeller via separate subagents i stedet for at skifte model midt i en samtale.

Hvor længe lever cachen? 5 minutter vs. 1 time TTL

Standardlevetid for cache-entries er 5 minutter fra sidste cache-hit. Hver gang du læser fra cachen, fornyes TTL'en, så en aktiv konversation holder cachen varm uden særlig indsats. For bursty trafik med længere pauser kan du opt-in til en 1-times TTL:

cache_control = {"type": "ephemeral", "ttl": "1h"}

Prisen er 2× input for write (mod 1,25× for 5-min), men entries overlever pauser på op til en time. Det er typisk værd at betale for, hvis du har:

En kundesupport-pipeline, hvor brugere kommer tilbage efter pauser
Et batch-job, der kører hver halve time over de samme dokumenter
En dashboard-applikation, hvor data refreshes hver 30. minut

For continuous traffic (requests oftere end hver 5. minut) er der ingen grund til 1-times TTL. Almindelige reads holder cachen varm uden ekstra omkostning. For idle gaps under 5 minutter er standardværdien fint.

Bekræft cache hits og find tavse invalidatorer

Anthropic API'et returnerer cache-statistik i response.usage-objektet på hvert request:

Felt	Betydning
`cache_creation_input_tokens`	Tokens skrevet til cachen i denne request (du betalte 1,25× eller 2×)
`cache_read_input_tokens`	Tokens læst fra cachen (du betalte 0,1×)
`input_tokens`	Tokens betalt til fuld pris (ikke cachede)

Den samlede prompt-størrelse er summen af alle tre. Hvis cache_read_input_tokens er nul på tværs af gentagne requests med teoretisk identisk præfiks, er en tavs invalidator aktiv. Ærligt talt, det her er fælde nummer ét, jeg ser hos teams, der lige har slået caching til. De mest almindelige er:

Mønster	Hvorfor det dræber cachen
`datetime.now()` i system prompt	Præfikset ændres ved hver request
`uuid.uuid4()` eller request-ID tidligt i indholdet	Hver request er unik
`json.dumps(d)` uden `sort_keys=True`	Ikke-deterministisk nøglerækkefølge
Iteration over et `set` i prompt-byggeriet	Rækkefølgen er ikke-deterministisk
f-string med session/user ID i system prompt	Per-bruger præfiks, ingen deling mulig
Betingede system-sektioner (`if flag:`)	Hver flag-kombination er et nyt præfiks

For at debugge en mistanke om en tavs invalidator: log de første 500 bytes af din renderede prompt fra to subsekvente requests og diff dem. Den første byte der adskiller sig, er der hvor cachen brydes.

Avancerede mønstre: tools, multi-turn og agentic loops

Caching af tools-definitioner

Hvis du har en stor liste af tool-definitioner via function calling i Python (typisk over 5.000 tokens), kan du cache dem ved at sætte breakpoint på sidste system-blok. Tools renderes før system og er dermed inkluderet i samme cache-entry. Eller sæt eksplicit cache_control på det sidste tool i listen:

tools = [
    {"name": "search_database", "description": "...", "input_schema": {...}},
    {"name": "send_email",      "description": "...", "input_schema": {...}},
    {
        "name": "fetch_url",
        "description": "...",
        "input_schema": {...},
        "cache_control": {"type": "ephemeral"},  # cacher alle tools + system
    },
]

Multi-turn konversationer

For en lang chat-historik kan du flytte cache-breakpointet i hver tur, så hver ny user-message bygger på den forrige cache:

# Tur 1: cacher hele system-prompten
messages = [{"role": "user", "content": "Første spørgsmål"}]

# Tur 2: cacher system + tur 1 (sæt breakpoint på sidste turn)
messages = [
    {"role": "user",      "content": "Første spørgsmål"},
    {"role": "assistant", "content": "Første svar"},
    {
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": "Andet spørgsmål",
                "cache_control": {"type": "ephemeral"},
            }
        ],
    },
]

Du må have maks. 4 cache_control-breakpoints per request, så for meget lange samtaler skal du være strategisk. En typisk pattern er: ét breakpoint på sidste system-blok, ét på begyndelsen af hver "fase" i samtalen, og ét på den seneste user-message.

Agentic loops med MCP-servere bygget i Python

I lange agentic loops, hvor du sender den voksende konversationshistorik tilbage hver iteration, vokser inputstørrelsen lineært. Caching gør dette håndterbart: hver iteration læser den tidligere konversation fra cache og betaler kun fuld pris for den nye tool-result og det nye model-response. Uden caching ville et 50-step agent loop koste cumulativt ekstremt meget. Med caching skalerer omkostningen omtrent lineært med output-mængden.

Almindelige fejl der dræber cache hit-raten

Efter at have implementeret caching i en række produktionssystemer er her de fejl, jeg har set hyppigst (og som er nemme at undgå, hvis man kender dem):

Dynamiske data tidligt i system prompt. "Current date: {today}" eller "User: {username}" i toppen invaliderer alt efter. Flyt det til en separat tekst-blok i den seneste user-message.
Tool-listen ændres per request. Hvis du bygger tools baseret på user permissions, har du en unik tool-liste per bruger. Ingen deling. Brug i stedet en statisk superset af tools, og lad modellen vælge hvilke den må bruge via en parameter.
For kort præfiks. Cache aktiveres først ved minimum ~1024 tokens (eller ~4096 på Opus-modeller). Under tærsklen cacher ingenting, ingen fejl, bare cache_creation_input_tokens: 0 tavst.
Modelskift midt i en konversation. Cache er bundet til modellen. Skift af model invaliderer hele cachen.
Glemte at sortere JSON-nøgler. Python's standard json.dumps bevarer indsættelsesrækkefølge. Hvis du bygger din prompt fra et dictionary, så brug altid sort_keys=True.
For mange breakpoints. Maks. 4 per request. Hvis du sætter flere, returnerer API'et en fejl. Vær strategisk: ét på system+tools, ét på dokumentkontekst, ét på chat-historik.

For yderligere detaljer er Anthropics officielle dokumentation for prompt caching autoritativ kilde. Den nyeste version af anthropic-sdk-python på GitHub understøtter alle features beskrevet her, inklusive 1-times TTL og top-level cache_control.

Ofte stillede spørgsmål

Hvor meget kan jeg spare med prompt caching?

Op til 90% reduktion i input-omkostninger for cachede tokens, hvilket typisk betyder 60–85% reduktion i total request-pris afhængigt af forholdet mellem input og output. For en chatbot med 30.000 tokens stabil kontekst per request og 100 daglige forespørgsler kan månedlige API-omkostninger falde fra hundredevis af dollars til under $20.

Hvor længe gemmer Anthropic cachede prompts?

Standardlevetiden er 5 minutter fra sidste cache-hit (TTL fornyes ved hver læsning). Med ttl: "1h" er levetiden 1 time, men cache-write koster 2× input-pris i stedet for 1,25×. Cache-data slettes automatisk efter TTL og opbevares aldrig på tværs af organisationer.

Virker prompt caching med streaming?

Ja. Caching påvirker kun input-behandlingen; output-streaming fungerer uændret. For requests med max_tokens over ~16.000 bør du altid bruge streaming for at undgå HTTP timeouts, og caching gør første token endnu hurtigere på cachede inputs.

Hvad er forskellen på cache_control og output_config?

cache_control styrer input-caching og placeres på content-blokke (eller på request-toplevel for automatisk placering). output_config styrer responsformat (såsom strukturerede JSON-outputs via format) og påvirker ikke caching. De er fuldt kompatible og bruges typisk sammen.

Hvorfor er min cache_read_input_tokens altid nul?

Den mest sandsynlige årsag er en tavs invalidator i din prompt: et timestamp, et UUID, ikke-deterministisk JSON-serialisering, eller et tool der ændres per request. Log de første 500 bytes af din renderede prompt fra to subsekvente requests og diff dem, og den første afvigende byte afslører kilden.

Kan jeg cache på tværs af forskellige modeller?

Nej. Cache-entries er bundet til den specifikke model (f.eks. claude-opus-4-8). At skifte model, selv mellem nært beslægtede versioner, invaliderer cachen helt. For multi-model arkitekturer bør hver model have sin egen cache-strategi.