Kamu rilis fitur yang manggil LLM setiap user request. System prompt, tool definitions, few-shot examples — 2.000 token yang sama, diproses dari nol, setiap panggilan. Sebulan kemudian tagihan datang dan kamu bayar harga penuh untuk konten yang nggak pernah berubah antar request.
Prompt caching memperbaiki ini. Anthropic dan OpenAI sekarang nge-cache prefix prompt yang berulang. Di cache hit, kamu bayar sebagian kecil dari harga input normal — 10% di Anthropic, 50% di OpenAI. Untuk workload dengan system prompt yang besar dan stabil, itu artinya tagihan turun drastis.
Cara Kerja Prompt Caching
Ide dasarnya sederhana. Ketika kamu kirim request, provider ngecek apakah prefix prompt kamu cocok dengan sesuatu yang baru aja diproses. Kalau iya, token itu dibaca dari cache. Kamu bayar tarif cache-read (jauh lebih murah), bukan tarif input penuh.
Kedua provider nge-cache prefix penuh — system prompt, tools, dan messages sampai breakpoint yang ditentukan. Kalau prefix-nya baru, mereka proses normal dan cache untuk panggilan berikutnya.
Cache bersifat ephemeral. Anthropic default 5 menit (refresh gratis setiap dipakai), OpenAI sekitar 30 menit. Bayangin kayak "request berulang dalam waktu yang berdekatan."
Anthropic: Automatic Caching (Satu Baris)
Anthropic punya setup paling simpel. Tambah satu field ke request:
import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-sonnet-4-5-20250901", # atau claude-opus-4-8
max_tokens=1024,
cache_control={"type": "ephemeral"},
system="Kamu adalah code reviewer. Cek isu keamanan, masalah performa, dan pelanggaran style. Selalu kasih saran perbaikan konkret.",
messages=[{"role": "user", "content": "Review ini: def foo(x): return eval(x)"}],
)
# Cek penggunaan cache di response
print(response.usage.cache_read_input_tokens) # token yang dibaca dari cache
print(response.usage.cache_creation_input_tokens) # token yang ditulis ke cache
Cuma cache_control={"type": "ephemeral"} yang kamu butuhin. Anthropic otomatis nge-cache semuanya sampai block terakhir yang bisa di-cache. Panggilan pertama: tulis ke cache (tarif 1,25× input normal). Panggilan berikutnya dengan prefix yang sama: baca dari cache (tarif 0,1× input normal).
Untuk system prompt 2.000 token, perhitungannya:
| Panggilan pertama | Panggilan kedua | Panggilan ke-100 (total) | |
|---|---|---|---|
| Tanpa caching | 2.000 × $15/MTok = $0,03 | $0,03 | $3,00 |
| Dengan caching | 2.000 × $18,75/MTok = $0,038 | 2.000 × $1,50/MTok = $0,003 | ~$0,34 |
Itu penghematan sekitar 90% setelah panggilan pertama kena prefix yang sama. Angka ini pakai harga Claude Opus 4.8 ($15/MTok input, $18,75/MTok cache write, $1,50/MTok cache read). Model lebih murah seperti Claude Sonnet 4.5 punya struktur multiplier yang sama dengan harga absolut lebih rendah.
Cache lifetime default 5 menit. Setiap kali konten cache dipakai, timer reset — gratis. Kamu juga bisa pilih TTL 1 jam dengan tarif cache write 2× input normal.
Anthropic: Explicit Cache Breakpoints
Automatic caching praktis tapi kontrolnya diserahkan ke sistem. Kalau kamu pengen nge-cache blok tertentu dan biarin yang lain nggak ke-cache, pakai explicit breakpoints:
response = client.messages.create(
model="claude-sonnet-4-5-20250901",
max_tokens=1024,
system=[
{
"type": "text",
"text": "Kamu adalah code reviewer. Cek isu keamanan.",
"cache_control": {"type": "ephemeral"}, # Cache system prompt
},
{
"type": "text",
"text": f"Review kode dalam bahasa: {user_language}",
# Tanpa cache_control — ini berubah per request, nggak worth di-cache
},
],
messages=[{"role": "user", "content": user_code}],
)
Cuma blok dengan cache_control yang di-cache. Hint bahasa yang dinamis nggak buang ruang cache. Ini berguna kalau kamu punya campuran konten statis dan dinamis — cache yang berulang, lewati yang berubah.
Kamu juga bisa menandai pesan terakhir dalam percakapan sebagai breakpoint supaya seluruh history ke-cache:
messages = conversation_history + [
{
"role": "user",
"content": [
{"type": "text", "text": pertanyaan_terbaru},
{"type": "text", "text": "Akhir dari turn percakapan.",
"cache_control": {"type": "ephemeral"}},
],
}
]
Di turn berikutnya, seluruh history sampai marker itu dibaca dari cache. Percakapan panjang jadi jauh lebih murah.
OpenAI: Automatic Caching (Tanpa Ubah Kode)
OpenAI ambil pendekatan berbeda. Prompt caching otomatis untuk prompt di atas 1.024 token di model yang didukung (GPT-4o, GPT-4o-mini, o1, o3, o4-mini). Kamu nggak perlu ubah kode sama sekali — service yang ngurus.
Cek response usage untuk lihat apakah caching aktif:
from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": "Kamu adalah SQL expert. Kalau dikasih pertanyaan, output cuma SQL query. Tanpa penjelasan."},
{"role": "user", "content": "Cari semua user yang signup bulan lalu"},
],
)
usage = response.usage
print(f"Token input: {usage.prompt_tokens}")
print(f"Token dari cache: {usage.prompt_tokens_details.cached_tokens}")
# Kalau cached_tokens > 0, kamu hemat di panggilan ini
Di cache hit, OpenAI kasih diskon 50% untuk token input yang ke-cache. Cache write dikenakan 1,25× tarif normal di model baru (GPT-4.1+, GPT-5.6+). Di model lama (GPT-4o, o1), cache write gratis — kamu cuma dapet benefit dari read tanpa penalti write.
Prompt cache key. Kalau banyak request share prefix panjang yang sama, pakai prompt_cache_key untuk naikin hit rate:
response = client.chat.completions.create(
model="gpt-4.1",
messages=[...],
extra_body={
"prompt_cache_key": "tenant:acme:legal-reviews-v1",
},
)
Ini bantu OpenAI routing request dengan key yang sama ke mesin yang sama, di mana cache lebih mungkin masih hangat. Pakai kalau kamu punya aplikasi multi-tenant dan tiap tenant punya system prompt atau knowledge base sendiri.
Pola Nyata yang Menghemat Uang
Tiga pola di mana prompt caching bikin perbedaan terukur.
Pola 1: System Prompt Besar
Bot customer support dengan system prompt 4.000 token (brand guidelines, katalog produk, aturan eskalasi, contoh tone-of-voice). Tanpa caching: $0,06 per panggilan di GPT-4o ($2,50/MTok × 4K token × 6 panggilan/menit = ~$21/jam). Dengan caching: diskon 50% di token input, sekitar $10,50/jam.
Workload yang sama di Claude Sonnet dengan diskon cache-hit 90%: biaya system prompt hampir nol setelah panggilan pertama.
Pola 2: Agent dengan Banyak Tool
Agent yang manggil LLM dengan 20 tool definitions (seringkali 3.000+ token JSON schema). Definisi itu identik di ratusan panggilan dalam sesi yang sama:
tools = [
{"name": "search_kb", "description": "Cari di knowledge base...", "input_schema": {...}},
{"name": "create_ticket", "description": "Buat tiket support...", "input_schema": {...}},
# ... 18 lainnya
]
# Panggilan pertama: tools di-cache dengan tarif 1,25×
# Panggilan berikutnya di window 5 menit yang sama: tools dibaca dari cache tarif 0,1×
response = client.messages.create(
model="claude-sonnet-4-5-20250901",
max_tokens=1024,
cache_control={"type": "ephemeral"},
tools=tools,
messages=[{"role": "user", "content": "Cari panduan setup VPN"}],
)
Pola 3: Percakapan Multi-Turn
Aplikasi chat di mana setiap pesan baru nambah ke history yang makin panjang. Di turn 20, percakapan mungkin 8.000 token. Tanpa caching, setiap turn proses full history dengan tarif input penuh. Dengan Anthropic explicit breakpoints menandai pesan terbaru, cuma pesan user baru dan respons asisten yang diproses di tarif penuh — 7.500 token pertama kena cache di harga 10%.
OpenAI nge-handle ini otomatis untuk percakapan di atas 1.024 token.
Kapan Pakai Anthropic vs OpenAI
Nggak ada yang strictly lebih baik. Tergantung workload.
Pakai Anthropic kalau:
- System prompt atau tool definitions kamu besar dan stabil (diskon 90% di reads unggul)
- Kamu butuh kontrol eksplisit atas apa yang di-cache
- Kamu jalanin agentic loop dengan tool calls (tools dan system yang sama dipakai berulang)
- Kamu pengen TTL 5 menit yang guaranteed dengan refresh gratis
Pakai OpenAI kalau:
- Kamu pengen nol perubahan kode (otomatis untuk prompt >1.024 token)
- Workload kamu punya prefix reuse moderat (diskon 50% solid untuk setup minimal)
- Kamu di model GPT-4o atau o-series di mana cache write gratis
- Kamu lebih suka TTL 30 menit tanpa perlu ngurus
Pakai dua-duanya kalau kamu routing antar provider. Polanya mirip jadi kamu bisa enable caching di kedua sisi dengan kode minimal.
Kesalahan Umum
Prompt pendek nggak di-cache. OpenAI butuh prefix minimal 1.024 token. Anthropic butuh minimal 1.024 token untuk Claude Sonnet dan 2.048 token untuk Claude Opus. System prompt 500 token nggak akan di-cache oleh provider manapun.
Cache write lebih mahal dari input normal. Di Anthropic, cache write 1,25× tarif normal. Di model OpenAI terbaru, multiplier sama. Kalau kamu kirim prefix berbeda di setiap request, kamu bayar penalti write tanpa pernah dapet diskon read. Itu strictly worse daripada tanpa caching.
Prefix dinamis nge-break cache hit. Kalau system prompt kamu ada timestamp atau user ID di awal, prefix berubah tiap panggilan. Cache nggak pernah match. Taruh konten dinamis setelah konten statis (di akhir prompt, bukan di awal). Atau pakai explicit breakpoints untuk menandai cuma bagian statis yang cacheable.
Terlalu banyak cache breakpoints. Setiap breakpoint mecah prefix. Di OpenAI, cuma prefix terpanjang yang matching sampai 50 breakpoints yang dipertimbangkan. Di Anthropic, cuma konten sebelum breakpoint yang di-cache. Pilih satu atau dua breakpoint strategis, bukan selusin.
Monitoring gratis — pakai. Kedua provider ekspos data cache hit/miss di usage response. Bikin dashboard atau log. Kalau cache-hit rate di bawah 30%, strategi caching kamu nggak jalan. Penyebab paling umum: prefix berubah antar panggilan dan kamu nggak sadar.
Yang Nggak Dibahas
Prompt caching juga ngurangin latency. Token yang ke-cache nggak diproses ulang lewat full model forward pass, yang motong 100-500ms dari response time untuk prefix besar. Latency win paling kerasa di chat UI real-time di mana tiap milidetik berarti.
Anthropic juga nawarin batch processing (diskon 50%, turnaround 24 jam) dan OpenAI punya Batch API (konsep sama). Ini bisa dikombinasi dengan caching — kamu bisa batch request yang share cached prefix dan ngelipatgandakan penghematan. Tradeoff beda (throughput vs latency), tapi worth diketahui.
Langkah Selanjutnya
- Baca dokumentasi Anthropic prompt caching untuk referensi API lengkap, termasuk setup TTL 1 jam dan cache diagnostics
- Baca panduan OpenAI prompt caching untuk varian Responses API dan detail prompt cache key
- Cek tagihan API kamu saat ini. Cari panggilan di mana token input jauh lebih besar dari token output — itu kandidat caching kamu
- Enable caching di satu endpoint dan ukur perbedaannya selama seminggu. Angkanya akan kasih tahu lebih banyak dari blog post manapun