De complete gids voor de Claude API: van setup tot productie

# 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-xxxxxxxxxxxx

pip install anthropic
# Of met uv (aanbevolen voor reproduceerbare omgevingen):
uv add anthropic

import anthropic
import os

client = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))

message = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Leg uit wat een REST API is in twee zinnen."}
    ]
)

print(message.content[0].text)

npm install @anthropic-ai/sdk
# Of met yarn:
yarn add @anthropic-ai/sdk

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-5",
  max_tokens: 1024,
  messages: [
    { role: "user", content: "Leg uit wat een REST API is in twee zinnen." }
  ],
});

console.log(message.content[0].text);

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-5",
    "max_tokens": 1024,
    "messages": [
      {"role": "user", "content": "Hallo Claude, werkt dit?"}
    ]
  }'

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-5",
                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)

import anthropic
import os

client = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))

with client.messages.stream(
    model="claude-sonnet-5",
    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}")

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const stream = await client.messages.stream({
  model: "claude-sonnet-5",
  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}`);

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-5",
    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)

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-5",
    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-5",
        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)

# 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/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-only

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:
        # Sonnet-tier: check console.anthropic.com. Vorige generatie Sonnet 4.6 stond op $3 / $15 per 1M.
        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-5",
    max_tokens=512,
    messages=[{"role": "user", "content": "Samenvatting van AI in 2026?"}]
)
logger.log_gebruik(response)
print(f"Geschatte kosten: ${logger.geschatte_kosten():.4f}")

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)