--- title: Usage and Cost Analytics API url: https://platform.claude.com/docs/de/manage-claude/usage-cost-analytics-api description: Frage Token-Nutzung und Kosten für deine Claude Console- oder Claude Enterprise-Organisation nach Modell, Workspace, API-Key, Akteur und mehr ab. --- **Die Admin API ist für Einzelkonten nicht verfügbar.** Um mit Teamkollegen zusammenzuarbeiten und Mitglieder hinzuzufügen, richte deine Organisation auf der Seite [Organization](https://platform.claude.com/settings/organization) (`platform.claude.com/settings/organization`) in der Claude Console ein. Die Usage and Cost Analytics API liefert die historische Token-Nutzung und die Kosten deiner Organisation, aufgeschlüsselt nach den von dir gewählten Dimensionen, etwa Modell, Workspace, API-Key oder dem Benutzer bzw. Service-Account hinter jeder Anfrage. Für Claude Console-Organisationen ähneln diese Daten dem, was die Seiten [Usage](https://platform.claude.com/usage) und [Cost](https://platform.claude.com/cost) der Claude Console anzeigen. Die API hat zwei Endpunkte: * `GET /v1/organizations/analytics/usage` liefert Token-Anzahlen und Anfrageanzahlen. * `GET /v1/organizations/analytics/cost` liefert Kosten in USD. Die Usage and Cost Analytics API befindet sich in der Beta-Phase. Sende bei jeder Anfrage `anthropic-beta: analytics-usage-cost-2026-08-24` als Header sowie einen [`anthropic-version`](https://platform.claude.com/docs/de/api/versioning)-Header mit. Das SDK und die `ant`-CLI senden beide Header für dich und rufen die restlichen Seiten ab, während du die Ergebnisse liest, sodass `limit` nur die Seitengröße festlegt. Verwende diese API, um: * **Ausgaben zuzuordnen:** Kosten und Token-Nutzung nach Workspace, API-Key, Modell, Service-Tier oder der Identität aufzuschlüsseln, die die jeweilige Anfrage gestellt hat. * **Die größten Verbraucher zu finden:** Ergebnisse nach Token, Anfragen oder Kosten zu sortieren, um Fragen wie „Welche API-Keys geben diesen Monat am meisten aus?“ zu beantworten. * **Zeitreihen zu erstellen:** Ergebnisse für Dashboards und Finanzberichte in tägliche, stündliche oder minütliche Intervalle aufzuteilen. * **Einmal zu integrieren:** Dieselben Endpunkte, Parameter und Antwortfelder bedienen Organisationen in der Claude Console und in Claude Enterprise. **Admin-API-Key erforderlich** Claude Console-Organisationen verwenden einen [Admin-API-Key](https://platform.claude.com/docs/de/manage-claude/admin-api-keys#create-a-key-for-a-claude-console-organization) oder andere [Admin-API-Anmeldedaten](https://platform.claude.com/docs/de/manage-claude/admin-api#authentication). Claude Enterprise-Organisationen verwenden einen Key mit dem Scope `read:analytics`, der in claude.ai vom primären Eigentümer erstellt wird, nachdem die Analytics API für die Organisation aktiviert wurde; siehe [Zugriff auf die Claude Enterprise Analytics API erhalten](https://platform.claude.com/docs/de/manage-claude/analytics-api#get-access-to-the-claude-enterprise-analytics-api). In beiden Fällen setzt du die Umgebungsvariable `ANTHROPIC_API_KEY` auf diesen Key; die Beispiele auf dieser Seite lesen den Key daraus. Wenn du diese Endpunkte mit einem Admin-API-Key aufrufst, gib dem Dienst, der diese Daten sammelt, einen eigenen Key, speichere ihn in einem Secrets-Manager und rotiere ihn regelmäßig; wenn du beim Erstellen des Keys ein [Key-Ablaufdatum](https://platform.claude.com/docs/de/manage-claude/authentication#key-expiration) festlegst, wird die Rotation erzwungen. Wo möglich, verwende stattdessen eine [Workload Identity Federation](https://platform.claude.com/docs/de/manage-claude/workload-identity-federation)-Regel mit dem [`org:admin`-Scope](https://platform.claude.com/docs/de/manage-claude/wif-reference#oauth-scopes), sodass der Dienst kurzlebige Token erhält und es keinen langlebigen Key gibt, der durchsickern kann. **Claude Platform on AWS:** Beide Endpunkte sind verfügbar. Anfragen verwenden die Basis-URL und Authentifizierung von Claude Platform on AWS anstelle eines Admin-API-Keys (siehe [Anfragen stellen](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#making-requests)), und AWS IAM autorisiert sie über die [Aktionen `ListAccountUsage` und `ListAccountCost`](https://platform.claude.com/docs/de/api/claude-platform-on-aws-iam-actions#usage-and-cost). Jede Anfrage umfasst nur die Workspaces in der AWS-Region des Endpunkts, den du aufrufst. Rufe daher den Endpunkt jeder Region auf, um deine gesamte Organisation abzudecken. `user_profile_id`, `claude_tag_category`, `claude_tag_user_id` und die Dimensionen von Claude Managed Agents (`agent_id`, `environment_id`, `deployment_id` und `session_id`) sind in jeder Zeile `null`. **Claude Models on Google Cloud (Anthropic managed):** Beide Endpunkte sind verfügbar. Rufe sie über die [Basis-URL auf Organisationsebene](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#making-requests) mit Google Cloud-Anmeldedaten statt mit einem Admin-API-Key auf. Der Endpunkt `/usage` benötigt die [IAM-Berechtigung](https://platform.claude.com/docs/de/api/claude-models-on-google-cloud-anthropic-managed-iam-permissions) `usageAnalytics.list`, und der Endpunkt `/cost` benötigt `costAnalytics.list`. ## Schnellstart Rufe die tägliche Token-Nutzung für die erste Septemberwoche ab, mit einer Zeile für jedes Modell und jeden Tag: ```bash cURL curl --globoff "https://api.anthropic.com/v1/organizations/analytics/usage?\ starting_at=2026-09-01T00:00:00Z&\ ending_at=2026-09-08T00:00:00Z&\ time_bucket_width=1d&\ group_by[]=model&\ limit=10" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: analytics-usage-cost-2026-08-24" \ -H "x-api-key: $ANTHROPIC_API_KEY" ``` ```bash CLI ant beta:organization:analytics:usage list \ --starting-at 2026-09-01T00:00:00Z \ --ending-at 2026-09-08T00:00:00Z \ --time-bucket-width 1d \ --group-by model \ --limit 10 ``` ```python Python client = anthropic.Anthropic() rows = client.beta.organization.analytics.usage.list( starting_at="2026-09-01T00:00:00Z", ending_at="2026-09-08T00:00:00Z", time_bucket_width="1d", group_by=["model"], limit=10, ) for row in rows: print(f"{row.starting_at} {row.group.model}: {row.usage.total_tokens}") ``` ```typescript TypeScript const client = new Anthropic(); const rows = await client.beta.organization.analytics.usage.list({ starting_at: "2026-09-01T00:00:00Z", ending_at: "2026-09-08T00:00:00Z", time_bucket_width: "1d", group_by: ["model"], limit: 10 }); for await (const row of rows) { console.log(`${row.starting_at} ${row.group.model}: ${row.usage.total_tokens}`); } ``` ```csharp C# using Anthropic.Models.Beta.Organization.Analytics; using Anthropic.Models.Beta.Organization.Analytics.Usage; AnthropicClient client = new(); var page = await client.Beta.Organization.Analytics.Usage.List( new() { StartingAt = DateTimeOffset.Parse("2026-09-01T00:00:00Z"), EndingAt = DateTimeOffset.Parse("2026-09-08T00:00:00Z"), TimeBucketWidth = BetaAnalyticsTimeBucketWidth.Day, GroupBy = [BetaAnalyticsUsageGroupBy.Model], Limit = 10, } ); await foreach (var row in page.Paginate()) { Console.WriteLine($"{row.StartingAt} {row.Group.Model}: {row.Usage.TotalTokens}"); } ``` ```go Go client := anthropic.NewClient() rows := client.Beta.Organization.Analytics.Usage.ListAutoPaging(context.Background(), anthropic.BetaOrganizationAnalyticsUsageListParams{ StartingAt: time.Date(2026, time.September, 1, 0, 0, 0, 0, time.UTC), EndingAt: anthropic.Time(time.Date(2026, time.September, 8, 0, 0, 0, 0, time.UTC)), TimeBucketWidth: anthropic.BetaAnalyticsTimeBucketWidthDay, GroupBy: []anthropic.BetaAnalyticsUsageGroupBy{anthropic.BetaAnalyticsUsageGroupByModel}, Limit: anthropic.Int(10), }) for rows.Next() { row := rows.Current() fmt.Printf("%s %s: %d\n", row.StartingAt.Format(time.RFC3339), row.Group.Model, row.Usage.TotalTokens) } if err := rows.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.beta.organization.analytics.BetaAnalyticsTimeBucketWidth; import com.anthropic.models.beta.organization.analytics.usage.BetaAnalyticsUsageGroupBy; import com.anthropic.models.beta.organization.analytics.usage.UsageListParams; import java.time.OffsetDateTime; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = UsageListParams.builder() .startingAt(OffsetDateTime.parse("2026-09-01T00:00:00Z")) .endingAt(OffsetDateTime.parse("2026-09-08T00:00:00Z")) .timeBucketWidth(BetaAnalyticsTimeBucketWidth.DAY) .addGroupBy(BetaAnalyticsUsageGroupBy.MODEL) .limit(10) .build(); var rows = client.beta().organization().analytics().usage().list(params); for (var row : rows.autoPager()) { IO.println(row.startingAt() + " " + row.group().model().orElse(null) + ": " + row.usage().totalTokens()); } } ``` ```php PHP $client = new Client(); $rows = $client->beta->organization->analytics->usage->list( startingAt: new \DateTimeImmutable('2026-09-01T00:00:00Z'), endingAt: new \DateTimeImmutable('2026-09-08T00:00:00Z'), timeBucketWidth: '1d', groupBy: ['model'], limit: 10, ); foreach ($rows->pagingEachItem() as $row) { $startingAt = $row->startingAt->format(\DateTimeInterface::ATOM); echo "{$startingAt} {$row->group->model}: {$row->usage->totalTokens}\n"; } ``` ```ruby Ruby client = Anthropic::Client.new page = client.beta.organization.analytics.usage.list( starting_at: Time.utc(2026, 9, 1), ending_at: Time.utc(2026, 9, 8), time_bucket_width: :"1d", group_by: [:model], limit: 10 ) page.auto_paging_each do |row| puts "#{row.starting_at} #{row.group.model}: #{row.usage.total_tokens}" end ``` Die Antwort enthält eine Zeile für jedes Modell und jeden Tag mit Nutzung, die Zeile mit dem größten `total_tokens` zuerst. Dieses Beispiel zeigt eine einzelne Zeile: ```json { "data": [ { "starting_at": "2026-09-03T00:00:00Z", "ending_at": "2026-09-04T00:00:00Z", "group": { "product": null, "model": "claude-sonnet-5", "context_window": null, "inference_geo": null, "speed": null, "slack_channel_id": null, "claude_tag_category": null, "claude_tag_user_id": null, "rbac_group_id": null, "workspace_id": null, "service_tier": null, "user_profile_id": null, "agent_id": null, "environment_id": null, "deployment_id": null, "session_id": null, "actor": null, "actor_type": null, "api_key_id": null }, "usage": { "uncached_input_tokens": 1284500, "cache_creation": { "ephemeral_1h_input_tokens": 0, "ephemeral_5m_input_tokens": 215300 }, "cache_read_input_tokens": 3200000, "output_tokens": 891000, "total_tokens": 5590800, "server_tool_use": { "web_search_requests": 12 }, "requests": 4210 } } ], "has_more": true, "next_page": "page_V2mQ4dkt9HcbX3pLr...", "data_refreshed_at": "2026-09-18T16:02:11Z" } ``` **Setze einen User-Agent-Header für Integrationen** Wenn du eine Integration entwickelst, setze deinen User-Agent-Header, damit Anthropic Nutzungsmuster besser verstehen kann: ```text wrap User-Agent: YourApp/1.0.0 (https://yourapp.com) ``` ## Wie Ergebnisse aufgebaut sind * **Jede Zeile besteht aus drei Teilen:** `starting_at` und `ending_at` geben den Zeitraum an, den die Zeile abdeckt, `group` enthält alle Dimensionen, und `usage` (bzw. `cost` beim Cost-Endpunkt) enthält die Metriken. * **Dimensionen sind null, sofern nicht gruppiert:** Eine Dimension in `group` ist `null`, es sei denn, du führst sie in `group_by[]` auf. Eine gruppierte Dimension ist außerdem in Zeilen `null`, die keinen Wert dafür haben, etwa `model` bei der Nutzung von Code Execution. `group_by[]` akzeptiert bis zu fünf Dimensionen. * **Eine Zeile für jede Kombination:** Jede Zeile ist eine Kombination der gruppierten Dimensionen, und jede Kombination mit Nutzung oder Kosten erscheint über alle Seiten einer Abfrage hinweg genau einmal. Ohne `group_by[]` und ohne `time_bucket_width` besteht die Antwort aus einer einzigen Zeile, die den gesamten Zeitraum summiert. * **Zeitintervalle sind optional:** Setze `time_bucket_width` auf `1m`, `1h` oder `1d`, um jede Kombination nach UTC-Zeitintervall aufzuteilen; `starting_at` und `ending_at` jeder Zeile sind dann die Grenzen ihres Zeitintervalls. Zeitintervalle ohne Nutzung oder Kosten erzeugen keine Zeilen. * **Standardmäßig nach Rang sortiert:** Zeilen werden nach der `order_by`-Metrik über den gesamten Zeitraum sortiert, standardmäßig die größten zuerst (`order=asc` kehrt dies um). Um eine Zeitreihe zu erstellen, setze `time_bucket_width` und `order_by=time`. Die Zeilen werden dann ein Zeitintervall nach dem anderen zurückgegeben, standardmäßig das neueste Zeitintervall zuerst (`order=asc` stellt das älteste an den Anfang), wobei innerhalb jedes Zeitintervalls die größten Zeilen zuerst kommen. Fülle leere Zeitintervalle mit Nullen auf. * **Filter funktionieren zusammen mit Gruppierung:** Für die meisten Dimensionen, nach denen du gruppieren kannst, gibt es einen passenden Listenfilter in Klammernotation, etwa `models[]=claude-opus-5-5`. Wiederhole den Parameter, um mehrere Werte zu übergeben, bis zu 100. Mehrere Werte für denselben Filter werden mit OR kombiniert, verschiedene Filter mit AND. Filter und `group_by[]` sind unabhängig voneinander; du kannst nach jeder Dimension filtern, mit oder ohne nach ihr zu gruppieren, und umgekehrt. Dimensionen wie `model` und `actor` gelten für jede Organisation. Einige, etwa `api_key_id`, gelten nur für Claude Console-Organisationen, andere, etwa `slack_channel_id`, nur für Claude Enterprise-Organisationen. Eine Dimension, die nicht für deine Organisation gilt, ist in jeder Zeile `null`, und ihr Filter trifft auf nichts zu; die Ausnahme ist `rbac_group_id`, das stattdessen einen Fehler zurückgibt, wenn Teams für deine Organisation nicht verfügbar sind. Die API-Referenz für [usage](https://platform.claude.com/docs/de/api/beta/organization/analytics/usage/list) und [cost](https://platform.claude.com/docs/de/api/beta/organization/analytics/cost/list) listet jede Dimension, jeden Filter und jeden Wert auf. ### Akteure Die Dimension `actor` gibt an, wem eine Anfrage zugeordnet wird: einem Benutzer, einem Service-Account, einer föderierten Cloud-Identität (einem AWS- oder Google Cloud-Principal, für Organisationen, die über ihre Cloud-Plattform auf Claude zugreifen) oder, wenn keines davon hinter der Anfrage steht, dem API-Key selbst. Wenn du nach `actor` gruppierst, ist `actor` in jeder Zeile ein Objekt, dessen `type` angibt, um welche Art es sich handelt. Nutzung, die keiner Identität zugeordnet werden kann, hat `actor: null`. [Persönliche Keys und Service-Account-Keys](https://platform.claude.com/docs/de/manage-claude/authentication#key-types) agieren als der Benutzer oder Service-Account, mit dem sie verknüpft sind, sodass ihre Anfragen diese Identität als `actor` und den Key in `api_key_id` zeigen. Veraltete Workspace-Keys sind mit keiner Identität verknüpft, daher erscheint der Key sowohl als `actor` als auch als `api_key_id`. Die Ausnahme ist der Key, den Claude Code erstellt, wenn sich ein Mitglied mit seinem Claude Console-Konto anmeldet: Er befindet sich im [Claude Code Workspace](https://platform.claude.com/docs/de/manage-claude/workspaces#claude-code-workspace), und seine Nutzung wird diesem Mitglied zugeordnet. Anfragen ohne API-Key, etwa aus der Claude Console oder mit einem [Workload Identity Federation](https://platform.claude.com/docs/de/manage-claude/workload-identity-federation)-Token, haben `api_key_id: null`; der `actor` eines föderierten Workloads ist sein Service-Account. Um Nutzung ohne API-Key in einen `api_key_ids[]`-Filter einzuschließen, füge einen leeren Eintrag hinzu: `api_key_ids[]=`. Die Filter `api_key_ids[]` und `actor_ids[]` beantworten unterschiedliche Fragen. `api_key_ids[]=apikey_...` trifft auf jede Anfrage zu, die der Key authentifiziert hat, unabhängig davon, wem sie zugeordnet ist. `actor_ids[]=apikey_...` trifft nur auf Anfragen zu, die dem Key selbst zugeordnet sind. ## Usage-Endpunkt `GET /v1/organizations/analytics/usage` gibt Token-Anzahlen nach Typ zurück. `order_by` akzeptiert `total_tokens` (Standard), `output_tokens`, `uncached_input_tokens`, `requests` oder `time`. Um beispielsweise eine Woche Nutzung für einen Workspace und einen API-Key aufgeschlüsselt nach Service-Tier zu sehen (eine Zeile für jeden Tier, die die gesamte Woche abdeckt): ```bash cURL curl --globoff "https://api.anthropic.com/v1/organizations/analytics/usage?\ starting_at=2026-09-01T00:00:00Z&\ ending_at=2026-09-08T00:00:00Z&\ workspace_ids[]=wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ&\ api_key_ids[]=apikey_01Rj2N8SVvo6BePZj99NhmiT&\ group_by[]=service_tier" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: analytics-usage-cost-2026-08-24" \ -H "x-api-key: $ANTHROPIC_API_KEY" ``` ```bash CLI ant beta:organization:analytics:usage list \ --starting-at 2026-09-01T00:00:00Z \ --ending-at 2026-09-08T00:00:00Z \ --workspace-id wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ \ --api-key-id apikey_01Rj2N8SVvo6BePZj99NhmiT \ --group-by service_tier ``` ```python Python client = anthropic.Anthropic() rows = client.beta.organization.analytics.usage.list( starting_at="2026-09-01T00:00:00Z", ending_at="2026-09-08T00:00:00Z", workspace_ids=["wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"], api_key_ids=["apikey_01Rj2N8SVvo6BePZj99NhmiT"], group_by=["service_tier"], ) for row in rows: print(f"{row.group.service_tier}: {row.usage.total_tokens}") ``` ```typescript TypeScript const client = new Anthropic(); const rows = await client.beta.organization.analytics.usage.list({ starting_at: "2026-09-01T00:00:00Z", ending_at: "2026-09-08T00:00:00Z", workspace_ids: ["wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"], api_key_ids: ["apikey_01Rj2N8SVvo6BePZj99NhmiT"], group_by: ["service_tier"] }); for await (const row of rows) { console.log(`${row.group.service_tier}: ${row.usage.total_tokens}`); } ``` ```csharp C# using Anthropic.Models.Beta.Organization.Analytics.Usage; AnthropicClient client = new(); var page = await client.Beta.Organization.Analytics.Usage.List( new() { StartingAt = DateTimeOffset.Parse("2026-09-01T00:00:00Z"), EndingAt = DateTimeOffset.Parse("2026-09-08T00:00:00Z"), WorkspaceIds = ["wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"], ApiKeyIds = ["apikey_01Rj2N8SVvo6BePZj99NhmiT"], GroupBy = [BetaAnalyticsUsageGroupBy.ServiceTier], } ); await foreach (var row in page.Paginate()) { Console.WriteLine($"{row.Group.ServiceTier?.Raw()}: {row.Usage.TotalTokens}"); } ``` ```go Go client := anthropic.NewClient() rows := client.Beta.Organization.Analytics.Usage.ListAutoPaging(context.Background(), anthropic.BetaOrganizationAnalyticsUsageListParams{ StartingAt: time.Date(2026, time.September, 1, 0, 0, 0, 0, time.UTC), EndingAt: anthropic.Time(time.Date(2026, time.September, 8, 0, 0, 0, 0, time.UTC)), WorkspaceIDs: []string{"wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"}, APIKeyIDs: []string{"apikey_01Rj2N8SVvo6BePZj99NhmiT"}, GroupBy: []anthropic.BetaAnalyticsUsageGroupBy{anthropic.BetaAnalyticsUsageGroupByServiceTier}, }) for rows.Next() { row := rows.Current() fmt.Printf("%s: %d\n", row.Group.ServiceTier, row.Usage.TotalTokens) } if err := rows.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.beta.organization.analytics.usage.BetaAnalyticsUsageGroupBy; import com.anthropic.models.beta.organization.analytics.usage.UsageListParams; import java.time.OffsetDateTime; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = UsageListParams.builder() .startingAt(OffsetDateTime.parse("2026-09-01T00:00:00Z")) .endingAt(OffsetDateTime.parse("2026-09-08T00:00:00Z")) .addWorkspaceId("wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ") .addApiKeyId("apikey_01Rj2N8SVvo6BePZj99NhmiT") .addGroupBy(BetaAnalyticsUsageGroupBy.SERVICE_TIER) .build(); var rows = client.beta().organization().analytics().usage().list(params); for (var row : rows.autoPager()) { IO.println(row.group().serviceTier().orElse(null) + ": " + row.usage().totalTokens()); } } ``` ```php PHP $client = new Client(); $rows = $client->beta->organization->analytics->usage->list( startingAt: new \DateTimeImmutable('2026-09-01T00:00:00Z'), endingAt: new \DateTimeImmutable('2026-09-08T00:00:00Z'), workspaceIDs: ['wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ'], apiKeyIDs: ['apikey_01Rj2N8SVvo6BePZj99NhmiT'], groupBy: ['service_tier'], ); foreach ($rows->pagingEachItem() as $row) { echo "{$row->group->serviceTier}: {$row->usage->totalTokens}\n"; } ``` ```ruby Ruby client = Anthropic::Client.new page = client.beta.organization.analytics.usage.list( starting_at: Time.utc(2026, 9, 1), ending_at: Time.utc(2026, 9, 8), workspace_ids: ["wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"], api_key_ids: ["apikey_01Rj2N8SVvo6BePZj99NhmiT"], group_by: [:service_tier] ) page.auto_paging_each do |row| puts "#{row.group.service_tier}: #{row.usage.total_tokens}" end ``` Um API-Key- und Workspace-IDs nachzuschlagen, verwende die Endpunkte [List API Keys](https://platform.claude.com/docs/de/api/organization/api_keys/list) und [List Workspaces](https://platform.claude.com/docs/de/api/organization/workspaces/list) oder die Claude Console. Um herauszufinden, welche Benutzer, Service-Accounts und API-Keys in einem Monat die meisten Anfragen gestellt haben: ```bash cURL curl --globoff "https://api.anthropic.com/v1/organizations/analytics/usage?\ starting_at=2026-09-01T00:00:00Z&\ ending_at=2026-10-01T00:00:00Z&\ group_by[]=actor&\ order_by=requests&\ limit=25" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: analytics-usage-cost-2026-08-24" \ -H "x-api-key: $ANTHROPIC_API_KEY" ``` ```bash CLI ant beta:organization:analytics:usage list \ --starting-at 2026-09-01T00:00:00Z \ --ending-at 2026-10-01T00:00:00Z \ --group-by actor \ --order-by requests \ --limit 25 ``` ```python Python client = anthropic.Anthropic() rows = client.beta.organization.analytics.usage.list( starting_at="2026-09-01T00:00:00Z", ending_at="2026-10-01T00:00:00Z", group_by=["actor"], order_by="requests", limit=25, ) for row in rows: print(f"{row.group.actor}: {row.usage.requests}") ``` ```typescript TypeScript const client = new Anthropic(); const rows = await client.beta.organization.analytics.usage.list({ starting_at: "2026-09-01T00:00:00Z", ending_at: "2026-10-01T00:00:00Z", group_by: ["actor"], order_by: "requests", limit: 25 }); for await (const row of rows) { console.log(`${JSON.stringify(row.group.actor)}: ${row.usage.requests}`); } ``` ```csharp C# using Anthropic.Models.Beta.Organization.Analytics.Usage; AnthropicClient client = new(); var page = await client.Beta.Organization.Analytics.Usage.List( new() { StartingAt = DateTimeOffset.Parse("2026-09-01T00:00:00Z"), EndingAt = DateTimeOffset.Parse("2026-10-01T00:00:00Z"), GroupBy = [BetaAnalyticsUsageGroupBy.Actor], OrderBy = BetaAnalyticsUsageOrderBy.Requests, Limit = 25, } ); await foreach (var row in page.Paginate()) { Console.WriteLine($"{row.Group.Actor?.Json}: {row.Usage.Requests}"); } ``` ```go Go client := anthropic.NewClient() rows := client.Beta.Organization.Analytics.Usage.ListAutoPaging(context.Background(), anthropic.BetaOrganizationAnalyticsUsageListParams{ StartingAt: time.Date(2026, time.September, 1, 0, 0, 0, 0, time.UTC), EndingAt: anthropic.Time(time.Date(2026, time.October, 1, 0, 0, 0, 0, time.UTC)), GroupBy: []anthropic.BetaAnalyticsUsageGroupBy{anthropic.BetaAnalyticsUsageGroupByActor}, OrderBy: anthropic.BetaAnalyticsUsageOrderByRequests, Limit: anthropic.Int(25), }) for rows.Next() { row := rows.Current() fmt.Printf("%s: %d\n", row.Group.Actor.RawJSON(), row.Usage.Requests) } if err := rows.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.beta.organization.analytics.usage.BetaAnalyticsUsageGroupBy; import com.anthropic.models.beta.organization.analytics.usage.BetaAnalyticsUsageOrderBy; import com.anthropic.models.beta.organization.analytics.usage.UsageListParams; import java.time.OffsetDateTime; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = UsageListParams.builder() .startingAt(OffsetDateTime.parse("2026-09-01T00:00:00Z")) .endingAt(OffsetDateTime.parse("2026-10-01T00:00:00Z")) .addGroupBy(BetaAnalyticsUsageGroupBy.ACTOR) .orderBy(BetaAnalyticsUsageOrderBy.REQUESTS) .limit(25) .build(); var rows = client.beta().organization().analytics().usage().list(params); for (var row : rows.autoPager()) { IO.println(row.group().actor().orElse(null) + ": " + row.usage().requests().orElse(null)); } } ``` ```php PHP $client = new Client(); $rows = $client->beta->organization->analytics->usage->list( startingAt: new \DateTimeImmutable('2026-09-01T00:00:00Z'), endingAt: new \DateTimeImmutable('2026-10-01T00:00:00Z'), groupBy: ['actor'], orderBy: 'requests', limit: 25, ); foreach ($rows->pagingEachItem() as $row) { $actor = json_encode($row->group->actor); echo "{$actor}: {$row->usage->requests}\n"; } ``` ```ruby Ruby client = Anthropic::Client.new page = client.beta.organization.analytics.usage.list( starting_at: Time.utc(2026, 9, 1), ending_at: Time.utc(2026, 10, 1), group_by: [:actor], order_by: :requests, limit: 25 ) page.auto_paging_each do |row| puts "#{row.group.actor}: #{row.usage.requests}" end ``` ## Cost-Endpunkt `GET /v1/organizations/analytics/cost` akzeptiert dieselben Filter, Dimensionen und Zeitintervalle wie der `/usage`-Endpunkt. Das `cost`-Objekt jeder Zeile enthält `amount` (die Kosten nach Rabatten und vor der Anrechnung von Guthaben), `list_amount` (die Kosten zu Listenpreisen), `currency` (immer `"USD"`) und `requests`. Beträge sind Dezimal-Strings in Cent mit sechs Nachkommastellen: `"41280.000000"` entspricht 412,80 $ USD. `order_by` akzeptiert `amount` (Standard), `list_amount` oder `time`. Zwei zusätzliche Dimensionen gibt es nur bei diesem Endpunkt, und sie zählen nicht zum Limit von fünf Dimensionen: `group_by[]=cost_type` teilt jede Zeile in eine Zeile für jeden Kostentyp auf, und `group_by[]=token_type` teilt die Token-Kosten in eine Zeile für jeden Token-Typ auf. `limit` gilt für diese beiden Dimensionen ebenfalls nicht, sodass eine Seite mehr als `limit` Zeilen enthalten kann. Zum Beispiel Kosten nach Modell, Kostentyp und Token-Typ für einen Monat: ```bash cURL curl --globoff "https://api.anthropic.com/v1/organizations/analytics/cost?\ starting_at=2026-09-01T00:00:00Z&\ ending_at=2026-10-01T00:00:00Z&\ group_by[]=model&\ group_by[]=cost_type&\ group_by[]=token_type" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: analytics-usage-cost-2026-08-24" \ -H "x-api-key: $ANTHROPIC_API_KEY" ``` ```bash CLI ant beta:organization:analytics:cost list \ --starting-at 2026-09-01T00:00:00Z \ --ending-at 2026-10-01T00:00:00Z \ --group-by model \ --group-by cost_type \ --group-by token_type ``` ```python Python client = anthropic.Anthropic() rows = client.beta.organization.analytics.cost.list( starting_at="2026-09-01T00:00:00Z", ending_at="2026-10-01T00:00:00Z", group_by=["model", "cost_type", "token_type"], ) for row in rows: print( f"{row.group.model} {row.group.cost_type} {row.group.token_type}: {row.cost.amount}" ) ``` ```typescript TypeScript const client = new Anthropic(); const rows = await client.beta.organization.analytics.cost.list({ starting_at: "2026-09-01T00:00:00Z", ending_at: "2026-10-01T00:00:00Z", group_by: ["model", "cost_type", "token_type"] }); for await (const row of rows) { console.log( `${row.group.model} ${row.group.cost_type} ${row.group.token_type}: ${row.cost.amount}` ); } ``` ```csharp C# using Anthropic.Models.Beta.Organization.Analytics.Cost; AnthropicClient client = new(); var page = await client.Beta.Organization.Analytics.Cost.List( new() { StartingAt = DateTimeOffset.Parse("2026-09-01T00:00:00Z"), EndingAt = DateTimeOffset.Parse("2026-10-01T00:00:00Z"), GroupBy = [BetaAnalyticsCostGroupBy.Model, BetaAnalyticsCostGroupBy.CostType, BetaAnalyticsCostGroupBy.TokenType], } ); await foreach (var row in page.Paginate()) { Console.WriteLine( $"{row.Group.Model} {row.Group.CostType?.Raw()} {row.Group.TokenType?.Raw()}: {row.Cost.Amount}" ); } ``` ```go Go client := anthropic.NewClient() rows := client.Beta.Organization.Analytics.Cost.ListAutoPaging(context.Background(), anthropic.BetaOrganizationAnalyticsCostListParams{ StartingAt: time.Date(2026, time.September, 1, 0, 0, 0, 0, time.UTC), EndingAt: anthropic.Time(time.Date(2026, time.October, 1, 0, 0, 0, 0, time.UTC)), GroupBy: []anthropic.BetaAnalyticsCostGroupBy{anthropic.BetaAnalyticsCostGroupByModel, anthropic.BetaAnalyticsCostGroupByCostType, anthropic.BetaAnalyticsCostGroupByTokenType}, }) for rows.Next() { row := rows.Current() fmt.Printf("%s %s %s: %s\n", row.Group.Model, row.Group.CostType, row.Group.TokenType, row.Cost.Amount) } if err := rows.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.beta.organization.analytics.cost.BetaAnalyticsCostGroupBy; import com.anthropic.models.beta.organization.analytics.cost.CostListParams; import java.time.OffsetDateTime; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = CostListParams.builder() .startingAt(OffsetDateTime.parse("2026-09-01T00:00:00Z")) .endingAt(OffsetDateTime.parse("2026-10-01T00:00:00Z")) .addGroupBy(BetaAnalyticsCostGroupBy.MODEL) .addGroupBy(BetaAnalyticsCostGroupBy.COST_TYPE) .addGroupBy(BetaAnalyticsCostGroupBy.TOKEN_TYPE) .build(); var rows = client.beta().organization().analytics().cost().list(params); for (var row : rows.autoPager()) { var group = row.group(); IO.println( group.model().orElse(null) + " " + group.costType().orElse(null) + " " + group.tokenType().orElse(null) + ": " + row.cost().amount() ); } } ``` ```php PHP $client = new Client(); $rows = $client->beta->organization->analytics->cost->list( startingAt: new \DateTimeImmutable('2026-09-01T00:00:00Z'), endingAt: new \DateTimeImmutable('2026-10-01T00:00:00Z'), groupBy: ['model', 'cost_type', 'token_type'], ); foreach ($rows->pagingEachItem() as $row) { $group = $row->group; echo "{$group->model} {$group->costType} {$group->tokenType}: {$row->cost->amount}\n"; } ``` ```ruby Ruby client = Anthropic::Client.new page = client.beta.organization.analytics.cost.list( starting_at: Time.utc(2026, 9, 1), ending_at: Time.utc(2026, 10, 1), group_by: [:model, :cost_type, :token_type] ) page.auto_paging_each do |row| group = row.group puts "#{group.model} #{group.cost_type} #{group.token_type}: #{row.cost.amount}" end ``` Für jedes Modell enthält die Antwort fünf `tokens`-Zeilen (eine für jeden Token-Typ) sowie je eine Zeile für `web_search`, `code_execution` und `session_usage`. Eine dieser Zeilen: ```json { "starting_at": "2026-09-01T00:00:00Z", "ending_at": "2026-10-01T00:00:00Z", "group": { "model": "claude-opus-5", ..., "cost_type": "tokens", "token_type": "cache_read_input_tokens" }, "cost": { "currency": "USD", "amount": "41280.000000", "list_amount": "51600.000000", "requests": null } } ``` Das `group`-Objekt enthält jede Dimension und ist hier gekürzt. Wenn `group_by[]=cost_type` oder `token_type` angegeben ist, ist `requests` in jeder Zeile `null`. Anfragen, die im Rahmen einer Priority-Tier-Verpflichtung bedient werden, erscheinen beim Usage-Endpunkt mit `service_tier: "priority"`, tragen aber keine Token-Kosten zu `amount` und `list_amount` bei, da deine Verpflichtung sie abdeckt; die Verpflichtungsgebühr wird separat abgerechnet und ist nicht in diesen Daten enthalten. Websuche bei diesen Anfragen wird zum Standardtarif abgerechnet. Anfragen über deine zugesagte Kapazität hinaus werden im Standard-Tier bedient und bepreist. ## Datumsbereiche und Zeitintervalle * Zeitstempel sind im Format RFC 3339 mit UTC-Offset, zum Beispiel `2026-09-01T00:00:00Z`. `starting_at` ist inklusiv und `ending_at` exklusiv. * `starting_at` muss am oder nach dem 1. Januar 2026 und innerhalb der letzten 365 Tage liegen. Eine Anfrage kann höchstens 31 Tage umfassen; `ending_at` ist standardmäßig 31 Tage nach `starting_at` oder die aktuelle Zeit, je nachdem, was früher ist. * `ending_at` ist erforderlich, sobald `time_bucket_width` gesetzt ist, und mit `time_bucket_width=1m` kann eine Anfrage höchstens 24 Stunden umfassen. * Beide Enden des Bereichs werden auf eine UTC-Intervallgrenze abgerundet, oder auf die volle Stunde, wenn `time_bucket_width` nicht gesetzt ist. Zum Beispiel wird mit `time_bucket_width=1h` ein `starting_at` von `2026-09-01T10:43:00Z` als `2026-09-01T10:00:00Z` und ein `ending_at` von `2026-09-01T15:43:00Z` als `2026-09-01T15:00:00Z` behandelt, sodass die Antwort 10:00 bis 15:00 UTC abdeckt. ## Datenaktualität Jede Antwort enthält einen `data_refreshed_at`-Zeitstempel, und Nutzung nach diesem Zeitpunkt fehlt oder ist unvollständig. Wenn für keinen Teil des angefragten Zeitraums bereits Daten verfügbar sind, ist `data_refreshed_at` `null` und `data` leer. Daten werden in der Regel innerhalb von 4 Stunden nach der zugrunde liegenden Nutzung aktualisiert, es kann aber bis zu 24 Stunden dauern. Werte können überarbeitet werden, wenn verspätete Ereignisse eintreffen und Abgleiche laufen, bis etwa 7 Tage nach Ende des Kalendermonats. Beispielsweise können sich Werte für den 1. Oktober bis etwa zum 7. November ändern. Für stabile Ergebnisse über wiederholte Aufrufe hinweg setze `ending_at` auf oder vor einen `data_refreshed_at`-Wert, den du bereits gesehen hast; für endgültige Summen frage nur Monate ab, die vor mindestens 7 Tagen geendet haben. Jede Seite einer paginierten Abfrage liest denselben Daten-Snapshot, daher ist `data_refreshed_at` auf allen Seiten identisch. ## Migration von der Usage and Cost API Dieser Abschnitt richtet sich an Claude Console-Organisationen, die die veraltete [Usage and Cost API](https://platform.claude.com/docs/de/manage-claude/usage-cost-api) (`/v1/organizations/usage_report/messages` und `/v1/organizations/cost_report`) aufrufen. Dein Admin-API-Key, der `anthropic-version`-Header, `starting_at` und `ending_at`, die Werte für die Intervallbreite (`1m`, `1h`, `1d`), die Klammernotation, die Namen der Paginierungsfelder sowie die Namen der Token- und Kostenfelder bleiben gleich. Was sich ändert: | Usage and Cost API | Usage and Cost Analytics API | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Kein Beta-Header | `anthropic-beta: analytics-usage-cost-2026-08-24` bei jeder Anfrage | | Daten erscheinen in der Regel innerhalb von 5 Minuten | Daten werden in der Regel innerhalb von 4 Stunden aktualisiert, es kann aber bis zu 24 Stunden dauern (siehe [Datenaktualität](https://platform.claude.com/docs/de/manage-claude/usage-cost-analytics-api#data-freshness)) | | `data` ist eine Liste von Zeitintervallen, die älteste zuerst, einschließlich leerer, jeweils mit einer `results`-Liste, deren Einträge Dimensionen und Metriken nebeneinander enthalten | `data` ist eine nach `order_by` sortierte Liste von Zeilen, jede mit eigenem `starting_at` und `ending_at`, Dimensionen in `group` und Metriken in `usage` oder `cost`. Kombinationen ohne Nutzung oder Kosten haben keine Zeile. | | `bucket_width`, Standardwert `1d` | `time_bucket_width`, kein Standardwert. Übergib `time_bucket_width=1d`, um tägliche Zeilen beizubehalten; lass es weg, um Summen über den gesamten Zeitraum zu erhalten. Der Cost-Endpunkt akzeptiert außerdem jeden Filter sowie Zeitintervalle von `1m` und `1h`. | | `limit` zählt Zeitintervalle pro Seite | `limit` zählt Zeilen pro Seite (1 bis 1.000, Standardwert 20), daher hängt die Anzahl der Seiten davon ab, wie viele Kombinationen Daten haben | | Beliebiger Datumsbereich, vorwärts nach Zeitintervall paginiert | `starting_at` am oder nach dem 1. Januar 2026 und innerhalb der letzten 365 Tage, höchstens 31 Tage pro Anfrage, `ending_at` erforderlich mit `time_bucket_width` und höchstens 24 Stunden mit `1m`-Zeitintervallen (siehe [Datumsbereiche und Zeitintervalle](https://platform.claude.com/docs/de/manage-claude/usage-cost-analytics-api#date-ranges-and-time-buckets)). Teile längere Zeiträume auf mehrere Anfragen auf. | | `account_ids[]`, `service_account_ids[]`, `group_by[]=account_id`, `group_by[]=service_account_id` | `actor_ids[]` mit denselben getaggten IDs sowie `group_by[]=actor` oder `actor_type`; lies `actor.user_id` oder `actor.service_account_id`. Siehe [Akteure](https://platform.claude.com/docs/de/manage-claude/usage-cost-analytics-api#actors). | | `context_window[]` | `context_windows[]` | | `group_by[]=description` im Kostenbericht, mit einem `description`-String | Kein `description`. Gruppiere stattdessen nach den strukturierten Dimensionen: beliebige von `model`, `cost_type`, `token_type`, `context_window`, `service_tier`, `inference_geo` und `speed`, die alle in eine Anfrage passen. | | Ein unbekannter API-Key oder eine unbekannte Workspace-ID gibt einen Fehler zurück | Sie passt auf nichts, ebenso wie ein falsch geschriebener `models[]`-Name. Jede Liste akzeptiert bis zu 100 Werte. | | `workspace_id: null` für den Standard-Workspace | Die tatsächliche `workspace_id` des Standard-Workspace (siehe [Wie wird der Standard-Workspace dargestellt?](https://platform.claude.com/docs/de/manage-claude/usage-cost-analytics-api#how-is-the-default-workspace-represented)) | | `inference_geo: "not_available"` und `service_tier: "standard"` bei Nutzung ohne Inference-Geo oder Tier | `null` für beide. `inference_geos[]=not_available` passt weiterhin auf die Zeilen ohne Inference-Geo. | | Kosten-`service_tier` ist `standard` oder `batch`; `amount` etwa `"123.45"` | Der tatsächliche Tier; `amount` mit sechs Dezimalstellen, etwa `"123.450000"`, plus `list_amount`. | | Code Execution nicht im Nutzungsbericht; keine Anfragezahlen | Code Execution erscheint als Nutzungszeilen mit `model: null`; fügt `requests` bei beiden Endpunkten und `total_tokens` bei Nutzungszeilen hinzu | Um den veralteten Tagesbericht nachzubilden, fordere `time_bucket_width=1d` mit demselben `group_by[]` an, blättere mit `limit=1000` durch die Seiten, gruppiere dann die Zeilen nach `starting_at` und fülle fehlende Tage mit Nullen auf. Füge `order_by=time&order=asc` hinzu, um die Tage in der richtigen Reihenfolge zu erhalten. Tägliche Nutzung nach Modell für 1 Woche, vorher: ```bash cURL curl --globoff "https://api.anthropic.com/v1/organizations/usage_report/messages?\ starting_at=2026-09-01T00:00:00Z&\ ending_at=2026-09-08T00:00:00Z&\ group_by[]=model&\ bucket_width=1d" \ -H "anthropic-version: 2023-06-01" \ -H "x-api-key: $ANTHROPIC_API_KEY" ``` und nachher: ```bash cURL curl --globoff "https://api.anthropic.com/v1/organizations/analytics/usage?\ starting_at=2026-09-01T00:00:00Z&\ ending_at=2026-09-08T00:00:00Z&\ group_by[]=model&\ time_bucket_width=1d&\ limit=1000" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: analytics-usage-cost-2026-08-24" \ -H "x-api-key: $ANTHROPIC_API_KEY" ``` ```bash CLI ant beta:organization:analytics:usage list \ --starting-at 2026-09-01T00:00:00Z \ --ending-at 2026-09-08T00:00:00Z \ --time-bucket-width 1d \ --group-by model \ --limit 1000 ``` ```python Python client = anthropic.Anthropic() rows = client.beta.organization.analytics.usage.list( starting_at="2026-09-01T00:00:00Z", ending_at="2026-09-08T00:00:00Z", time_bucket_width="1d", group_by=["model"], limit=1000, ) for row in rows: print(f"{row.starting_at} {row.group.model}: {row.usage.total_tokens}") ``` ```typescript TypeScript const client = new Anthropic(); const rows = await client.beta.organization.analytics.usage.list({ starting_at: "2026-09-01T00:00:00Z", ending_at: "2026-09-08T00:00:00Z", time_bucket_width: "1d", group_by: ["model"], limit: 1000 }); for await (const row of rows) { console.log(`${row.starting_at} ${row.group.model}: ${row.usage.total_tokens}`); } ``` ```csharp C# using Anthropic.Models.Beta.Organization.Analytics; using Anthropic.Models.Beta.Organization.Analytics.Usage; AnthropicClient client = new(); var page = await client.Beta.Organization.Analytics.Usage.List( new() { StartingAt = DateTimeOffset.Parse("2026-09-01T00:00:00Z"), EndingAt = DateTimeOffset.Parse("2026-09-08T00:00:00Z"), TimeBucketWidth = BetaAnalyticsTimeBucketWidth.Day, GroupBy = [BetaAnalyticsUsageGroupBy.Model], Limit = 1000, } ); await foreach (var row in page.Paginate()) { Console.WriteLine($"{row.StartingAt} {row.Group.Model}: {row.Usage.TotalTokens}"); } ``` ```go Go client := anthropic.NewClient() rows := client.Beta.Organization.Analytics.Usage.ListAutoPaging(context.Background(), anthropic.BetaOrganizationAnalyticsUsageListParams{ StartingAt: time.Date(2026, time.September, 1, 0, 0, 0, 0, time.UTC), EndingAt: anthropic.Time(time.Date(2026, time.September, 8, 0, 0, 0, 0, time.UTC)), TimeBucketWidth: anthropic.BetaAnalyticsTimeBucketWidthDay, GroupBy: []anthropic.BetaAnalyticsUsageGroupBy{anthropic.BetaAnalyticsUsageGroupByModel}, Limit: anthropic.Int(1000), }) for rows.Next() { row := rows.Current() fmt.Printf("%s %s: %d\n", row.StartingAt.Format(time.RFC3339), row.Group.Model, row.Usage.TotalTokens) } if err := rows.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.beta.organization.analytics.BetaAnalyticsTimeBucketWidth; import com.anthropic.models.beta.organization.analytics.usage.BetaAnalyticsUsageGroupBy; import com.anthropic.models.beta.organization.analytics.usage.UsageListParams; import java.time.OffsetDateTime; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = UsageListParams.builder() .startingAt(OffsetDateTime.parse("2026-09-01T00:00:00Z")) .endingAt(OffsetDateTime.parse("2026-09-08T00:00:00Z")) .timeBucketWidth(BetaAnalyticsTimeBucketWidth.DAY) .addGroupBy(BetaAnalyticsUsageGroupBy.MODEL) .limit(1000) .build(); var rows = client.beta().organization().analytics().usage().list(params); for (var row : rows.autoPager()) { IO.println(row.startingAt() + " " + row.group().model().orElse(null) + ": " + row.usage().totalTokens()); } } ``` ```php PHP $client = new Client(); $rows = $client->beta->organization->analytics->usage->list( startingAt: new \DateTimeImmutable('2026-09-01T00:00:00Z'), endingAt: new \DateTimeImmutable('2026-09-08T00:00:00Z'), timeBucketWidth: '1d', groupBy: ['model'], limit: 1000, ); foreach ($rows->pagingEachItem() as $row) { $startingAt = $row->startingAt->format(\DateTimeInterface::ATOM); echo "{$startingAt} {$row->group->model}: {$row->usage->totalTokens}\n"; } ``` ```ruby Ruby client = Anthropic::Client.new page = client.beta.organization.analytics.usage.list( starting_at: Time.utc(2026, 9, 1), ending_at: Time.utc(2026, 9, 8), time_bucket_width: :"1d", group_by: [:model], limit: 1000 ) page.auto_paging_each do |row| puts "#{row.starting_at} #{row.group.model}: #{row.usage.total_tokens}" end ``` Tägliche Kosten nach Workspace, Modell, Service-Tier, Kontextfenster und Inference-Geo, aufgeteilt nach Kostentyp und Token-Typ: ```bash cURL curl --globoff "https://api.anthropic.com/v1/organizations/analytics/cost?\ starting_at=2026-09-01T00:00:00Z&\ ending_at=2026-09-08T00:00:00Z&\ time_bucket_width=1d&\ group_by[]=workspace_id&\ group_by[]=model&\ group_by[]=service_tier&\ group_by[]=context_window&\ group_by[]=inference_geo&\ group_by[]=cost_type&\ group_by[]=token_type&\ limit=1000" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: analytics-usage-cost-2026-08-24" \ -H "x-api-key: $ANTHROPIC_API_KEY" ``` ```bash CLI ant beta:organization:analytics:cost list \ --starting-at 2026-09-01T00:00:00Z \ --ending-at 2026-09-08T00:00:00Z \ --time-bucket-width 1d \ --group-by workspace_id \ --group-by model \ --group-by service_tier \ --group-by context_window \ --group-by inference_geo \ --group-by cost_type \ --group-by token_type \ --limit 1000 ``` ```python Python client = anthropic.Anthropic() rows = client.beta.organization.analytics.cost.list( starting_at="2026-09-01T00:00:00Z", ending_at="2026-09-08T00:00:00Z", time_bucket_width="1d", group_by=[ "workspace_id", "model", "service_tier", "context_window", "inference_geo", "cost_type", "token_type", ], limit=1000, ) for row in rows: group = row.group print( f"{row.starting_at} {group.workspace_id} {group.model} {group.service_tier} " f"{group.context_window} {group.inference_geo} {group.cost_type} {group.token_type}: " f"{row.cost.amount}" ) ``` ```typescript TypeScript const client = new Anthropic(); const rows = await client.beta.organization.analytics.cost.list({ starting_at: "2026-09-01T00:00:00Z", ending_at: "2026-09-08T00:00:00Z", time_bucket_width: "1d", group_by: [ "workspace_id", "model", "service_tier", "context_window", "inference_geo", "cost_type", "token_type" ], limit: 1000 }); for await (const row of rows) { const { group } = row; console.log( `${row.starting_at} ${group.workspace_id} ${group.model} ${group.service_tier} ` + `${group.context_window} ${group.inference_geo} ${group.cost_type} ${group.token_type}: ` + `${row.cost.amount}` ); } ``` ```csharp C# using Anthropic.Models.Beta.Organization.Analytics; using Anthropic.Models.Beta.Organization.Analytics.Cost; AnthropicClient client = new(); var page = await client.Beta.Organization.Analytics.Cost.List( new() { StartingAt = DateTimeOffset.Parse("2026-09-01T00:00:00Z"), EndingAt = DateTimeOffset.Parse("2026-09-08T00:00:00Z"), TimeBucketWidth = BetaAnalyticsTimeBucketWidth.Day, GroupBy = [ BetaAnalyticsCostGroupBy.WorkspaceID, BetaAnalyticsCostGroupBy.Model, BetaAnalyticsCostGroupBy.ServiceTier, BetaAnalyticsCostGroupBy.ContextWindow, BetaAnalyticsCostGroupBy.InferenceGeo, BetaAnalyticsCostGroupBy.CostType, BetaAnalyticsCostGroupBy.TokenType, ], Limit = 1000, } ); await foreach (var row in page.Paginate()) { var group = row.Group; Console.WriteLine( $"{row.StartingAt} {group.WorkspaceID} {group.Model} {group.ServiceTier?.Raw()} " + $"{group.ContextWindow?.Raw()} {group.InferenceGeo?.Raw()} {group.CostType?.Raw()} " + $"{group.TokenType?.Raw()}: {row.Cost.Amount}" ); } ``` ```go Go client := anthropic.NewClient() rows := client.Beta.Organization.Analytics.Cost.ListAutoPaging(context.Background(), anthropic.BetaOrganizationAnalyticsCostListParams{ StartingAt: time.Date(2026, time.September, 1, 0, 0, 0, 0, time.UTC), EndingAt: anthropic.Time(time.Date(2026, time.September, 8, 0, 0, 0, 0, time.UTC)), TimeBucketWidth: anthropic.BetaAnalyticsTimeBucketWidthDay, GroupBy: []anthropic.BetaAnalyticsCostGroupBy{ anthropic.BetaAnalyticsCostGroupByWorkspaceID, anthropic.BetaAnalyticsCostGroupByModel, anthropic.BetaAnalyticsCostGroupByServiceTier, anthropic.BetaAnalyticsCostGroupByContextWindow, anthropic.BetaAnalyticsCostGroupByInferenceGeo, anthropic.BetaAnalyticsCostGroupByCostType, anthropic.BetaAnalyticsCostGroupByTokenType, }, Limit: anthropic.Int(1000), }) for rows.Next() { row := rows.Current() group := row.Group fmt.Printf("%s %s %s %s %s %s %s %s: %s\n", row.StartingAt.Format(time.RFC3339), group.WorkspaceID, group.Model, group.ServiceTier, group.ContextWindow, group.InferenceGeo, group.CostType, group.TokenType, row.Cost.Amount) } if err := rows.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.beta.organization.analytics.BetaAnalyticsTimeBucketWidth; import com.anthropic.models.beta.organization.analytics.cost.BetaAnalyticsCostGroupBy; import com.anthropic.models.beta.organization.analytics.cost.CostListParams; import java.time.OffsetDateTime; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = CostListParams.builder() .startingAt(OffsetDateTime.parse("2026-09-01T00:00:00Z")) .endingAt(OffsetDateTime.parse("2026-09-08T00:00:00Z")) .timeBucketWidth(BetaAnalyticsTimeBucketWidth.DAY) .addGroupBy(BetaAnalyticsCostGroupBy.WORKSPACE_ID) .addGroupBy(BetaAnalyticsCostGroupBy.MODEL) .addGroupBy(BetaAnalyticsCostGroupBy.SERVICE_TIER) .addGroupBy(BetaAnalyticsCostGroupBy.CONTEXT_WINDOW) .addGroupBy(BetaAnalyticsCostGroupBy.INFERENCE_GEO) .addGroupBy(BetaAnalyticsCostGroupBy.COST_TYPE) .addGroupBy(BetaAnalyticsCostGroupBy.TOKEN_TYPE) .limit(1000) .build(); var rows = client.beta().organization().analytics().cost().list(params); for (var row : rows.autoPager()) { var group = row.group(); IO.println( row.startingAt() + " " + group.workspaceId().orElse(null) + " " + group.model().orElse(null) + " " + group.serviceTier().orElse(null) + " " + group.contextWindow().orElse(null) + " " + group.inferenceGeo().orElse(null) + " " + group.costType().orElse(null) + " " + group.tokenType().orElse(null) + ": " + row.cost().amount() ); } } ``` ```php PHP $client = new Client(); $rows = $client->beta->organization->analytics->cost->list( startingAt: new \DateTimeImmutable('2026-09-01T00:00:00Z'), endingAt: new \DateTimeImmutable('2026-09-08T00:00:00Z'), timeBucketWidth: '1d', groupBy: [ 'workspace_id', 'model', 'service_tier', 'context_window', 'inference_geo', 'cost_type', 'token_type', ], limit: 1000, ); foreach ($rows->pagingEachItem() as $row) { $startingAt = $row->startingAt->format(\DateTimeInterface::ATOM); $group = $row->group; echo "{$startingAt} {$group->workspaceID} {$group->model} {$group->serviceTier} " . "{$group->contextWindow} {$group->inferenceGeo} {$group->costType} {$group->tokenType}: " . "{$row->cost->amount}\n"; } ``` ```ruby Ruby client = Anthropic::Client.new page = client.beta.organization.analytics.cost.list( starting_at: Time.utc(2026, 9, 1), ending_at: Time.utc(2026, 9, 8), time_bucket_width: :"1d", group_by: [ :workspace_id, :model, :service_tier, :context_window, :inference_geo, :cost_type, :token_type ], limit: 1000 ) page.auto_paging_each do |row| group = row.group puts "#{row.starting_at} #{group.workspace_id} #{group.model} #{group.service_tier} " \ "#{group.context_window} #{group.inference_geo} #{group.cost_type} #{group.token_type}: " \ "#{row.cost.amount}" end ``` ## Migration von den Claude Enterprise-Nutzungs- und Kostenberichten Dieser Abschnitt richtet sich an Claude Enterprise-Organisationen, die die Berichtsendpunkte `usage_report`, `cost_report`, `user_usage_report` und `user_cost_report` der [Claude Enterprise Analytics API](https://platform.claude.com/docs/de/manage-claude/analytics-api) unter `/v1/organizations/analytics/` aufrufen. Diese Endpunkte sind veraltet und werden weiterhin unterstützt. Wechsle zu `/analytics/usage` und `/analytics/cost`, wenn du eines der folgenden Dinge möchtest: * Jede Gruppe in jedem Zeitintervall statt der 100 größten Gruppen pro Zeitintervall * Gruppierung nach `actor` oder `actor_type` zusammen mit anderen Dimensionen, sowohl bei Nutzung als auch bei Kosten * Zeilen, die nach einer Metrik deiner Wahl über den gesamten Zeitraum sortiert oder nach Zeitintervall geordnet sind * Eine Integration, die auch Organisationen in der Claude Console bedient Dein Key, das früheste Datum, der Rückblick von 365 Tagen und die Spanne von 31 Tagen, die Namen und Werte der Filter und Dimensionen (außer `user_ids[]` und dem Produktwert für Claude Tag), die `actor`-Felder für Benutzer, die Metrik- und Betragsfelder, `data_refreshed_at`, die Cursor-Regeln und das [Ratenlimit auf Organisationsebene](https://platform.claude.com/docs/de/manage-claude/analytics-api#working-with-the-api) bleiben unverändert. Der einzige neue Header ist der Beta-Header `analytics-usage-cost-2026-08-24`. Was sich ändert: | Claude Enterprise-Berichte | Usage and Cost Analytics API | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `usage_report` und `cost_report` geben Zeitintervalle zurück, das älteste zuerst, einschließlich leerer, die jeweils höchstens ihre 100 größten Gruppen enthalten; `bucket_width` hat den Standardwert `1d` und `limit` zählt Zeitintervalle | Zeilen, die jede Kombination mit Daten abdecken, sortiert nach `order_by`, jede mit eigenem `starting_at` und `ending_at`, Dimensionen in `group` und Metriken in `usage` oder `cost`. `time_bucket_width` ist optional und `limit` zählt Zeilen. | | Der Parameter für Zeitintervalle ist `bucket_width` | Er heißt `time_bucket_width`, mit denselben Werten | | Bei `usage_report` und `cost_report` ist `ending_at` mit `bucket_width` optional, und `1m`-Zeitintervalle können bis zu 31 Tage umfassen | `ending_at` erforderlich mit `time_bucket_width`; `1m`-Zeitintervalle umfassen höchstens 24 Stunden pro Anfrage | | `user_usage_report` und `user_cost_report` geben eine Zeile pro Benutzer zurück | `group_by[]=actor&actor_types[]=user_actor`. Ohne den Filter erhältst du außerdem Zeilen für Identitäten, die keine Benutzer sind, sowie eine Zeile mit `actor: null` für nicht zugeordnete Nutzung. | | Nutzung von Claude Tag hat `product: "claude-tag"` | `product: "claude_tag"`; `products[]` akzeptiert beide Schreibweisen | | Ein nicht erkannter `models[]`-Name gibt einen 400-Fehler zurück | Er passt auf nichts | | `user_ids[]` | `actor_ids[]` mit denselben getaggten `user_...`-IDs | | `exclude_deleted_users` bei den Berichten pro Benutzer | Erfordert `group_by[]=actor`; ohne dies gibt die Anfrage einen 400-Fehler zurück. Es entfernt nur Zeilen, deren `actor` ein Benutzer mit `deleted: true` ist; Zeilen für andere Identitäten und Zeilen mit `actor: null` bleiben erhalten. | Kosten pro Benutzer für einen Monat, vorher: ```bash cURL curl "https://api.anthropic.com/v1/organizations/analytics/user_cost_report?\ starting_at=2026-09-01T00:00:00Z&\ ending_at=2026-10-01T00:00:00Z&\ limit=100" \ -H "anthropic-version: 2023-06-01" \ -H "x-api-key: $ANTHROPIC_API_KEY" ``` ```bash CLI ant beta:organization:analytics:user-cost-report list \ --starting-at 2026-09-01T00:00:00Z \ --ending-at 2026-10-01T00:00:00Z \ --limit 100 ``` ```python Python client = anthropic.Anthropic() rows = client.beta.organization.analytics.user_cost_report.list( starting_at="2026-09-01T00:00:00Z", ending_at="2026-10-01T00:00:00Z", limit=100, ) for row in rows: print(f"{row.actor.user_id}: {row.amount}") ``` ```typescript TypeScript const client = new Anthropic(); const rows = await client.beta.organization.analytics.userCostReport.list({ starting_at: "2026-09-01T00:00:00Z", ending_at: "2026-10-01T00:00:00Z", limit: 100 }); for await (const row of rows) { console.log(`${row.actor.user_id}: ${row.amount}`); } ``` ```csharp C# AnthropicClient client = new(); var page = await client.Beta.Organization.Analytics.UserCostReport.List( new() { StartingAt = DateTimeOffset.Parse("2026-09-01T00:00:00Z"), EndingAt = DateTimeOffset.Parse("2026-10-01T00:00:00Z"), Limit = 100, } ); await foreach (var row in page.Paginate()) { Console.WriteLine($"{row.Actor.UserID}: {row.Amount}"); } ``` ```go Go client := anthropic.NewClient() rows := client.Beta.Organization.Analytics.UserCostReport.ListAutoPaging(context.Background(), anthropic.BetaOrganizationAnalyticsUserCostReportListParams{ StartingAt: time.Date(2026, time.September, 1, 0, 0, 0, 0, time.UTC), EndingAt: anthropic.Time(time.Date(2026, time.October, 1, 0, 0, 0, 0, time.UTC)), Limit: anthropic.Int(100), }) for rows.Next() { row := rows.Current() fmt.Printf("%s: %s\n", row.Actor.UserID, row.Amount) } if err := rows.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.beta.organization.analytics.usercostreport.UserCostReportListParams; import java.time.OffsetDateTime; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = UserCostReportListParams.builder() .startingAt(OffsetDateTime.parse("2026-09-01T00:00:00Z")) .endingAt(OffsetDateTime.parse("2026-10-01T00:00:00Z")) .limit(100) .build(); var rows = client.beta().organization().analytics().userCostReport().list(params); for (var row : rows.autoPager()) { IO.println(row.actor().userId() + ": " + row.amount()); } } ``` ```php PHP $client = new Client(); $rows = $client->beta->organization->analytics->userCostReport->list( startingAt: new \DateTimeImmutable('2026-09-01T00:00:00Z'), endingAt: new \DateTimeImmutable('2026-10-01T00:00:00Z'), limit: 100, ); foreach ($rows->pagingEachItem() as $row) { echo "{$row->actor->userID}: {$row->amount}\n"; } ``` ```ruby Ruby client = Anthropic::Client.new page = client.beta.organization.analytics.user_cost_report.list( starting_at: Time.utc(2026, 9, 1), ending_at: Time.utc(2026, 10, 1), limit: 100 ) page.auto_paging_each do |row| puts "#{row.actor.user_id}: #{row.amount}" end ``` und nachher, mit zusätzlicher Aufschlüsselung nach Produkt: ```bash cURL curl --globoff "https://api.anthropic.com/v1/organizations/analytics/cost?\ starting_at=2026-09-01T00:00:00Z&\ ending_at=2026-10-01T00:00:00Z&\ group_by[]=actor&\ group_by[]=product&\ actor_types[]=user_actor&\ limit=100" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: analytics-usage-cost-2026-08-24" \ -H "x-api-key: $ANTHROPIC_API_KEY" ``` ```bash CLI ant beta:organization:analytics:cost list \ --starting-at 2026-09-01T00:00:00Z \ --ending-at 2026-10-01T00:00:00Z \ --actor-type user_actor \ --group-by actor \ --group-by product \ --limit 100 ``` ```python Python client = anthropic.Anthropic() rows = client.beta.organization.analytics.cost.list( starting_at="2026-09-01T00:00:00Z", ending_at="2026-10-01T00:00:00Z", actor_types=["user_actor"], group_by=["actor", "product"], limit=100, ) for row in rows: actor = row.group.actor if actor is not None and actor.type == "user_actor": print(f"{actor.user_id} {row.group.product}: {row.cost.amount}") ``` ```typescript TypeScript const client = new Anthropic(); const rows = await client.beta.organization.analytics.cost.list({ starting_at: "2026-09-01T00:00:00Z", ending_at: "2026-10-01T00:00:00Z", actor_types: ["user_actor"], group_by: ["actor", "product"], limit: 100 }); for await (const row of rows) { const { actor } = row.group; if (actor?.type === "user_actor") { console.log(`${actor.user_id} ${row.group.product}: ${row.cost.amount}`); } } ``` ```csharp C# using Anthropic.Models.Beta.Organization.Analytics; using Anthropic.Models.Beta.Organization.Analytics.Cost; AnthropicClient client = new(); var page = await client.Beta.Organization.Analytics.Cost.List( new() { StartingAt = DateTimeOffset.Parse("2026-09-01T00:00:00Z"), EndingAt = DateTimeOffset.Parse("2026-10-01T00:00:00Z"), ActorTypes = [BetaAnalyticsActorType.UserActor], GroupBy = [BetaAnalyticsCostGroupBy.Actor, BetaAnalyticsCostGroupBy.Product], Limit = 100, } ); await foreach (var row in page.Paginate()) { if (row.Group.Actor is { } actor && actor.TryPickReportUser(out var user)) { Console.WriteLine($"{user.UserID} {row.Group.Product}: {row.Cost.Amount}"); } } ``` ```go Go client := anthropic.NewClient() rows := client.Beta.Organization.Analytics.Cost.ListAutoPaging(context.Background(), anthropic.BetaOrganizationAnalyticsCostListParams{ StartingAt: time.Date(2026, time.September, 1, 0, 0, 0, 0, time.UTC), EndingAt: anthropic.Time(time.Date(2026, time.October, 1, 0, 0, 0, 0, time.UTC)), ActorTypes: []anthropic.BetaAnalyticsActorType{anthropic.BetaAnalyticsActorTypeUserActor}, GroupBy: []anthropic.BetaAnalyticsCostGroupBy{anthropic.BetaAnalyticsCostGroupByActor, anthropic.BetaAnalyticsCostGroupByProduct}, Limit: anthropic.Int(100), }) for rows.Next() { row := rows.Current() if user, ok := row.Group.Actor.AsAny().(anthropic.BetaAnalyticsReportUserActor); ok { fmt.Printf("%s %s: %s\n", user.UserID, row.Group.Product, row.Cost.Amount) } } if err := rows.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.beta.organization.analytics.BetaAnalyticsActorType; import com.anthropic.models.beta.organization.analytics.cost.BetaAnalyticsCostGroupBy; import com.anthropic.models.beta.organization.analytics.cost.CostListParams; import java.time.OffsetDateTime; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = CostListParams.builder() .startingAt(OffsetDateTime.parse("2026-09-01T00:00:00Z")) .endingAt(OffsetDateTime.parse("2026-10-01T00:00:00Z")) .addActorType(BetaAnalyticsActorType.USER_ACTOR) .addGroupBy(BetaAnalyticsCostGroupBy.ACTOR) .addGroupBy(BetaAnalyticsCostGroupBy.PRODUCT) .limit(100) .build(); var rows = client.beta().organization().analytics().cost().list(params); for (var row : rows.autoPager()) { row.group().actor().flatMap(actor -> actor.user()).ifPresent(user -> IO.println(user.userId() + " " + row.group().product().orElse(null) + ": " + row.cost().amount()) ); } } ``` ```php PHP use Anthropic\Beta\Organization\Analytics\AnalyticsReportUserActor; // ... $client = new Client(); $rows = $client->beta->organization->analytics->cost->list( startingAt: new \DateTimeImmutable('2026-09-01T00:00:00Z'), endingAt: new \DateTimeImmutable('2026-10-01T00:00:00Z'), actorTypes: ['user_actor'], groupBy: ['actor', 'product'], limit: 100, ); foreach ($rows->pagingEachItem() as $row) { $actor = $row->group->actor; if ($actor instanceof AnalyticsReportUserActor) { echo "{$actor->userID} {$row->group->product}: {$row->cost->amount}\n"; } } ``` ```ruby Ruby client = Anthropic::Client.new page = client.beta.organization.analytics.cost.list( starting_at: Time.utc(2026, 9, 1), ending_at: Time.utc(2026, 10, 1), actor_types: [:user_actor], group_by: [:actor, :product], limit: 100 ) page.auto_paging_each do |row| actor = row.group.actor if actor.is_a?(Anthropic::Models::Beta::Organization::BetaAnalyticsReportUserActor) puts "#{actor.user_id} #{row.group.product}: #{row.cost.amount}" end end ``` ## Häufig gestellte Fragen ### Wie wird der Standard-Workspace dargestellt? Der Standard-Workspace einer Organisation in der Claude Console hat wie jeder andere Workspace eine eigene `wrkspc_`-ID. Zeilen für den Standard-Workspace enthalten diese ID in `workspace_id`, und du kannst mit `workspace_ids[]` danach filtern. [List Workspaces](https://platform.claude.com/docs/de/api/organization/workspaces/list) lässt den Standard-Workspace weg, es sei denn, du übergibst `include_default=true`. Um zu prüfen, ob eine unbekannte `workspace_id` der Standard-Workspace ist, übergib sie an [Get Workspace](https://platform.claude.com/docs/de/api/organization/workspaces/retrieve): Der Standard-Workspace gibt `"name": "Default"` zurück. ### Wie erhalte ich Kosten pro Benutzer für Claude Code? Rufe den Cost-Endpunkt mit `products[]=claude_code&group_by[]=actor` auf. Claude Console-Organisationen können auch die [Claude Code Analytics API](https://platform.claude.com/docs/de/manage-claude/claude-code-analytics-api) verwenden, die Claude Code-Aktivität und geschätzte Kosten pro Benutzer liefert. ## Siehe auch * [Usage and Cost API](https://platform.claude.com/docs/de/manage-claude/usage-cost-api) (veraltet) * [Analytics APIs](https://platform.claude.com/docs/de/manage-claude/analytics-api): welche Analytics API und welchen Key-Typ deine Organisation benötigt * [Claude Code Analytics API](https://platform.claude.com/docs/de/manage-claude/claude-code-analytics-api) * [Admin-API-Referenz](https://platform.claude.com/docs/de/api/beta/organization) * [Preise](https://platform.claude.com/docs/de/about-claude/pricing)