Inleiding: waarom de Claude API de moeite waard is
In 2026 is de Claude API van Anthropic uitgegroeid tot een van de meest gebruikte AI-interfaces voor bedrijven die serieuze applicaties willen bouwen. Of je nu een klantenservice-bot wil automatiseren, documenten wil samenvatten, of een volledige AI-agent wil bouwen die zelfstandig taken uitvoert: de Claude API geeft je de tools om het te doen.
Deze gids neemt je mee van je allereerste API-aanroep tot een robuuste productieomgeving. We behandelen authenticatie, foutafhandeling, codevoorbeelden in Python en Node.js, streaming, tool use, en alles wat je nodig hebt om Claude veilig en efficiënt in te zetten.
Verwacht: meer dan 10 werkende codevoorbeelden, architectuurkeuzes uitgelegd, en een productie-checklist die je direct kunt gebruiken.
Stap 1: Account aanmaken en API key ophalen
Voordat je ook maar een regel code schrijft, heb je een Anthropic account nodig en een geldige API key.
Account aanmaken
Ga naar console.anthropic.com en maak een account aan. Na verificatie heb je toegang tot het developer dashboard. Hier vind je je API keys, gebruiksstatistieken en billing-instellingen.
API key aanmaken
Navigeer in het dashboard naar 'API Keys' en klik op 'Create Key'. Geef de key een herkenbare naam (bijv. 'productie-app' of 'dev-lokaal'). Kopieer de key direct: je ziet hem maar eenmaal.
Sla de key op als omgevingsvariabele, nooit hardcoded in je code:
# Linux/macOS
export ANTHROPIC_API_KEY="sk-ant-xxxxxxxxxxxx"
# Windows (PowerShell)
$env:ANTHROPIC_API_KEY = "sk-ant-xxxxxxxxxxxx"
# In een .env bestand (gebruik python-dotenv of dotenv in Node)
ANTHROPIC_API_KEY=sk-ant-xxxxxxxxxxxxGebruik nooit dezelfde key voor development en productie. Maak separate keys aan per omgeving en roteer ze elke 90 dagen.
Stap 2: SDK installeren en je eerste aanroep
Anthropic biedt officiële SDK's voor Python en TypeScript/Node.js. Beide zijn goed gedocumenteerd en actief onderhouden.
Python installatie
pip install anthropic
# Of met uv (aanbevolen voor reproduceerbare omgevingen):
uv add anthropicJe eerste Python aanroep
import anthropic
import os
client = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
message = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=1024,
messages=[
{"role": "user", "content": "Leg uit wat een REST API is in twee zinnen."}
]
)
print(message.content[0].text)Node.js / TypeScript installatie
npm install @anthropic-ai/sdk
# Of met yarn:
yarn add @anthropic-ai/sdkJe eerste Node.js aanroep
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY,
});
const message = await client.messages.create({
model: "claude-sonnet-4-6",
max_tokens: 1024,
messages: [
{ role: "user", content: "Leg uit wat een REST API is in twee zinnen." }
],
});
console.log(message.content[0].text);Direct met curl (voor snelle tests)
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "claude-sonnet-4-6",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "Hallo Claude, werkt dit?"}
]
}'Stap 3: Het juiste model kiezen
Anthropic biedt meerdere Claude-modellen aan, elk met een andere balans tussen snelheid, intelligentie en kosten. In 2026 zijn dit de belangrijkste opties:
Claude Opus 4.6: het krachtigste model. Gebruik dit voor complexe taken zoals diepgaande analyse, meertalige tekst, of agentic workflows waar redeneren centraal staat. Relatief hoge kosten per token.
Claude Sonnet 4.6: de sweet spot voor de meeste productietoepassingen. Snel, intelligent en betaalbaar. Aanbevolen voor klantenservice-bots, samenvattingen, codering en RAG-systemen.
Claude Haiku 3.5: ultrasnell en goedkoop. Ideaal voor eenvoudige classificatietaken, korte teksten genereren, of hoge-volume applicaties waar latency kritisch is.
Tip voor productie: begin met Sonnet voor de meeste taken. Reserveer Opus voor de 10-20% van aanvragen die echt complexe redenering vereisen. Gebruik Haiku voor pre-screening of eenvoudige classificatie.
Stap 4: Foutafhandeling en retry-logica
In productie gaan dingen mis. API's hebben rate limits, netwerken vallen uit, en tijdelijke overbelasting is normaal. Robuuste foutafhandeling is geen optie: het is vereist.
Veel voorkomende foutcodes
429 Too Many Requests: je hebt de rate limit bereikt. Wacht en probeer opnieuw. 500/529 Server Error: tijdelijke overbelasting bij Anthropic. Exponential backoff toepassen. 400 Bad Request: controleer je parameters (max_tokens, model naam, message format).
Retry-logica met exponential backoff (Python)
import anthropic
import time
import os
from anthropic import RateLimitError, APIStatusError
client = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
def vraag_claude_met_retry(prompt: str, max_pogingen: int = 5) -> str:
wachttijd = 1 # seconden
for poging in range(max_pogingen):
try:
response = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=1024,
messages=[{"role": "user", "content": prompt}]
)
return response.content[0].text
except RateLimitError:
if poging == max_pogingen - 1:
raise
print(f"Rate limit bereikt. Wacht {wachttijd}s... (poging {poging + 1}/{max_pogingen})")
time.sleep(wachttijd)
wachttijd *= 2 # Exponential backoff
except APIStatusError as e:
if e.status_code in [500, 529] and poging < max_pogingen - 1:
print(f"Server fout {e.status_code}. Wacht {wachttijd}s...")
time.sleep(wachttijd)
wachttijd *= 2
else:
raise
raise Exception("Maximaal aantal pogingen bereikt")
# Gebruik:
antwoord = vraag_claude_met_retry("Wat zijn de voordelen van Python?")
print(antwoord)Stap 5: Streaming responses implementeren
Voor gebruikersinterfaces wil je tekst tonen terwijl Claude hem genereert: net als in de Claude.ai interface. Dit heet streaming en zorgt voor een responsievere gebruikerservaring.
Streaming in Python
import anthropic
import os
client = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
with client.messages.stream(
model="claude-sonnet-4-6",
max_tokens=1024,
messages=[{"role": "user", "content": "Schrijf een kort verhaal over een robot."}]
) as stream:
for tekst in stream.text_stream:
print(tekst, end="", flush=True)
# Haal de volledige response op na afloop
finale_response = stream.get_final_message()
print(f"\n\nTokens gebruikt: {finale_response.usage.output_tokens}")Streaming in Node.js
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic();
const stream = await client.messages.stream({
model: "claude-sonnet-4-6",
max_tokens: 1024,
messages: [{ role: "user", content: "Schrijf een kort verhaal over een robot." }],
});
for await (const chunk of stream) {
if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
process.stdout.write(chunk.delta.text);
}
}
const finalMessage = await stream.finalMessage();
console.log(`\nTokens: ${finalMessage.usage.output_tokens}`);Stap 6: System prompts en gespreksgeschiedenis
Een system prompt geeft Claude context over zijn rol, toon en beperkingen. Dit is hoe je Claude een persoonlijkheid of specifieke taakfocus geeft.
import anthropic
import os
client = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
# Klantenservice bot met system prompt
response = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=512,
system="""Je bent een vriendelijke klantenservice medewerker voor TechShop NL.
Regels:
- Beantwoord alleen vragen over onze producten en diensten
- Verwijs bij klachten altijd naar support@techshop.nl
- Spreek klanten aan met 'u'
- Geef beknopte, directe antwoorden (max 3 zinnen)
""",
messages=[
{"role": "user", "content": "Wanneer wordt mijn bestelling geleverd?"},
{"role": "assistant", "content": "Bestellingen worden doorgaans binnen 2-3 werkdagen geleverd. Heeft u een trackingnummer ontvangen?"},
{"role": "user", "content": "Nee, ik heb niets ontvangen."}
]
)
print(response.content[0].text)Stap 7: Tool Use (Function Calling)
Met Tool Use kan Claude externe functies aanroepen: denk aan een database query, een API call, of een berekening. Dit is de basis van agentic AI-toepassingen.
import anthropic
import json
import os
client = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
# Definieer een tool
tools = [
{
"name": "get_weather",
"description": "Haal het huidige weer op voor een bepaalde stad",
"input_schema": {
"type": "object",
"properties": {
"city": {
"type": "string",
"description": "De naam van de stad, bijv. Amsterdam"
}
},
"required": ["city"]
}
}
]
# Eerste aanroep: Claude beslist of het de tool wil gebruiken
response = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=1024,
tools=tools,
messages=[{"role": "user", "content": "Wat is het weer in Amsterdam?"}]
)
# Verwerk tool gebruik
if response.stop_reason == "tool_use":
tool_call = next(b for b in response.content if b.type == "tool_use")
city = tool_call.input["city"]
# Simuleer een weer-API aanroep
weer_data = {"city": city, "temperature": "12°C", "condition": "Bewolkt"}
# Stuur het resultaat terug naar Claude
eindresultaat = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=1024,
tools=tools,
messages=[
{"role": "user", "content": "Wat is het weer in Amsterdam?"},
{"role": "assistant", "content": response.content},
{
"role": "user",
"content": [{
"type": "tool_result",
"tool_use_id": tool_call.id,
"content": json.dumps(weer_data)
}]
}
]
)
print(eindresultaat.content[0].text)Stap 8: Van development naar productie
Een werkende demo is niet hetzelfde als een productiewaardige applicatie. Hier zijn de stappen om de stap te maken.
Environment variables beheren
Gebruik nooit hardcoded API keys. In productie gebruik je je cloud provider's secrets management:
# AWS Secrets Manager voorbeeld
import boto3
import json
def get_anthropic_key():
client = boto3.client("secretsmanager", region_name="eu-west-1")
response = client.get_secret_value(SecretId="prod/anthropic/api-key")
return json.loads(response["SecretString"])["ANTHROPIC_API_KEY"]
# Of simpel met python-dotenv voor kleinere projecten
from dotenv import load_dotenv
import os
load_dotenv() # Laadt .env bestand in development
api_key = os.environ.get("ANTHROPIC_API_KEY")GitHub Actions CI/CD pipeline
# .github/workflows/deploy.yml
name: Deploy naar productie
on:
push:
branches: [main]
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Setup Python
uses: actions/setup-python@v5
with:
python-version: "3.12"
- name: Installeer dependencies
run: pip install -r requirements.txt
- name: Run tests
env:
ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
run: pytest tests/
- name: Deploy naar server
env:
ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
run: |
echo "Deploy commando hier"
# bijv: flyctl deploy --remote-onlyRate limiting en kosten bewaken
import anthropic
import os
from dataclasses import dataclass
@dataclass
class GebruiksLogger:
totaal_input_tokens: int = 0
totaal_output_tokens: int = 0
def log_gebruik(self, response: anthropic.types.Message):
self.totaal_input_tokens += response.usage.input_tokens
self.totaal_output_tokens += response.usage.output_tokens
def geschatte_kosten(self) -> float:
# Claude Sonnet 4.6 prijzen (controleer console.anthropic.com voor actuele prijzen)
input_kosten = (self.totaal_input_tokens / 1_000_000) * 3.0 # $3 per 1M tokens
output_kosten = (self.totaal_output_tokens / 1_000_000) * 15.0 # $15 per 1M tokens
return input_kosten + output_kosten
logger = GebruiksLogger()
client = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
response = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=512,
messages=[{"role": "user", "content": "Samenvatting van AI in 2026?"}]
)
logger.log_gebruik(response)
print(f"Geschatte kosten: ${logger.geschatte_kosten():.4f}")Stap 9: Beveiliging in productie
De OWASP API Security Top 10 is ook van toepassing op AI API-integraties. De meest relevante risico's voor Claude-gebaseerde applicaties:
Prompt injection: gebruikers die via hun input proberen de system prompt te overschrijven. Mitigeer dit door gebruikersinput te valideren en de system prompt expliciet te scheiden van user input.
Datalekken: stuur nooit gevoelige data (BSN, wachtwoorden, creditcardnummers) naar de API. Implementeer input-sanitization voor je de API aanroept.
API key exposure: roteer keys regelmatig, gebruik separate keys per omgeving, en stel spending limits in via het Anthropic dashboard.
import re
def sanitize_user_input(tekst: str) -> str:
"""Verwijder potentieel gevaarlijke patterns uit gebruikersinput."""
# Verwijder BSN-achtige patronen (9 cijfers)
tekst = re.sub(r'\b\d{9}\b', '[VERWIJDERD]', tekst)
# Verwijder IBAN patronen
tekst = re.sub(r'\b[A-Z]{2}\d{2}[A-Z0-9]{4}\d{7}([A-Z0-9]?){0,16}\b', '[VERWIJDERD]', tekst)
# Begrens de lengte (voorkom token-bombing)
if len(tekst) > 10_000:
tekst = tekst[:10_000] + "... [afgekapt]"
return tekst
# Gebruik altijd voor je naar de API stuurt:
schone_input = sanitize_user_input(user_message)Stap 10: Monitoring en observability
In productie wil je weten: hoeveel API-aanroepen doe je, wat is de gemiddelde latency, en waar gaat het mis?
Voor basismonitoring kun je de Anthropic Usage-pagina gebruiken in het dashboard. Voor geavanceerdere monitoring integreer je met tools als Datadog, New Relic, of open-source alternatieven als Prometheus + Grafana.
Zorg minimaal voor logging van: aanroeptijdstip, model gebruikt, tokens in/out, latency in ms, eventuele fouten, en user/session ID voor tracing.
Handige resources en video tutorials
Officiële Anthropic documentatie: docs.anthropic.com: bevat de volledige API reference, migratiegidsen en best practices.
Anthropic Cookbook op GitHub (github.com/anthropics/anthropic-cookbook): praktische codevoorbeelden voor tool use, RAG, multimodal, en meer.
Video tutorial: 'Claude API Full Course' op YouTube (youtube.com/watch?v=A4vB0poh8mM): behandelt setup tot geavanceerde features in 45 minuten.
Anthropic Academy: anthropic.com/learn: gratis cursussen over prompt engineering en API-gebruik, inclusief certificering.
Community: het Anthropic Discord-kanaal voor developer vragen, en de Reddit community r/ClaudeAI voor praktijkvragen.
Productie-checklist
Gebruik deze checklist voordat je live gaat:
[ ] API key staat in omgevingsvariabele, nooit in code. [ ] Separate keys voor dev, staging en productie. [ ] Retry-logica met exponential backoff geimplementeerd. [ ] Maximale inputlengte begrensd (voorkom token-bombing). [ ] Gevoelige data wordt gesanitized voor API-aanroep. [ ] Gebruikskosten worden gemonitord via dashboard of eigen logging. [ ] Streaming ingeschakeld voor gebruikersinterfaces. [ ] Foutmeldingen zijn gebruiksvriendelijk (geen raw API errors tonen). [ ] Rate limit headers worden uitgelezen en gerespecteerd. [ ] Model keuze is bewust gedaan (Sonnet voor meeste taken, niet altijd Opus).
Conclusie
De Claude API is in 2026 volwassen genoeg voor serieuze productietoepassingen. De SDK's zijn stabiel, de documentatie is uitstekend, en de modellen zijn krachtig genoeg voor een breed scala aan taken.
Begin klein: schrijf je eerste aanroep, test foutafhandeling, en bouw van daaruit op. De stap van demo naar productie zit hem in de details: keys veilig opslaan, retry-logica, monitoring, en kostenbeheersing.
Heb je vragen of loop je ergens tegenaan? Bekijk de officiële docs op docs.anthropic.com of stel je vraag in de Anthropic developer community.
