Belangrijkste inzichten
- OpenAI-compatibele API: DeepSeek volgt het OpenAI API-formaat -- stap over door de base_url en API-key te wijzigen. De OpenAI Python SDK, LangChain en LlamaIndex werken allemaal direct.
- 90% besparing met context caching: Gedeelde prompt-prefixes worden automatisch gecasht tegen $0.28/M tokens vs $0.28/M voor cache-misses -- geen codewijzigingen nodig.
- 5 miljoen gratis tokens om te beginnen: Nieuwe accounts ontvangen 5M gratis tokens zonder dat een creditcard vereist is, genoeg voor uitgebreide experimenten.
- Twee modi: deepseek-chat voor standaardtaken (8K max output) en deepseek-reasoner voor Chain-of-Thought redenering (64K max output) -- reasoner gebruikt meer tokens maar levert betere resultaten bij moeilijke problemen.
DeepSeek V4 API-handleiding: Prijzen, Installatie & Codevoorbeelden
DeepSeek is de kostenleider geworden in LLM API's. Met prijzen die een orde van grootte lager liggen dan die van OpenAI en Anthropic en volledige OpenAI SDK-compatibiliteit, duurt het overstappen naar DeepSeek ongeveer vijf minuten. Deze gids loodst u door alles heen: accountinstelling, prijsberekeningen, codevoorbeelden in Python en JavaScript, context caching en migratie vanaf OpenAI.
Of u nu een chatbot bouwt, een code-assistent, of volledige codebases verwerkt met het 1M token context-venster, deze gids helpt u verder.
Snel aan de slag: Uw eerste DeepSeek API-aanroep
Aan de slag gaan duurt drie stappen.
1. Maak een account aan
Ga naar platform.deepseek.com en meld u aan. Nieuwe accounts ontvangen 5 miljoen gratis tokens zonder dat een creditcard vereist is — genoeg om uitgebreid te experimenteren voordat u zich vastlegt.
2. Genereer een API-key
Navigeer naar API Keys in het dashboard. Klik op Create new API key, geef deze een naam en kopieer de key onmiddellijk. U zult deze niet opnieuw kunnen bekijken.
Sla de key op als een omgevingsvariabele:
export DEEPSEEK_API_KEY="sk-your-key-here"
3. Doe uw eerste verzoek
Omdat DeepSeek het OpenAI API-formaat volgt, kunt u de officiële OpenAI SDK gebruiken. Installeer deze eerst:
pip install openai
Doe vervolgens een eenvoudige chat completion-aanroep:
from openai import OpenAI
client = OpenAI(
api_key="sk-your-key-here",
base_url="https://api.deepseek.com"
)
response = client.chat.completions.create(
model="deepseek-chat",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Explain Python decorators in three sentences."}
]
)
print(response.choices[0].message.content)
Dat is het. Als u de OpenAI API eerder hebt gebruikt, zijn de enige verschillen de base_url en uw API-key.
Prijsoverzicht
Het prijsmodel van DeepSeek is eenvoudig en aanzienlijk goedkoper dan dat van concurrenten. De belangrijkste onderscheidende factor is context caching, wat de inputkosten met 90% verlaagt voor herhaalde prompt-prefixes.
DeepSeek API-prijzen
| Token-type | Kosten per 1M tokens |
|---|---|
| Input (cache hit) | $0.028 |
| Input (cache miss) | $0.28 |
| Output | $0.42 |
Hoe dit zich verhoudt
| Provider / Model | Input (per 1M) | Output (per 1M) |
|---|---|---|
| DeepSeek V4 (cache hit) | $0.028 | $0.42 |
| DeepSeek V4 (cache miss) | $0.28 | $0.42 |
| OpenAI GPT-5.4 | $2.50 | $10.00 |
| Anthropic Claude Opus 4.6 | $15.00 | $75.00 |
| Google Gemini 3.1 Pro | $1.25 | $5.00 |
De cijfers spreken voor zich. Met cache hits is DeepSeek ongeveer 90x goedkoper dan OpenAI op input-tokens en 500x goedkoper dan Claude Opus. Zelfs zonder caching is het cache-miss tarief van DeepSeek van $0.28/M nog steeds 9x goedkoper dan de GPT-5.4 input-prijzen.
Kostenvoorbeeld
Het verwerken van 100 verzoeken, elk met een 2,000-token system prompt en een 500-token gebruikersquery, waarbij antwoorden van 1,000 tokens worden gegenereerd:
- Met caching (99 cache hits): ~$0.05 totaal
- Zonder caching: ~$0.29 totaal
- Dezelfde werklast op GPT-5.4: ~$3.75 totaal
Voor toepassingen met een hoog volume lopen de besparingen snel op.
API-modi: deepseek-chat vs deepseek-reasoner
DeepSeek biedt twee verschillende modelmodi, elk geoptimaliseerd voor verschillende taken.
deepseek-chat
De standaardmodus voor algemene taken. Snel, efficiënt en geschikt voor de meeste toepassingen.
| Eigenschap | Waarde |
|---|---|
| Max input-tokens | 1,000,000 |
| Max output-tokens | 8,192 |
| Beste voor | Chat, samenvatting, codegeneratie, algemene Q&A |
deepseek-reasoner
Maakt Chain-of-Thought (CoT) redenering mogelijk. Het model "denkt" stap voor stap na voordat het een definitief antwoord geeft, wat de nauwkeurigheid bij moeilijke problemen aanzienlijk verbetert.
| Eigenschap | Waarde |
|---|---|
| Max input-tokens | 1,000,000 |
| Max output-tokens | 64,000 |
| Beste voor | Wiskunde, logische puzzels, complex debuggen, meerstaps redeneren |
De reasoner retourneert zowel het denkproces als het definitieve antwoord:
response = client.chat.completions.create(
model="deepseek-reasoner",
messages=[
{"role": "user", "content": "Prove that the square root of 2 is irrational."}
]
)
# De reasoning chain
print(response.choices[0].message.reasoning_content)
# Het definitieve antwoord
print(response.choices[0].message.content)
Wanneer de reasoner te gebruiken: Als de taak meerstaps logica, wiskundige bewijzen of complex code-debuggen vereist, gebruik dan deepseek-reasoner. Voor al het andere is deepseek-chat sneller en goedkoper.
Codevoorbeelden
Python: Basis chat completion
import os
from openai import OpenAI
client = OpenAI(
api_key=os.getenv("DEEPSEEK_API_KEY"),
base_url="https://api.deepseek.com"
)
def ask_deepseek(prompt, system_prompt="You are a helpful assistant."):
response = client.chat.completions.create(
model="deepseek-chat",
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": prompt}
],
temperature=0.7,
max_tokens=2048
)
return response.choices[0].message.content
answer = ask_deepseek("Write a Python function to merge two sorted lists.")
print(answer)
Python: Streaming
Voor lange antwoorden biedt streaming een betere gebruikerservaring door tokens te retourneren terwijl ze worden gegenereerd:
stream = client.chat.completions.create(
model="deepseek-chat",
messages=[
{"role": "system", "content": "You are a senior software engineer."},
{"role": "user", "content": "Review this code and suggest improvements:\n\ndef fib(n):\n if n <= 1: return n\n return fib(n-1) + fib(n-2)"}
],
stream=True
)
for chunk in stream:
if chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
Python: Reasoner-modus
response = client.chat.completions.create(
model="deepseek-reasoner",
messages=[
{"role": "user", "content": "Find all bugs in this code and explain why each is a bug:\n\ndef quicksort(arr):\n if len(arr) <= 1:\n return arr\n pivot = arr[0]\n left = [x for x in arr if x < pivot]\n right = [x for x in arr if x > pivot]\n return quicksort(left) + [pivot] + quicksort(right)"}
]
)
print("Reasoning:", response.choices[0].message.reasoning_content)
print("Answer:", response.choices[0].message.content)
JavaScript / Node.js: Basis chat
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.DEEPSEEK_API_KEY,
baseURL: "https://api.deepseek.com",
});
async function askDeepSeek(prompt) {
const response = await client.chat.completions.create({
model: "deepseek-chat",
messages: [
{ role: "system", content: "You are a helpful assistant." },
{ role: "user", content: prompt },
],
});
return response.choices[0].message.content;
}
const answer = await askDeepSeek("Explain closures in JavaScript.");
console.log(answer);
JavaScript / Node.js: Streaming
const stream = await client.chat.completions.create({
model: "deepseek-chat",
messages: [
{ role: "user", content: "Write a REST API in Express.js with CRUD routes for a todo app." },
],
stream: true,
});
for await (const chunk of stream) {
const content = chunk.choices[0]?.delta?.content;
if (content) {
process.stdout.write(content);
}
}
Context Caching: 90% besparing op herhaalde prompts
De context caching van DeepSeek is een van de sterkste concurrentievoordelen en vereist nul codewijzigingen aan uw kant.
Hoe het werkt
Wanneer u een verzoek verstuurt, controleert DeepSeek of het begin van uw prompt overeenkomt met een eerder gecashte prefix. Als de eerste N tokens identiek zijn aan een recent verzoek, worden die tokens vanuit de cache geleverd tegen het verlaagde tarief ($0.028/M vs $0.28/M).
Dit gebeurt automatisch. U hoeft geen cache keys te declareren, TTL's in te stellen of uw API-aanroepen op enige wijze aan te passen.
Wanneer caching wordt geactiveerd
Caching treedt in werking wanneer:
- Dezelfde system prompt over verschillende verzoeken heen. Als elk verzoek begint met "You are a senior Python developer...", wordt die prefix gecasht na de eerste aanroep.
- Gedeelde gespreksgeschiedenis. In gesprekken met meerdere beurten wordt de opgebouwde geschiedenis van eerdere beurten gecasht.
- Batchverwerking met consistente sjablonen. Het uitvoeren van dezelfde analyse-prompt over verschillende inputs betekent dat alleen het variabele gedeelte het volledige tarief kost.
Cache hits maximaliseren
Om het meeste uit caching te halen:
- Plaats statische inhoud eerst. Structureer uw berichten zo dat de system prompt en eventuele vaste instructies vóór de variabele inhoud komen.
- Houd system prompts identiek. Zelfs een verschil van één enkel teken verbreekt de cache-match.
- Verwerk soortgelijke verzoeken in batches. Verstuur verzoeken met gedeelde prefixes kort achter elkaar zodat de cache warm blijft.
- Gebruik gerust lange system prompts. Een system prompt van 10,000 tokens kost bijna niets na het eerste verzoek als deze gecasht blijft.
Migratie vanaf OpenAI
Als u momenteel de OpenAI API gebruikt, is de overstap naar DeepSeek een wijziging van twee regels. Het API-formaat is identiek.
Voorheen (OpenAI)
from openai import OpenAI
client = OpenAI(
api_key="sk-openai-key-here"
# base_url defaults to https://api.openai.com/v1
)
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Hello"}]
)
Daarna (DeepSeek)
from openai import OpenAI
client = OpenAI(
api_key="sk-deepseek-key-here",
base_url="https://api.deepseek.com" # <-- voeg deze regel toe
)
response = client.chat.completions.create(
model="deepseek-chat", # <-- wijzig de modelnaam
messages=[{"role": "user", "content": "Hello"}]
)
Dat is de gehele migratie. Twee regels zijn gewijzigd: base_url en model. Al het andere — berichtformaat, streaming, function calling, JSON mode — werkt op dezelfde manier.
Aanpak met omgevingsvariabelen
Voor projecten die eenvoudig tussen providers moeten kunnen schakelen:
import os
from openai import OpenAI
provider = os.getenv("LLM_PROVIDER", "deepseek")
config = {
"deepseek": {
"api_key": os.getenv("DEEPSEEK_API_KEY"),
"base_url": "https://api.deepseek.com",
"model": "deepseek-chat"
},
"openai": {
"api_key": os.getenv("OPENAI_API_KEY"),
"base_url": "https://api.openai.com/v1",
"model": "gpt-4o"
}
}
client = OpenAI(
api_key=config[provider]["api_key"],
base_url=config[provider]["base_url"]
)
DeepSeek gebruiken met open-source tools
Omdat DeepSeek OpenAI-compatibel is, werkt het met het groeiende ecosysteem van open-source AI coding tools. Hier zijn de populairste.
OpenCode
OpenCode is een open-source terminal-gebaseerde AI coding assistent. Configureer het om DeepSeek te gebruiken door de provider in uw configuratie in te stellen:
{
"provider": {
"name": "deepseek",
"apiKey": "sk-your-key",
"baseURL": "https://api.deepseek.com",
"model": "deepseek-chat"
}
}
Aider
Aider is een command-line AI pair programmer. Verwijs het naar DeepSeek met omgevingsvariabelen:
export OPENAI_API_BASE="https://api.deepseek.com"
export OPENAI_API_KEY="sk-your-deepseek-key"
aider --model openai/deepseek-chat
Continue (VS Code Extension)
Continue is een open-source AI code-assistent voor VS Code en JetBrains. Voeg DeepSeek toe in uw ~/.continue/config.json:
{
"models": [
{
"title": "DeepSeek V4",
"provider": "openai",
"model": "deepseek-chat",
"apiBase": "https://api.deepseek.com",
"apiKey": "sk-your-key"
}
]
}
Alle drie de tools behandelen DeepSeek als een directe OpenAI-vervanging. Geen speciale adapters of plugins nodig.
Gebruikmaken van het 1M token context-venster
Het context-venster van 1 miljoen tokens van DeepSeek maakt workflows mogelijk die voorheen onpraktisch waren.
Volledige codebase-analyse
Een typisch middelgroot project (50,000 regels code) is ongeveer 500,000 tokens. Met het 1M context van DeepSeek kunt u een volledige codebase in één prompt invoeren voor:
- Architectuur-beoordelingen. Vraag het model om circulaire afhankelijkheden, ontbrekende abstracties of inconsistente patronen over het hele project te identificeren.
- Bestands-overschrijdende refactoring. Beschrijf de gewenste wijziging en laat het model gecoördineerde bewerkingen over meerdere bestanden genereren.
- Beveiligingsaudits. Scan de hele codebase op SQL injection, XSS en andere kwetsbaarheden in één keer.
Praktische tips voor grote contexten
- Geef eerst een bestandsboom op. Begin uw prompt met de mappenstructuur zodat het model de projectlay-out begrijpt voordat het individuele bestanden leest.
- Gebruik duidelijke scheidingstekens. Wikkel elk bestand in markeringen zoals
--- FILE: src/auth.py ---zodat het model naar specifieke bestanden kan verwijzen in zijn antwoord. - Stel gerichte vragen. Een 1M context-venster betekent niet dat u vage prompts moet gebruiken. Wees specifiek over wat u geanalyseerd wilt hebben.
- Combineer met caching. Als u meerdere vragen stelt over dezelfde codebase, wordt het codebase-gedeelte gecasht na de eerste aanroep — volgende vragen kosten een fractie van de initiële aanroep.
Best practices voor kostenoptimalisatie
1. Structureer prompts voor maximale cache hits
Plaats uw langste, meest stabiele inhoud aan het begin van de berichten-array. System prompts, few-shot voorbeelden en referentiedocumentatie moeten vóór de variabele gebruikersquery komen.
2. Gebruik standaard deepseek-chat
Bewaar deepseek-reasoner voor taken die echt meerstaps redenering vereisen. Voor eenvoudige generatie, samenvatting en code completion is deepseek-chat sneller en gebruikt het minder tokens.
3. Stel passende max_tokens in
Stel max_tokens niet hoger in dan u nodig heeft. Als u een antwoord van 200 tokens verwacht, zal het instellen van max_tokens: 8192 op zich niet meer kosten, maar het voorkomt dat het model niet stopt als het begint uit te weiden.
4. Verwerk vergelijkbare verzoeken in batches
Groepeer verzoeken die dezelfde system prompt delen en verstuur ze kort achter elkaar. Dit houdt de cache warm en zorgt ervoor dat de meeste verzoeken de gecashte prefix raken.
5. Monitor token-verbruik
Controleer het usage-veld in API-antwoorden om uw werkelijke verbruik bij te houden:
# In het respons-object:
print(f"Input tokens: {response.usage.prompt_tokens}")
print(f"Output tokens: {response.usage.completion_tokens}")
print(f"Cache hit tokens: {response.usage.prompt_cache_hit_tokens}")
print(f"Cache miss tokens: {response.usage.prompt_cache_miss_tokens}")
6. Gebruik streaming voor lange outputs
Streaming bespaart geen geld, maar het verbetert de waargenomen latentie. Gebruikers zien de eerste tokens binnen milliseconden in plaats van te wachten tot het volledige antwoord is gegenereerd.
Afronding
De API van DeepSeek combineert agressieve prijzen, OpenAI-compatibiliteit en een 1M token context-venster in een pakket dat moeilijk te negeren is. Het migratiepad vanaf OpenAI is triviaal — verander twee regels code en uw bestaande applicatie werkt. Context caching levert automatische kostenbesparingen op zonder enige codewijzigingen. En het ecosysteem van open-source tools ondersteunt DeepSeek al als een eersteklas provider.
Voor ontwikkelaars die kostengevoelige applicaties, verwerkingspijplijnen met een hoog volume of tools voor volledige codebase-analyse bouwen, is DeepSeek V4 een serieuze overweging waard. Begin met de 5 miljoen gratis tokens, benchmark tegen uw huidige provider en laat de cijfers uw beslissing leiden.
