--- title: C# SDK url: https://platform.claude.com/docs/de/cli-sdks-libraries/sdks/csharp description: Installiere und konfiguriere das Anthropic C# SDK für .NET-Anwendungen mit IChatClient-Integration --- Das Anthropic C# SDK bietet bequemen Zugriff auf die Claude API aus Anwendungen, die in C# geschrieben sind. Eine Dokumentation der API-Funktionen mit Codebeispielen findest du in der [API-Referenz](https://platform.claude.com/docs/de/api/overview). Diese Seite behandelt C#-spezifische SDK-Funktionen und die Konfiguration. Ab Version 10+ ist das Paket `Anthropic` das offizielle Anthropic SDK für C#. Die Paketversionen 3.X und darunter wurden zuvor für das von der tryAGI-Community entwickelte SDK verwendet, das nach [`tryAGI.Anthropic`](https://www.nuget.org/packages/tryagi.Anthropic/) umgezogen ist. Wenn du den früheren Client in deinem Projekt weiterhin verwenden musst, aktualisiere deine Paketreferenz auf `tryAGI.Anthropic`. ## Installation Installiere das Paket von [NuGet](https://www.nuget.org/packages/Anthropic): ```bash dotnet add package Anthropic ``` ## Anforderungen Diese Bibliothek erfordert .NET Standard 2.0 oder höher. ## Verwendung ```csharp using System; using Anthropic; using Anthropic.Models.Messages; AnthropicClient client = new(); MessageCreateParams parameters = new() { MaxTokens = 1024, Messages = [new UserMessageParam { Content = "Hello, Claude" }], Model = Model.ClaudeOpus5_5, }; var message = await client.Messages.Create(parameters); foreach (var block in message.Content) { if (block.TryPickText(out var textBlock)) { Console.WriteLine(textBlock.Text); } } ``` 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. ## Client-Konfiguration Konfiguriere den Client über Umgebungsvariablen: ```csharp using Anthropic; // Konfiguriert über die Umgebungsvariablen ANTHROPIC_API_KEY, ANTHROPIC_AUTH_TOKEN und ANTHROPIC_BASE_URL AnthropicClient client = new(); ``` Oder manuell: ```csharp using Anthropic; AnthropicClient client = new() { ApiKey = "my-anthropic-api-key" }; ``` Oder mit einer Kombination beider Ansätze. In dieser Tabelle findest du die verfügbaren Optionen: | Eigenschaft | Umgebungsvariable | Erforderlich | Standardwert | | ----------- | ---------------------- | ------------ | ----------------------------- | | `ApiKey` | `ANTHROPIC_API_KEY` | false | - | | `AuthToken` | `ANTHROPIC_AUTH_TOKEN` | false | - | | `BaseUrl` | `ANTHROPIC_BASE_URL` | true | `"https://api.anthropic.com"` | ### Konfiguration ändern Um vorübergehend eine geänderte Client-Konfiguration zu verwenden und dabei dieselben Verbindungs- und Thread-Pools wiederzuverwenden, rufe `WithOptions` auf einem beliebigen Client oder Service auf: ```csharp using System; var message = await client .WithOptions(options => options with { BaseUrl = "https://example.com", Timeout = TimeSpan.FromSeconds(42), } ) .Messages.Create(parameters); Console.WriteLine(message); ``` Mit einem [`with`-Ausdruck](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/with-expression) lassen sich die geänderten Optionen einfach erstellen. Die Methode `WithOptions` wirkt sich nicht auf den ursprünglichen Client oder Service aus. ## Streaming Das SDK definiert Methoden, die Streams von Antwort-„Chunks" zurückgeben, wobei jeder Chunk einzeln verarbeitet werden kann, sobald er eintrifft, anstatt auf die vollständige Antwort zu warten. „Streaming"-Methoden (Streaming) entsprechen im Allgemeinen [SSE](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events)- oder [JSONL](https://jsonlines.org)-Antworten. Eine Streaming-Methode hat immer das Suffix `Streaming` im Namen, auch wenn sie keine Nicht-Streaming-Variante hat. Diese Streaming-Methoden geben [`IAsyncEnumerable`](https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.iasyncenumerable-1) zurück: ```csharp using System; using Anthropic.Models.Messages; MessageCreateParams parameters = new() { MaxTokens = 1024, Messages = [new UserMessageParam { Content = "Hello, Claude" }], Model = Model.ClaudeOpus5_5, }; await foreach (var message in client.Messages.CreateStreaming(parameters)) { Console.WriteLine(message); } ``` ## Fehlerbehandlung Das SDK wirft benutzerdefinierte ungeprüfte Exception-Typen: * `AnthropicApiException`: Basisklasse für API-Fehler. In dieser Tabelle siehst du, welche Exception-Unterklasse für jeden HTTP-Statuscode geworfen wird: | Status | Exception | | ------ | ---------------------------------------- | | 400 | `AnthropicBadRequestException` | | 401 | `AnthropicUnauthorizedException` | | 403 | `AnthropicForbiddenException` | | 404 | `AnthropicNotFoundException` | | 422 | `AnthropicUnprocessableEntityException` | | 429 | `AnthropicRateLimitException` | | 5xx | `Anthropic5xxException` | | andere | `AnthropicUnexpectedStatusCodeException` | Zusätzlich erben alle 4xx-Fehler von `Anthropic4xxException`. * `AnthropicSseException`: wird bei Fehlern geworfen, die während des SSE-Streamings nach einer erfolgreichen initialen HTTP-Antwort auftreten. * `AnthropicIOException`: I/O-Netzwerkfehler. * `AnthropicInvalidDataException`: Fehler beim Interpretieren erfolgreich geparster Daten. Zum Beispiel, wenn auf eine Eigenschaft zugegriffen wird, die eigentlich erforderlich sein sollte, die API sie aber unerwartet in der Antwort weggelassen hat. * `AnthropicException`: Basisklasse für alle Exceptions. ## Wiederholungsversuche Das SDK wiederholt Anfragen standardmäßig automatisch 2 Mal, mit einem kurzen exponentiellen Backoff zwischen den Anfragen. Nur die folgenden Fehlertypen werden wiederholt: * Verbindungsfehler (zum Beispiel aufgrund eines Netzwerkverbindungsproblems) * 408 Request Timeout * 409 Conflict * 429 Rate Limit * 5xx Internal Die API kann das SDK auch explizit anweisen, eine Anfrage zu wiederholen oder nicht zu wiederholen. Um eine benutzerdefinierte Anzahl von Wiederholungsversuchen festzulegen, konfiguriere den Client mit der Eigenschaft `MaxRetries`: ```csharp using Anthropic; AnthropicClient client = new() { MaxRetries = 3 }; ``` Oder konfiguriere einen einzelnen Methodenaufruf mit `WithOptions`: ```csharp using System; var message = await client .WithOptions(options => options with { MaxRetries = 3 } ) .Messages.Create(parameters); Console.WriteLine(message); ``` ## Timeouts Anfragen laufen standardmäßig nach 10 Minuten in ein Timeout. Um ein benutzerdefiniertes Timeout festzulegen, konfiguriere den Client mit der Option `Timeout`: ```csharp using System; using Anthropic; AnthropicClient client = new() { Timeout = TimeSpan.FromSeconds(42) }; ``` Oder konfiguriere einen einzelnen Methodenaufruf mit `WithOptions`: ```csharp using System; var message = await client .WithOptions(options => options with { Timeout = TimeSpan.FromSeconds(42) } ) .Messages.Create(parameters); Console.WriteLine(message); ``` ## Paginierung Das SDK definiert Methoden, die paginierte Ergebnislisten zurückgeben. Es bietet bequeme Möglichkeiten, auf die Ergebnisse entweder seitenweise oder Element für Element über alle Seiten hinweg zuzugreifen. ### Automatische Paginierung Um alle Ergebnisse über alle Seiten hinweg zu durchlaufen, verwende die Methode `Paginate`, die bei Bedarf automatisch weitere Seiten abruft. Die Methode gibt ein [`IAsyncEnumerable`](https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.iasyncenumerable-1) zurück: ```csharp using System; var page = await client.Messages.Batches.List(parameters); await foreach (var item in page.Paginate()) { Console.WriteLine(item); } ``` ### Manuelle Paginierung Um auf einzelne Seitenelemente zuzugreifen und die nächste Seite manuell anzufordern, verwende die Eigenschaft `Items` sowie die Methoden `HasNext` und `Next`: ```csharp var page = await client.Messages.Batches.List(); while (true) { foreach (var item in page.Items) { Console.WriteLine(item); } if (!page.HasNext()) { break; } page = await page.Next(); } ``` ## Antwortvalidierung In seltenen Fällen kann die API eine Antwort zurückgeben, die nicht dem erwarteten Typ entspricht. Standardmäßig wirft das SDK in diesem Fall keine Exception. Es wirft `AnthropicInvalidDataException` nur, wenn du direkt auf die Eigenschaft zugreifst. Wenn du lieber vorab prüfen möchtest, dass die Antwort vollständig korrekt typisiert ist, rufe entweder `Validate` auf: ```csharp var message = await client.Messages.Create(parameters); message.Validate(); ``` Oder konfiguriere den Client mit der Option `ResponseValidation`: ```csharp using Anthropic; AnthropicClient client = new() { ResponseValidation = true }; ``` Oder konfiguriere einen einzelnen Methodenaufruf mit `WithOptions`: ```csharp using System; var message = await client .WithOptions(options => options with { ResponseValidation = true } ) .Messages.Create(parameters); Console.WriteLine(message); ``` ## IChatClient-Integration Das SDK stellt eine Implementierung der Schnittstelle `IChatClient` aus der Bibliothek `Microsoft.Extensions.AI.Abstractions` bereit. Dadurch können `AnthropicClient` (und `Anthropic.Services.IBetaService`) mit anderen Bibliotheken verwendet werden, die sich in diese Kernabstraktionen integrieren. Zum Beispiel können Tools aus der Bibliothek MCP C# SDK (`ModelContextProtocol`) direkt mit einem `AnthropicClient` verwendet werden, der über `IChatClient` bereitgestellt wird. ```csharp using Anthropic; using Microsoft.Extensions.AI; using ModelContextProtocol.Client; // Konfiguriert über die Umgebungsvariablen ANTHROPIC_API_KEY, ANTHROPIC_AUTH_TOKEN und ANTHROPIC_BASE_URL AnthropicClient client = new(); IChatClient chatClient = client.AsIChatClient("claude-opus-5-5") .AsBuilder() .UseFunctionInvocation() .Build(); // Verwendet McpClient aus dem MCP C# SDK McpClient learningServer = await McpClient.CreateAsync( new HttpClientTransport(new() { Endpoint = new("https://learn.microsoft.com/api/mcp") })); ChatOptions options = new() { Tools = [.. await learningServer.ListToolsAsync()] }; Console.WriteLine(await chatClient.GetResponseAsync("Tell me about IChatClient", options)); ``` ## Anfragen und Antworten Um eine Anfrage an die Claude API zu senden, erstelle eine Instanz einer `Params`-Klasse und übergib sie an die entsprechende Client-Methode. Wenn die Antwort empfangen wird, wird sie in eine Instanz einer C#-Klasse deserialisiert. Zum Beispiel sollte `client.Messages.Create` mit einer Instanz von `MessageCreateParams` aufgerufen werden und gibt eine Instanz von `Task` zurück. ## Erweiterte Verwendung ### Binäre Antworten Das SDK definiert Methoden, die binäre Antworten zurückgeben. Diese werden für API-Antworten verwendet, die nicht unbedingt geparst werden sollten, wie etwa Nicht-JSON-Daten. Diese Methoden geben `HttpResponse` zurück: ```csharp using System; using Anthropic.Models.Files; FileDownloadParams parameters = new() { FileID = "file_id" }; var response = await client.Files.Download(parameters); Console.WriteLine(response); ``` Um den Antwortinhalt in einer Datei oder einem beliebigen [`Stream`](https://learn.microsoft.com/en-us/dotnet/api/system.io.stream) zu speichern, verwende die Methode [`CopyToAsync`](https://learn.microsoft.com/en-us/dotnet/api/system.io.stream.copytoasync): ```csharp using System.IO; using var response = await client.Files.Download(parameters); using var contentStream = await response.ReadAsStream(); using var fileStream = File.Open(path, FileMode.OpenOrCreate); await contentStream.CopyToAsync(fileStream); // Or any other Stream ``` ### Rohe Antworten Das SDK definiert Methoden, die Antworten in Instanzen von C#-Klassen deserialisieren. Um auf Antwort-Header, Statuscode oder den rohen Antwort-Body zuzugreifen, stelle jedem HTTP-Methodenaufruf auf einem Client oder Service `WithRawResponse` voran: ```csharp var response = await client.WithRawResponse.Messages.Create(parameters); var statusCode = response.StatusCode; var headers = response.Headers; ``` Auf die rohe `HttpResponseMessage` kann auch über die Eigenschaft `RawMessage` zugegriffen werden. Bei Nicht-Streaming-Antworten kannst du die Antwort bei Bedarf in eine Instanz einer C#-Klasse deserialisieren: ```csharp using System; using Anthropic.Models.Messages; var response = await client.WithRawResponse.Messages.Create(parameters); Message deserialized = await response.Deserialize(); Console.WriteLine(deserialized); ``` Bei Streaming-Antworten kannst du die Antwort bei Bedarf in ein `IAsyncEnumerable` deserialisieren: ```csharp using System; var response = await client.WithRawResponse.Messages.CreateStreaming(parameters); await foreach (var item in response.Enumerate()) { Console.WriteLine(item); } ``` ### Logging Alle Log-Meldungen sind ausschließlich für das Debugging gedacht. Format und Inhalt der Log-Meldungen können sich zwischen Releases ändern. Aktiviere das Debug-Logging, indem du eine Umgebungsvariable setzt: ```bash export ANTHROPIC_LOG=debug ``` ### OpenTelemetry-Tracing Wenn deine Anwendung ihrem OpenTelemetry Tracer Provider die Sources des SDK mit `AddSource("com.anthropic.sdk.csharp*")` hinzufügt, 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). ### Nicht dokumentierte API-Funktionalität Das SDK ist für die bequeme Nutzung der dokumentierten API typisiert. Es unterstützt jedoch auch die Arbeit mit nicht dokumentierten oder noch nicht unterstützten Teilen der API. ## Plattformintegrationen Ausführliche Anleitungen zur Plattformeinrichtung mit Codebeispielen findest du hier: * [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). Das C# SDK unterstützt die folgenden Plattformen über separate NuGet-Pakete: * **Agent Platform:** `Anthropic.Vertex`. Informationen zur Client-Einrichtung findest du unter [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/google-managed). * **Bedrock:** `Anthropic.Bedrock`. Verwende `AnthropicBedrockMantleClient` für den Messages-API-Bedrock-Endpunkt oder `AnthropicBedrockClient` (`bedrock-runtime`-Pfad). `AnthropicBedrockMantleClient` akzeptiert ein optionales `MantleAwsClientOptions`-Konfigurationsobjekt; `AnthropicBedrockClient` akzeptiert `AnthropicBedrockCredentialsHelper.FromEnv()` oder explizite Anmeldedaten. * **Claude Platform on AWS:** `Anthropic.Aws`. Verwende `AnthropicAwsClient`; setze `WorkspaceId` auf dem Client oder die Umgebungsvariable `ANTHROPIC_AWS_WORKSPACE_ID` (siehe [Workspaces](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#workspaces)). Als Beta verfügbar. * **Foundry:** `Anthropic.Foundry`. Verwende `AnthropicFoundryClient` mit `DefaultAnthropicFoundryCredentials.FromEnv()` oder expliziten Anmeldedaten. Verwende `AnthropicBedrockMantleClient` für neue Projekte; `AnthropicBedrockClient` bleibt für bestehende Anwendungen erhalten, die die Bedrock-`InvokeModel`-API verwenden. Das C#-SDK unterstützt außerdem Claude Models on Google Cloud (Anthropic managed) über `AnthropicGoogleCloudClient` aus dem Paket `Anthropic.GoogleCloud`. Dieser Client befindet sich in der Beta. Setze `WorkspaceId` auf einem optionalen `GoogleCloudClientOptions`-Wert oder setze die Umgebungsvariable `ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID`. Siehe [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). ## Semantische Versionierung Jede Hauptversion dieses SDK sendet standardmäßig eine API-Version im Header `anthropic-version`, und mit jeder neuen API-Version erscheint eine neue Hauptversion. Die erste Hauptversion, die `2026-10-21` sendet, ist 13.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 an Bibliotheksinterna, die technisch öffentlich sind, aber nicht für die externe Nutzung vorgesehen oder dokumentiert sind. 2. Änderungen, von denen nicht erwartet wird, dass sie sich in der Praxis auf die große Mehrheit der Nutzer auswirken. Abwärtskompatibilität wird ernst genommen, damit du dich auf ein reibungsloses Upgrade-Erlebnis verlassen kannst. ## Zusätzliche Ressourcen * [GitHub-Repository](https://github.com/anthropics/anthropic-sdk-csharp) * [NuGet-Paket](https://www.nuget.org/packages/Anthropic) * [API-Referenz](https://platform.claude.com/docs/de/api/overview) * [Streaming von Nachrichten](https://platform.claude.com/docs/de/build-with-claude/streaming)