---
title: Python SDK
url: https://platform.claude.com/docs/de/cli-sdks-libraries/sdks/python
description: Installiere und konfiguriere das Anthropic Python SDK mit Unterstützung für synchrone und asynchrone Clients
---

Das Anthropic Python SDK bietet bequemen Zugriff auf die Claude API aus Python-Anwendungen. Es unterstützt sowohl synchrone als auch asynchrone Operationen, „streaming" (Streaming) sowie Integrationen mit Amazon Bedrock, Claude Platform on AWS, Claude Models on Google Cloud (Anthropic managed), Claude Models on Google Cloud (Google managed) und Microsoft Foundry.

<Info>
  Eine Dokumentation der API-Funktionen mit Codebeispielen findest du in der [API-Referenz](https://platform.claude.com/docs/de/api/overview). Diese Seite behandelt Python-spezifische SDK-Funktionen und -Konfiguration.
</Info>

## Installation

```bash
pip install anthropic
```

Für plattformspezifische Integrationen oder eine verbesserte asynchrone Leistung installiere mit Extras:

```bash
# Für Unterstützung von Amazon Bedrock
pip install "anthropic[bedrock]"

# Für Unterstützung von Google Cloud
pip install "anthropic[vertex]"

# Für Unterstützung von Claude Platform on AWS
pip install "anthropic[aws]"

# Unterstützung für Microsoft Foundry ist im Basispaket enthalten

# Für bessere Async-Performance mit aiohttp
pip install "anthropic[aiohttp]"
```

Um Claude Models on Google Cloud (Anthropic managed) zu verwenden, führe `pip install "anthropic[google_cloud]"` aus.

## Anforderungen

Python 3.10 oder höher ist erforderlich. Wenn du von einer 0.x-Version des SDK aktualisierst, findest du im [v1-Migrationsleitfaden](https://github.com/anthropics/anthropic-sdk-python/blob/main/MIGRATION.md) die Liste der Breaking Changes.

## Verwendung

```python
import os
from anthropic import Anthropic

client = Anthropic(
    # Dies ist der Standardwert und kann weggelassen werden
    api_key=os.environ.get("ANTHROPIC_API_KEY"),
)

message = client.messages.create(
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Hello, Claude",
        }
    ],
    model="claude-opus-5-5",
)

for block in message.content:
    if block.type == "text":
        print(block.text)
```

<Tip>
  Erwäge, [python-dotenv](https://pypi.org/project/python-dotenv/) zu verwenden, um `ANTHROPIC_API_KEY="my-anthropic-api-key"` zu deiner `.env`-Datei hinzuzufügen, damit dein „API key" (API-Key) nicht in der Versionskontrolle gespeichert wird.
</Tip>

Informationen zu Authentifizierungsoptionen, einschließlich Workload Identity Federation, findest du unter [Authentifizierung](https://platform.claude.com/docs/de/manage-claude/authentication). Wenn dein API-Key ein [persönlicher Key oder Service-Account-Key](https://platform.claude.com/docs/de/manage-claude/authentication#key-types) ist, der nicht auf einen Workspace beschränkt ist, setze die Workspace-ID im Request-Header `anthropic-workspace-id`; [Einen Workspace auswählen](https://platform.claude.com/docs/de/manage-claude/authentication#select-a-workspace) zeigt die Option pro Anfrage für dieses SDK.

## Asynchrone Verwendung

```python
import os
import asyncio
from anthropic import AsyncAnthropic

client = AsyncAnthropic(
    api_key=os.environ.get("ANTHROPIC_API_KEY"),
)


async def main() -> None:
    message = await client.messages.create(
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": "Hello, Claude",
            }
        ],
        model="claude-opus-5-5",
    )
    print(message.content)


asyncio.run(main())
```

### aiohttp für bessere Nebenläufigkeit verwenden

Für eine verbesserte asynchrone Leistung kannst du anstelle des standardmäßigen `httpx2` das HTTP-Backend `aiohttp` verwenden:

```python
import os
import asyncio
from anthropic import AsyncAnthropic, DefaultAioHttpClient


async def main() -> None:
    async with AsyncAnthropic(
        api_key=os.environ.get("ANTHROPIC_API_KEY"),
        http_client=DefaultAioHttpClient(),
    ) as client:
        message = await client.messages.create(
            max_tokens=1024,
            messages=[
                {
                    "role": "user",
                    "content": "Hello, Claude",
                }
            ],
            model="claude-opus-5-5",
        )
        print(message.content)


asyncio.run(main())
```

## Streaming-Antworten

Das SDK bietet Unterstützung für Streaming-Antworten mithilfe von Server-Sent Events (SSE).

```python
client = Anthropic()

stream = client.messages.create(
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Hello, Claude",
        }
    ],
    model="claude-opus-5-5",
    stream=True,
)
for event in stream:
    print(event.type)
```

Der asynchrone Client verwendet genau dieselbe Schnittstelle:

```python
client = AsyncAnthropic()

stream = await client.messages.create(
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Hello, Claude",
        }
    ],
    model="claude-opus-5-5",
    stream=True,
)
async for event in stream:
    print(event.type)
```

### Streaming-Helfer

Das SDK bietet außerdem Streaming-Helfer, die Kontextmanager verwenden und Zugriff auf den akkumulierten Text und die finale Nachricht bieten:

```python
async def main() -> None:
    async with client.messages.stream(
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": "Say hello there!",
            }
        ],
        model="claude-opus-5-5",
    ) as stream:
        async for text in stream.text_stream:
            print(text, end="", flush=True)
        print()

        message = await stream.get_final_message()
        print(message.to_json())


asyncio.run(main())
```

Streaming mit `client.messages.stream(...)` stellt verschiedene Helfer bereit, einschließlich Akkumulation und SDK-spezifischer Events.

Alternativ kannst du `client.messages.create(..., stream=True)` verwenden, das nur ein Iterable der Events im Stream zurückgibt und weniger Speicher verbraucht (es baut kein finales Nachrichtenobjekt für dich auf).

## Token-Zählung

Du kannst die genaue Nutzung für eine bestimmte Anfrage über die Antworteigenschaft `usage` einsehen:

```python
message = client.messages.create(...)
print(message.usage)
# Usage(input_tokens=25, output_tokens=13)
```

Du kannst Token auch zählen, bevor du eine Anfrage stellst:

```python
count = client.messages.count_tokens(
    model="claude-opus-5-5",
    messages=[{"role": "user", "content": "Hello, world"}],
)
print(count.input_tokens)  # 10
```

## Tool-Nutzung

Dieses SDK bietet Unterstützung für „tool use" (Tool-Nutzung), auch bekannt als Function Calling. Weitere Details findest du unter [Tool-Nutzung mit Claude](https://platform.claude.com/docs/de/agents-and-tools/tool-use/overview).

### Tool-Helfer

Das SDK bietet Helfer zum Definieren und Ausführen von Tools als reine Python-Funktionen. Der Decorator `@beta_tool` generiert das Tool-Schema aus der Funktionssignatur und dem Docstring:

```python
import json
from anthropic import Anthropic, beta_tool

client = Anthropic()


@beta_tool
def get_weather(location: str) -> str:
    """Get the weather for a given location.

    Args:
        location: The city and state, for example, San Francisco, CA
    Returns:
        A JSON-encoded string with the location, temperature, and weather condition.
    """
    return json.dumps(
        {
            "location": location,
            "temperature": "68°F",
            "condition": "Sunny",
        }
    )


# Verwende den tool_runner, um Tool-Aufrufe automatisch zu verarbeiten
runner = client.beta.messages.tool_runner(
    max_tokens=1024,
    model="claude-opus-5-5",
    tools=[get_weather],
    messages=[
        {"role": "user", "content": "What is the weather in SF?"},
    ],
)
for message in runner:
    print(message)
```

Bei jeder Iteration wird eine API-Anfrage gestellt. Wenn die Antwort einen Aufruf eines der angegebenen Tools enthält, wird das Tool automatisch aufgerufen und das Ergebnis in der nächsten Iteration direkt an das Modell zurückgegeben.

Um das Browser-Use-Tool oder das Computer-Use-Tool mit diesem SDK auszuführen, siehe [Browser- und Computer-Use mit den SDK-Toolsets](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-sdk).

## Message Batches

Dieses SDK bietet Unterstützung für [Batch-Verarbeitung](https://platform.claude.com/docs/de/build-with-claude/batch-processing) unter `client.messages.batches`.

### Einen Batch erstellen

Message Batches nimmt ein Array von Anfragen entgegen, wobei jedes Objekt einen `custom_id`-Bezeichner und dieselben Anfrage-`params` wie die Standard-Messages-API hat:

```python
client.messages.batches.create(
    requests=[
        {
            "custom_id": "my-first-request",
            "params": {
                "model": "claude-opus-5-5",
                "max_tokens": 1024,
                "messages": [{"role": "user", "content": "Hello, world"}],
            },
        },
        {
            "custom_id": "my-second-request",
            "params": {
                "model": "claude-opus-5-5",
                "max_tokens": 1024,
                "messages": [{"role": "user", "content": "Hi again, friend"}],
            },
        },
    ]
)
```

### Ergebnisse aus einem Batch abrufen

Sobald ein Message Batch verarbeitet wurde, angezeigt durch `.processing_status == 'ended'`, kannst du mit `.batches.results()` auf die Ergebnisse zugreifen:

```python
client = anthropic.Anthropic()
batch_id = "batch_abc123"
result_stream = client.messages.batches.results(batch_id)
for entry in result_stream:
    if entry.result.type == "succeeded":
        print(entry.result.message.content)
```

## Datei-Uploads

Anfrageparameter, die Datei-Uploads entsprechen, können in vielen verschiedenen Formen übergeben werden:

* Ein `PathLike`-Objekt (zum Beispiel `pathlib.Path`)
* Ein Tupel aus `(filename, content, content_type)`
* Ein dateiähnliches `BinaryIO`-Objekt

```python
from pathlib import Path
from anthropic import Anthropic

client = Anthropic()

# Hochladen über einen Dateipfad
client.files.upload(
    file=Path("/path/to/file"),
)

# Hochladen über Bytes
client.files.upload(
    file=("file.txt", b"my bytes", "text/plain"),
)
```

Der asynchrone Client verwendet genau dieselbe Schnittstelle. Wenn du eine `PathLike`-Instanz übergibst, wird der Dateiinhalt automatisch asynchron gelesen.

## Fehlerbehandlung

Wenn die Bibliothek keine Verbindung zur API herstellen kann oder die API einen Statuscode zurückgibt, der keinen Erfolg anzeigt (also eine 4xx- oder 5xx-Antwort), wird eine Unterklasse von `APIError` ausgelöst:

```python
import anthropic
# ...
try:
    message = client.messages.create(
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": "Hello, Claude",
            }
        ],
        model="claude-opus-5-5",
    )
except anthropic.APIConnectionError as e:
    print("The server could not be reached")
    print(e.__cause__)  # an underlying Exception, likely raised within httpx2
except anthropic.RateLimitError as e:
    print("A 429 status code was received; we should back off a bit.")
except anthropic.APIStatusError as e:
    print("Another non-200-range status code was received")
    print(e.status_code)
    print(e.response)
```

Die Fehlercodes lauten wie folgt:

| Statuscode | Fehlertyp                  |
| ---------- | -------------------------- |
| 400        | `BadRequestError`          |
| 401        | `AuthenticationError`      |
| 403        | `PermissionDeniedError`    |
| 404        | `NotFoundError`            |
| 409        | `ConflictError`            |
| 422        | `UnprocessableEntityError` |
| 429        | `RateLimitError`           |
| >=500      | `InternalServerError`      |
| N/A        | `APIConnectionError`       |

## Request-IDs

> Weitere Informationen zum Debuggen von Anfragen findest du unter [Request-ID](https://platform.claude.com/docs/de/api/errors#request-id).

Alle Objektantworten im SDK stellen eine `_request_id`-Eigenschaft bereit, die aus dem Antwort-Header `request-id` übernommen wird, damit du fehlgeschlagene Anfragen schnell protokollieren und an Anthropic melden kannst.

```python
message = client.messages.create(
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    model="claude-opus-5-5",
)
print(message._request_id)  # e.g., req_018EeWyXxfu5pfWkrYcMdjWG
```

<Note>
  Im Gegensatz zu anderen Eigenschaften mit dem Präfix `_` ist die Eigenschaft `_request_id` öffentlich. Sofern nicht anders dokumentiert, sind alle anderen Eigenschaften, Methoden und Module mit dem Präfix `_` privat.
</Note>

## Wiederholungsversuche

Bestimmte Fehler werden standardmäßig automatisch 2-mal mit einem kurzen exponentiellen Backoff wiederholt. Verbindungsfehler (zum Beispiel aufgrund eines Netzwerkverbindungsproblems), 408 Request Timeout, 409 Conflict, 429 Rate Limit und >=500 Internal Errors werden standardmäßig alle wiederholt.

Du kannst die Option `max_retries` verwenden, um dies zu konfigurieren oder zu deaktivieren:

```python
# Konfiguriere den Standard für alle Anfragen:
client = Anthropic(
    max_retries=0,  # default is 2
)

# Oder konfiguriere es pro Anfrage:
client.with_options(max_retries=5).messages.create(
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    model="claude-opus-5-5",
)
```

## Timeouts

Standardmäßig laufen Anfragen nach 10 Minuten in ein Timeout. Du kannst dies mit einer `timeout`-Option konfigurieren, die einen Float oder ein `httpx2.Timeout`-Objekt akzeptiert:

```python
import httpx2
from anthropic import Anthropic

# Standard für alle Anfragen konfigurieren:
client = Anthropic(
    timeout=20.0,  # 20 seconds (default is 10 minutes)
)

# Feinere Steuerung:
client = Anthropic(
    timeout=httpx2.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
)

# Pro Anfrage überschreiben:
client.with_options(timeout=5.0).messages.create(
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    model="claude-opus-5-5",
)
```

Bei einem Timeout wirft das SDK einen `APITimeoutError`.

Beachte, dass Anfragen, die in ein Timeout laufen, [standardmäßig zweimal wiederholt werden](https://platform.claude.com/docs/de/cli-sdks-libraries/sdks/python#retries).

## Lange Anfragen

<Warning>
  Erwäge, für länger laufende Anfragen die Streaming-[Messages API](https://platform.claude.com/docs/de/cli-sdks-libraries/sdks/python#streaming-responses) zu verwenden.
</Warning>

Vermeide es, einen großen `max_tokens`-Wert festzulegen, ohne Streaming zu verwenden. Einige Netzwerke trennen inaktive Verbindungen möglicherweise nach einer bestimmten Zeit, was dazu führen kann, dass die Anfrage fehlschlägt oder [in ein Timeout läuft](https://platform.claude.com/docs/de/cli-sdks-libraries/sdks/python#timeouts), ohne eine Antwort von Anthropic zu erhalten.

Das SDK wirft einen `ValueError`, wenn erwartet wird, dass eine Nicht-Streaming-Anfrage länger als etwa 10 Minuten dauert. Das Übergeben von `stream=True` oder das Überschreiben der `timeout`-Option auf Client- oder Anfrageebene deaktiviert diesen Fehler.

Eine erwartete Anfragelatenz, die länger als das [Timeout](https://platform.claude.com/docs/de/cli-sdks-libraries/sdks/python#timeouts) für eine Nicht-Streaming-Anfrage ist, führt dazu, dass der Client die Verbindung beendet und es erneut versucht, ohne eine Antwort zu erhalten.

Das SDK setzt eine [TCP-Socket-Keep-Alive](https://tldp.org/HOWTO/TCP-Keepalive-HOWTO/overview.html)-Option, um die Auswirkungen von Timeouts inaktiver Verbindungen in einigen Netzwerken zu verringern. Dies kann überschrieben werden, indem du dem Client eine benutzerdefinierte `http_client`-Option übergibst.

## Automatische Paginierung

Listenmethoden in der Claude API sind paginiert. Du kannst die `for`-Syntax verwenden, um über Elemente aller Seiten zu iterieren:

```python
client = Anthropic()

all_batches = []
# Ruft bei Bedarf automatisch weitere Seiten ab.
for batch in client.messages.batches.list(limit=20):
    all_batches.append(batch)
print(all_batches)
```

Für asynchrone Iteration:

```python
async def main() -> None:
    all_batches = []
    async for batch in client.messages.batches.list(limit=20):
        all_batches.append(batch)
    print(all_batches)


asyncio.run(main())
```

Alternativ kannst du die Methoden `.has_next_page()`, `.next_page_info()` oder `.get_next_page()` für eine feinere Kontrolle bei der Arbeit mit Seiten verwenden:

```python
first_page = await client.messages.batches.list(limit=20)

if first_page.has_next_page():
    print(f"will fetch next page using these details: {first_page.next_page_info()}")
    next_page = await first_page.get_next_page()
    print(f"number of items we just fetched: {len(next_page.data)}")

# Entferne `await` bei nicht-asynchroner Verwendung.
```

Oder arbeite direkt mit den zurückgegebenen Daten:

```python
first_page = await client.messages.batches.list(limit=20)

print(f"next page cursor: {first_page.last_id}")
for batch in first_page.data:
    print(batch.id)

# Entferne `await` für nicht-asynchrone Verwendung.
```

## Standard-Header

Das SDK sendet automatisch den Header `anthropic-version`, gesetzt auf die API-Version für diese Hauptversion des SDK (siehe [Semantische Versionierung](https://platform.claude.com/docs/de/cli-sdks-libraries/sdks/python#semantic-versioning)).

Bei Bedarf kannst du ihn überschreiben, indem du Standard-Header auf dem Client-Objekt oder pro Anfrage festlegst.

<Warning>
  Das Überschreiben von Standard-Headern kann zu falschen Typen und anderem unerwartetem oder undefiniertem Verhalten im SDK führen.
</Warning>

```python
# Lege Standard-Header für alle Requests auf dem Client fest
client = Anthropic(
    default_headers={"anthropic-version": "My-Custom-Value"},
)

# Oder überschreibe sie pro Request
client.messages.with_raw_response.create(
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    model="claude-opus-5-5",
    extra_headers={"anthropic-version": "My-Custom-Value"},
)
```

## Typsystem

### Anfrageparameter

Verschachtelte Anfrageparameter sind [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Antworten sind [Pydantic-Modelle](https://docs.pydantic.dev), die auch Hilfsmethoden für Dinge wie die Serialisierung zurück in JSON haben ([`v1`](https://docs.pydantic.dev/1.10/usage/models/), [`v2`](https://docs.pydantic.dev/latest/concepts/serialization/)).

Typisierte Anfragen und Antworten bieten Autovervollständigung und Dokumentation in deinem Editor. Wenn du Typfehler in VS Code sehen möchtest, um Bugs früher zu erkennen, setze `python.analysis.typeCheckingMode` auf `basic`.

### Antwortmodelle

Um ein Pydantic-Modell in ein Dictionary umzuwandeln, verwende die Hilfsmethoden:

```python
message = client.messages.create(...)

# In JSON-String umwandeln
json_str = message.to_json()

# In Dictionary umwandeln
data = message.to_dict()
```

### Umgang mit null vs. fehlenden Feldern

In Antworten kannst du zwischen Feldern unterscheiden, die explizit `null` sind, und Feldern, die nicht zurückgegeben wurden (fehlend):

```python
response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello"}],
)
if response.my_field is None:
    if "my_field" not in response.model_fields_set:
        print("field was not in the response")
    else:
        print("field was null")
```

## Erweiterte Verwendung

### Zugriff auf Rohdaten der Antwort (zum Beispiel Header)

Auf die von `httpx2` zurückgegebene „rohe" `Response` kann über die Eigenschaft `.with_raw_response` auf dem Client zugegriffen werden. Dies ist nützlich, um auf Antwort-Header oder andere Metadaten zuzugreifen:

```python
client = Anthropic()

response = client.messages.with_raw_response.create(
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    model="claude-opus-5-5",
)

print(response.headers.get("request-id"))
message = (
    response.parse()
)  # get the object that `messages.create()` would have returned
print(message.content)
```

Diese Methoden geben ein `APIResponse`-Objekt zurück. Auf dem asynchronen Client geben sie eine `AsyncAPIResponse` zurück, und `.parse()`, `.read()`, `.text()` und `.json()` müssen mit await aufgerufen werden.

### Streaming des Antwort-Bodys

Der Ansatz mit `.with_raw_response` liest den vollständigen Antwort-Body sofort, wenn du die Anfrage stellst. Um den Antwort-Body stattdessen zu streamen, verwende `.with_streaming_response`, das einen Kontextmanager erfordert und den Antwort-Body erst liest, wenn du `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` oder `.parse()` aufrufst. Im asynchronen Client sind dies asynchrone Methoden.

```python
with client.messages.with_streaming_response.create(
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    model="claude-opus-5-5",
) as response:
    print(response.headers.get("request-id"))

    for line in response.iter_lines():
        print(line)
```

Der Kontextmanager ist erforderlich, damit die Antwort zuverlässig geschlossen wird.

### Logging

Das SDK verwendet das Modul `logging` der Standardbibliothek.

Du kannst das Logging aktivieren, indem du die Umgebungsvariable `ANTHROPIC_LOG` auf `debug` oder `info` setzt:

```bash
export ANTHROPIC_LOG=debug
```

### OpenTelemetry-Tracing

Wenn deine Anwendung einen OpenTelemetry Tracer Provider registriert, gibt das SDK für jede Anfrage, die es sendet, einen Span aus. Um die Spans an deine Observability-Plattform zu senden, siehe [OpenTelemetry mit dem Claude SDK einrichten](https://platform.claude.com/docs/de/manage-claude/opentelemetry/sdk).

### Benutzerdefinierte/undokumentierte Anfragen stellen

Diese Bibliothek ist für den bequemen Zugriff auf die dokumentierte API typisiert. Wenn du auf undokumentierte Endpunkte, Parameter oder Antworteigenschaften zugreifen musst, kann die Bibliothek trotzdem verwendet werden.

#### Undokumentierte Endpunkte

Um Anfragen an undokumentierte Endpunkte zu stellen, kannst du `client.get`, `client.post` und andere HTTP-Verben verwenden. Optionen auf dem Client, wie z. B. Wiederholungsversuche, werden bei diesen Anfragen berücksichtigt.

```python
import httpx2

response = client.post(
    "/foo",
    cast_to=httpx2.Response,
    body={"my_param": True},
)

print(response.json())
```

#### Undokumentierte Anfrageparameter

Wenn du explizit einen zusätzlichen Parameter senden möchtest, kannst du dies mit den Anfrageoptionen `extra_query`, `extra_body` und `extra_headers` tun.

<Warning>
  Die `extra_`-Parameter überschreiben dokumentierte Parameter mit demselben Namen. Stelle aus Sicherheitsgründen sicher, dass diese Methoden nur mit vertrauenswürdigen Eingabedaten verwendet werden.
</Warning>

#### Undokumentierte Antworteigenschaften

Um auf undokumentierte Antworteigenschaften zuzugreifen, kannst du auf die zusätzlichen Felder wie `response.unknown_prop` zugreifen. Du kannst auch alle zusätzlichen Felder des Pydantic-Modells als Dict mit `response.model_extra` abrufen.

### Den HTTP-Client konfigurieren

Das SDK sendet Anfragen mit [httpx2](https://httpx2.pydantic.dev), einem API-kompatiblen Fork von `httpx`. Um den HTTP-Client anzupassen, einschließlich Proxys und Transports, übergib deinen eigenen [httpx2-Client](https://httpx2.pydantic.dev/api/#client) als `http_client`:

```python
import httpx2
from anthropic import Anthropic, DefaultHttpxClient

client = Anthropic(
    # Oder verwende die Umgebungsvariable `ANTHROPIC_BASE_URL`
    base_url="http://my.test.server.example.com:8083",
    http_client=DefaultHttpxClient(
        proxy="http://my.test.proxy.example.com",
        transport=httpx2.HTTPTransport(local_address="0.0.0.0"),
    ),
)
```

Du kannst den Client auch pro Anfrage mit `with_options()` anpassen:

```python
client.with_options(http_client=DefaultHttpxClient(...))
```

<Note>
  Verwende `DefaultHttpxClient` und `DefaultAsyncHttpxClient` anstelle von rohem `httpx2.Client` und `httpx2.AsyncClient`, um sicherzustellen, dass die Standardkonfiguration des SDK (wie Timeouts und Verbindungslimits) erhalten bleibt. Das Argument `http_client` muss ein `httpx2`-Client sein. Das Übergeben eines Clients aus dem separaten `httpx`-Paket löst einen `TypeError` aus.
</Note>

Tracing- und Mocking-Tools, die `httpx` selbst patchen, wie OpenTelemetrys `HTTPXClientInstrumentor`, Sentrys `httpx`-Integration, `respx` oder `pytest-httpx`, sehen die Anfragen des SDK standardmäßig nicht. Um sie zu verwenden, rufe `httpx2.alias_httpx()` einmal beim Start auf, bevor irgendetwas `httpx` importiert. Dadurch wird `import httpx` für den gesamten Prozess zu `httpx2` aufgelöst.

### HTTP-Ressourcen verwalten

Standardmäßig schließt die Bibliothek die zugrunde liegenden HTTP-Verbindungen, sobald der Client [vom Garbage Collector bereinigt](https://docs.python.org/3/reference/datamodel.html#object.__del__) wird. Du kannst den Client bei Bedarf manuell mit der Methode `.close()` schließen oder mit einem Kontextmanager, der beim Verlassen schließt.

```python
with Anthropic() as client:
    message = client.messages.create(...)

# HTTP-Client wird automatisch geschlossen
```

## Beta-Funktionen

Beta-Funktionen sind vor der allgemeinen Veröffentlichung verfügbar, um frühzeitig Feedback zu erhalten und neue Funktionalität zu testen. Du kannst die Verfügbarkeit aller Fähigkeiten und Tools von Claude in der [Funktionsübersicht](https://platform.claude.com/docs/de/build-with-claude/overview) überprüfen.

Du kannst auf die meisten Beta-API-Funktionen über die Eigenschaft `beta` des Clients zugreifen. Um eine bestimmte Beta-Funktion zu aktivieren, musst du beim Erstellen einer Nachricht den entsprechenden [Beta-Header](https://platform.claude.com/docs/de/api/beta-headers) zum Feld `betas` hinzufügen.

Zum Beispiel, um [Context Editing](https://platform.claude.com/docs/de/build-with-claude/context-editing) zu aktivieren:

```python
client = Anthropic()

response = client.beta.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    betas=["context-management-2025-06-27"],
)
```

## Plattformintegrationen

<Note>
  Detaillierte Anleitungen zur Plattformeinrichtung mit Codebeispielen findest du unter:

  * [Amazon Bedrock](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock)
  * [Amazon Bedrock (Opus 4.6 und früher)](https://platform.claude.com/docs/de/build-with-claude/claude-on-amazon-bedrock-legacy)
  * [Claude Platform on AWS](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws)
  * [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/google-managed)
  * [Microsoft Foundry](https://platform.claude.com/docs/de/build-with-claude/claude-in-microsoft-foundry)

  Siehe auch [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed).
</Note>

Alle sechs Client-Klassen sind im Basispaket `anthropic` enthalten:

| Anbieter                                          | Client                                         | Zusätzliche Abhängigkeiten              |
| ------------------------------------------------- | ---------------------------------------------- | --------------------------------------- |
| Agent Platform                                    | `from anthropic import AnthropicVertex`        | `pip install "anthropic[vertex]"`       |
| Bedrock                                           | `from anthropic import AnthropicBedrockMantle` | `pip install "anthropic[bedrock]"`      |
| Bedrock (`bedrock-runtime`-Pfad)                  | `from anthropic import AnthropicBedrock`       | `pip install "anthropic[bedrock]"`      |
| Claude Platform on AWS                            | `from anthropic import AnthropicAWS`           | `pip install "anthropic[aws]"`          |
| Claude Models on Google Cloud (Anthropic managed) | `from anthropic import AnthropicGoogleCloud`   | `pip install "anthropic[google_cloud]"` |
| Foundry                                           | `from anthropic import AnthropicFoundry`       | Keine                                   |

Der `AnthropicAWS`-Client befindet sich in der Beta-Phase. Übergib `workspace_id` an den Konstruktor oder setze die Umgebungsvariable `ANTHROPIC_AWS_WORKSPACE_ID`. Der `AnthropicGoogleCloud`-Client befindet sich ebenfalls in der Beta-Phase. Übergib `workspace_id` an den Konstruktor oder setze die Umgebungsvariable `ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID`. Unter [Auflösung von Projekt, Standort und Workspace](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution) erfährst du, wie der Client die Workspace-ID auflöst.

Verwende `AnthropicBedrockMantle` für neue Projekte; `AnthropicBedrock` bleibt für bestehende Anwendungen erhalten, die die Bedrock-`InvokeModel`-API verwenden.

## Semantische Versionierung

Jede Hauptversion dieses SDK sendet standardmäßig eine API-Version im Header `anthropic-version`, und mit jeder neuen API-Version kommt eine neue Hauptversion. Die erste Hauptversion, die `2026-10-21` sendet, ist 2.0.0; siehe [Migration zur API-Version 2026-10-21](https://platform.claude.com/docs/de/api/migration-2026-10-21#upgrade).

Dieses Paket folgt im Allgemeinen den [SemVer](https://semver.org/spec/v2.0.0.html)-Konventionen, wobei bestimmte abwärtsinkompatible Änderungen als Minor-Versionen veröffentlicht werden können:

1. Änderungen, die nur statische Typen betreffen, ohne das Laufzeitverhalten zu beeinträchtigen.
2. Änderungen an Interna der Bibliothek, die technisch öffentlich sind, aber nicht für die externe Verwendung vorgesehen oder dokumentiert sind.
3. Änderungen, von denen nicht erwartet wird, dass sie sich in der Praxis auf die überwiegende Mehrheit der Benutzer auswirken.

### Die installierte Version ermitteln

Wenn du auf die neueste Version aktualisiert hast, aber die erwarteten neuen Funktionen nicht siehst, verwendet deine Python-Umgebung wahrscheinlich noch eine ältere Version. Du kannst die zur Laufzeit verwendete Version wie folgt ermitteln:

```python
print(anthropic.__version__)
```

## Zusätzliche Ressourcen

* [GitHub-Repository](https://github.com/anthropics/anthropic-sdk-python)
* [API-Referenz](https://platform.claude.com/docs/de/api/overview)
* [Streaming Messages](https://platform.claude.com/docs/de/build-with-claude/streaming)
* [Tool-Nutzung mit Claude](https://platform.claude.com/docs/de/agents-and-tools/tool-use/overview)