--- title: API Usage and Cost Analytics url: https://platform.claude.com/docs/fr/manage-claude/usage-cost-analytics-api description: Interrogez l'utilisation des tokens et les coûts de votre organisation Claude Console ou Claude Enterprise par modèle, espace de travail, clé API, acteur, et plus encore. --- **L’Admin API n’est pas disponible pour les comptes individuels.** Pour collaborer avec vos coéquipiers et ajouter des membres, configurez votre organisation sur la page [Organization](https://platform.claude.com/settings/organization) (`platform.claude.com/settings/organization`) dans la Claude Console. L’API Usage and Cost Analytics rapporte l’historique de l’utilisation des tokens et des coûts de votre organisation, ventilé selon les dimensions de votre choix, telles que le modèle, l’espace de travail, la clé API, ou l’utilisateur ou le compte de service à l’origine de chaque requête. Pour les organisations Claude Console, ces données sont similaires à celles qu’affichent les pages [Usage](https://platform.claude.com/usage) et [Cost](https://platform.claude.com/cost) de la Claude Console. L’API comporte deux points de terminaison : * `GET /v1/organizations/analytics/usage` rapporte le nombre de tokens et le nombre de requêtes. * `GET /v1/organizations/analytics/cost` rapporte le coût en USD. L’API Usage and Cost Analytics est en version bêta. Envoyez l’en-tête `anthropic-beta: analytics-usage-cost-2026-08-24` ainsi qu’un en-tête [`anthropic-version`](https://platform.claude.com/docs/fr/api/versioning) avec chaque requête. Le SDK et la CLI `ant` envoient les deux en-têtes pour vous et récupèrent les pages restantes au fur et à mesure que vous lisez les résultats, de sorte que `limit` ne définit que la taille de page. Utilisez cette API pour : * **Attribuer les dépenses :** ventilez le coût et l’utilisation des tokens par espace de travail, clé API, modèle, niveau de service ou identité ayant effectué chaque requête. * **Identifier les principaux consommateurs :** classez les résultats par tokens, requêtes ou coût pour répondre à des questions telles que « quelles clés API dépensent le plus ce mois-ci ? ». * **Construire des séries temporelles :** répartissez les résultats en intervalles quotidiens, horaires ou par minute pour les tableaux de bord et les rapports financiers. * **Intégrer une seule fois :** les mêmes points de terminaison, paramètres et champs de réponse servent les organisations Claude Console et Claude Enterprise. **Clé Admin API requise** Les organisations Claude Console utilisent une [clé Admin API](https://platform.claude.com/docs/fr/manage-claude/admin-api-keys#create-a-key-for-a-claude-console-organization) ou un autre [identifiant Admin API](https://platform.claude.com/docs/fr/manage-claude/admin-api#authentication). Les organisations Claude Enterprise utilisent une clé dotée de la portée `read:analytics`, créée dans claude.ai par le propriétaire principal une fois l’API Analytics activée pour l’organisation ; consultez [Obtenir l’accès à la Claude Enterprise Analytics API](https://platform.claude.com/docs/fr/manage-claude/analytics-api#get-access-to-the-claude-enterprise-analytics-api). Dans les deux cas, définissez la variable d’environnement `ANTHROPIC_API_KEY` sur cette clé ; les exemples de cette page lisent la clé depuis cette variable. Si vous appelez ces points de terminaison avec une clé Admin API, attribuez au service qui collecte ces données sa propre clé, stockez-la dans un gestionnaire de secrets et effectuez sa rotation régulièrement ; définir une [expiration de clé](https://platform.claude.com/docs/fr/manage-claude/authentication#key-expiration) lors de la création de la clé impose cette rotation. Lorsque c’est possible, utilisez plutôt une règle [Workload Identity Federation](https://platform.claude.com/docs/fr/manage-claude/workload-identity-federation) avec la [portée `org:admin`](https://platform.claude.com/docs/fr/manage-claude/wif-reference#oauth-scopes), afin que le service obtienne des jetons de courte durée et qu’aucune clé de longue durée ne puisse fuiter. **Claude Platform on AWS :** Les deux points de terminaison sont disponibles. Les requêtes utilisent l’URL de base et l’authentification de Claude Platform on AWS à la place d’une clé Admin API (consultez [Effectuer des requêtes](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#making-requests)), et AWS IAM les autorise via les [actions `ListAccountUsage` et `ListAccountCost`](https://platform.claude.com/docs/fr/api/claude-platform-on-aws-iam-actions#usage-and-cost). Chaque requête ne couvre que les espaces de travail de la région AWS du point de terminaison que vous appelez ; appelez donc le point de terminaison de chaque région pour couvrir l’ensemble de votre organisation. `user_profile_id`, `claude_tag_category`, `claude_tag_user_id` et les dimensions de Claude Managed Agents (`agent_id`, `environment_id`, `deployment_id` et `session_id`) valent `null` sur chaque ligne. **Claude Models on Google Cloud (Anthropic managed) :** Les deux points de terminaison sont disponibles. Appelez-les via l’[URL de base au niveau de l’organisation](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#making-requests) avec des identifiants Google Cloud au lieu d’une clé Admin API. Le point de terminaison `/usage` nécessite l’[autorisation IAM](https://platform.claude.com/docs/fr/api/claude-models-on-google-cloud-anthropic-managed-iam-permissions) `usageAnalytics.list`, et le point de terminaison `/cost` nécessite `costAnalytics.list`. ## Démarrage rapide Obtenez l’utilisation quotidienne des tokens pour la première semaine de septembre, avec une ligne pour chaque modèle et chaque jour : ```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 ``` La réponse contient une ligne pour chaque modèle et chaque jour présentant une utilisation, en commençant par le `total_tokens` le plus élevé. Cet exemple montre une seule ligne : ```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" } ``` **Définir un en-tête User-Agent pour les intégrations** Si vous développez une intégration, définissez votre en-tête User-Agent pour aider Anthropic à comprendre les modèles d’utilisation : ```text wrap User-Agent: YourApp/1.0.0 (https://yourapp.com) ``` ## Structure des résultats * **Chaque ligne comporte trois parties :** `starting_at` et `ending_at` indiquent la période couverte par la ligne, `group` contient toutes les dimensions, et `usage` (ou `cost` sur le point de terminaison de coût) contient les métriques. * **Les dimensions sont nulles sauf si elles sont regroupées :** une dimension dans `group` vaut `null` sauf si vous la listez dans `group_by[]`. Une dimension regroupée vaut également `null` sur les lignes qui n’ont pas de valeur pour elle, comme `model` pour l’utilisation de l’exécution de code. `group_by[]` accepte jusqu’à cinq dimensions. * **Une ligne pour chaque combinaison :** chaque ligne correspond à une combinaison des dimensions regroupées, et chaque combinaison présentant une utilisation ou un coût apparaît exactement une fois sur l’ensemble des pages d’une requête. Sans `group_by[]` ni `time_bucket_width`, la réponse est une ligne unique qui totalise toute la plage. * **Les intervalles de temps sont facultatifs :** définissez `time_bucket_width` sur `1m`, `1h` ou `1d` pour répartir chaque combinaison par intervalle UTC ; les valeurs `starting_at` et `ending_at` de chaque ligne correspondent alors aux bornes de son intervalle. Les intervalles sans utilisation ni coût ne produisent aucune ligne. * **Classées par défaut :** Les lignes sont triées selon la métrique `order_by` sur toute la plage, de la plus grande à la plus petite par défaut (`order=asc` inverse l’ordre). Pour construire une série temporelle, définissez `time_bucket_width` et `order_by=time`. Les lignes sont alors renvoyées intervalle de temps après intervalle de temps, l’intervalle le plus récent en premier par défaut (`order=asc` place le plus ancien en premier), avec les plus grandes lignes en premier au sein de chaque intervalle. Remplissez les intervalles vides avec des zéros. * **Les filtres fonctionnent en parallèle du regroupement :** la plupart des dimensions selon lesquelles vous pouvez regrouper disposent d’un filtre de liste correspondant en notation entre crochets, comme `models[]=claude-opus-5-5`. Répétez le paramètre pour transmettre plusieurs valeurs, jusqu’à 100. Plusieurs valeurs pour un même filtre sont combinées avec OR, et des filtres différents sont combinés avec AND. Les filtres et `group_by[]` sont indépendants ; vous pouvez filtrer selon n’importe quelle dimension, avec ou sans regroupement selon celle-ci, ou inversement. Des dimensions telles que `model` et `actor` s’appliquent à toutes les organisations. Certaines, comme `api_key_id`, ne s’appliquent qu’aux organisations Claude Console, et d’autres, comme `slack_channel_id`, ne s’appliquent qu’aux organisations Claude Enterprise. Une dimension qui ne s’applique pas à votre organisation vaut `null` sur chaque ligne et son filtre ne correspond à rien ; l’exception est `rbac_group_id`, qui renvoie plutôt une erreur lorsque les équipes ne sont pas disponibles pour votre organisation. La référence de l’API pour [utilisation](https://platform.claude.com/docs/fr/api/beta/organization/analytics/usage/list) et [coûts](https://platform.claude.com/docs/fr/api/beta/organization/analytics/cost/list) liste chaque dimension, filtre et valeur. ### Acteurs La dimension `actor` indique à qui une requête est attribuée : un utilisateur, un compte de service, une identité cloud fédérée (un principal AWS ou Google Cloud, pour les organisations qui accèdent à Claude via leur plateforme cloud) ou, lorsqu’aucun de ceux-ci n’est à l’origine de la requête, la clé API elle-même. Lorsque vous groupez par `actor`, le champ `actor` de chaque ligne est un objet dont le `type` indique de quel type il s’agit. L’utilisation qui ne peut être attribuée à aucune identité a `actor: null`. Les [clés personnelles et clés de compte de service](https://platform.claude.com/docs/fr/manage-claude/authentication#key-types) agissent en tant qu’utilisateur ou compte de service auquel elles sont liées, de sorte que leurs requêtes affichent cette identité comme `actor` et la clé dans `api_key_id`. Les anciennes clés d’espace de travail ne sont liées à aucune identité, la clé apparaît donc à la fois comme `actor` et comme `api_key_id`. L’exception est la clé que Claude Code crée lorsqu’un membre se connecte avec son compte Claude Console : elle se trouve dans l’[espace de travail Claude Code](https://platform.claude.com/docs/fr/manage-claude/workspaces#claude-code-workspace), et son utilisation est attribuée à ce membre. Les requêtes effectuées sans clé API, par exemple depuis la Claude Console ou avec un jeton [Workload Identity Federation](https://platform.claude.com/docs/fr/manage-claude/workload-identity-federation), ont `api_key_id: null` ; l’`actor` d’une charge de travail fédérée est son compte de service. Pour inclure l’utilisation sans clé API dans un filtre `api_key_ids[]`, ajoutez une entrée vide : `api_key_ids[]=`. Les filtres `api_key_ids[]` et `actor_ids[]` répondent à des questions différentes. `api_key_ids[]=apikey_...` correspond à toutes les requêtes authentifiées par la clé, quelle que soit l’identité à laquelle elles sont attribuées. `actor_ids[]=apikey_...` ne correspond qu’aux requêtes attribuées à la clé elle-même. ## Point de terminaison d’utilisation `GET /v1/organizations/analytics/usage` renvoie le nombre de tokens par type. `order_by` accepte `total_tokens` (la valeur par défaut), `output_tokens`, `uncached_input_tokens`, `requests` ou `time`. Par exemple, pour voir une semaine d’utilisation pour un espace de travail et une clé API, ventilée par niveau de service (une ligne pour chaque niveau, couvrant toute la semaine) : ```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 ``` Pour rechercher les identifiants de clés API et d’espaces de travail, utilisez les points de terminaison [List API Keys](https://platform.claude.com/docs/fr/api/organization/api_keys/list) et [List Workspaces](https://platform.claude.com/docs/fr/api/organization/workspaces/list) ou la Claude Console. Pour identifier les utilisateurs, comptes de service et clés API ayant effectué le plus de requêtes au cours d’un mois : ```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 ``` ## Point de terminaison de coûts `GET /v1/organizations/analytics/cost` accepte les mêmes filtres, dimensions et intervalles de temps que le point de terminaison `/usage`. L’objet `cost` de chaque ligne contient `amount` (le coût après remises et avant l’application de tout crédit), `list_amount` (le coût aux prix catalogue), `currency` (toujours `"USD"`) et `requests`. Les montants sont des chaînes décimales en cents avec six décimales : `"41280.000000"` correspond à 412,80 $ USD. `order_by` accepte `amount` (la valeur par défaut), `list_amount` ou `time`. Deux dimensions supplémentaires n’existent que sur ce point de terminaison et ne sont pas prises en compte dans la limite de cinq dimensions : `group_by[]=cost_type` divise chaque ligne en une ligne pour chaque type de coût, et `group_by[]=token_type` divise le coût des tokens en une ligne pour chaque type de token. `limit` ne s’applique pas non plus à ces deux dimensions, de sorte qu’une page peut contenir plus de `limit` lignes. Par exemple, le coût par modèle, type de coût et type de token pour un mois : ```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 ``` Pour chaque modèle, la réponse contient cinq lignes `tokens` (une pour chaque type de token), plus une ligne pour chacun de `web_search`, `code_execution` et `session_usage`. L’une de ces lignes : ```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 } } ``` L’objet `group` contient toutes les dimensions et est abrégé ici. Lorsque `group_by[]=cost_type` ou `token_type` est spécifié, `requests` vaut `null` sur chaque ligne. Les requêtes servies dans le cadre d’un engagement Priority Tier apparaissent sur le point de terminaison d’utilisation avec `service_tier: "priority"` mais n’ajoutent aucun coût de tokens à `amount` et `list_amount`, car votre engagement les couvre ; les frais d’engagement sont facturés séparément et ne figurent pas dans ces données. La recherche web sur ces requêtes est facturée au tarif standard. Les requêtes au-delà de votre capacité engagée sont servies et tarifées au niveau standard. ## Plages de dates et intervalles de temps * Les horodatages sont au format RFC 3339 avec un décalage UTC, par exemple `2026-09-01T00:00:00Z`. `starting_at` est inclusif et `ending_at` est exclusif. * `starting_at` doit être postérieur ou égal au 1er janvier 2026 et compris dans les 365 derniers jours. Une requête peut couvrir au maximum 31 jours ; `ending_at` vaut par défaut 31 jours après `starting_at` ou l’heure actuelle, selon ce qui est le plus tôt. * `ending_at` est obligatoire dès que `time_bucket_width` est défini, et avec `time_bucket_width=1m` une requête peut couvrir au maximum 24 heures. * Les deux extrémités de la plage sont arrondies à l’inférieur à une limite d’intervalle UTC, ou à l’heure lorsque `time_bucket_width` n’est pas défini. Par exemple, avec `time_bucket_width=1h`, un `starting_at` de `2026-09-01T10:43:00Z` est traité comme `2026-09-01T10:00:00Z` et un `ending_at` de `2026-09-01T15:43:00Z` comme `2026-09-01T15:00:00Z`, de sorte que la réponse couvre de 10:00 à 15:00 UTC. ## Fraîcheur des données Chaque réponse inclut un horodatage `data_refreshed_at`, et l’utilisation postérieure à ce moment est manquante ou partielle. Lorsqu’aucune donnée n’est encore disponible pour une partie quelconque de la plage demandée, `data_refreshed_at` vaut `null` et `data` est vide. Les données sont généralement actualisées dans les 4 heures suivant l’utilisation sous-jacente et peuvent prendre jusqu’à 24 heures. Les valeurs peuvent être révisées à mesure que des événements tardifs arrivent et que des rapprochements sont effectués, jusqu’à environ 7 jours après la fin du mois calendaire. Par exemple, les valeurs du 1er octobre peuvent changer jusqu’au 7 novembre environ. Pour obtenir des résultats stables lors d’appels répétés, définissez `ending_at` à une valeur égale ou antérieure à un `data_refreshed_at` que vous avez déjà vu ; pour obtenir des totaux définitifs, n’interrogez que les mois terminés depuis au moins 7 jours. Chaque page d’une requête paginée lit le même instantané de données, de sorte que `data_refreshed_at` est identique d’une page à l’autre. ## Migrer depuis l’API Usage and Cost Cette section s’adresse aux organisations Claude Console qui appellent l’ancienne [API Usage and Cost](https://platform.claude.com/docs/fr/manage-claude/usage-cost-api) (`/v1/organizations/usage_report/messages` et `/v1/organizations/cost_report`). Votre clé Admin API, l’en-tête `anthropic-version`, `starting_at` et `ending_at`, les valeurs de largeur d’intervalle (`1m`, `1h`, `1d`), la notation entre crochets, les noms des champs de pagination et les noms des champs de tokens et de coûts restent inchangés. Ce qui change : | API Usage and Cost | API Usage and Cost Analytics | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Aucun en-tête bêta | `anthropic-beta: analytics-usage-cost-2026-08-24` avec chaque requête | | Les données apparaissent généralement en moins de 5 minutes | Les données sont généralement actualisées dans les 4 heures et peuvent prendre jusqu’à 24 heures (consultez [Fraîcheur des données](https://platform.claude.com/docs/fr/manage-claude/usage-cost-analytics-api#data-freshness)) | | `data` est une liste d’intervalles de temps, du plus ancien au plus récent, y compris les intervalles vides, chacun avec une liste `results` dont les entrées contiennent les dimensions et les métriques côte à côte | `data` est une liste de lignes classées par `order_by`, chacune avec ses propres `starting_at` et `ending_at`, les dimensions dans `group` et les métriques dans `usage` ou `cost`. Les combinaisons sans utilisation ni coût n’ont pas de ligne. | | `bucket_width`, `1d` par défaut | `time_bucket_width`, sans valeur par défaut. Transmettez `time_bucket_width=1d` pour conserver des lignes quotidiennes ; omettez-le pour obtenir des totaux sur toute la plage. Le point de terminaison de coût accepte également tous les filtres ainsi que les intervalles `1m` et `1h`. | | `limit` compte les intervalles de temps par page | `limit` compte les lignes par page (de 1 à 1 000, 20 par défaut), de sorte que le nombre de pages dépend du nombre de combinaisons disposant de données | | N’importe quelle plage de dates, paginée vers l’avant par intervalle | `starting_at` au 1er janvier 2026 ou après, et dans les 365 derniers jours, au maximum 31 jours par requête, `ending_at` obligatoire avec `time_bucket_width`, et au maximum 24 heures avec des intervalles `1m` (consultez [Plages de dates et intervalles de temps](https://platform.claude.com/docs/fr/manage-claude/usage-cost-analytics-api#date-ranges-and-time-buckets)). Divisez les plages plus longues en plusieurs requêtes. | | `account_ids[]`, `service_account_ids[]`, `group_by[]=account_id`, `group_by[]=service_account_id` | `actor_ids[]` avec les mêmes identifiants préfixés, et `group_by[]=actor` ou `actor_type` ; lisez `actor.user_id` ou `actor.service_account_id`. Consultez [Acteurs](https://platform.claude.com/docs/fr/manage-claude/usage-cost-analytics-api#actors). | | `context_window[]` | `context_windows[]` | | `group_by[]=description` sur le rapport de coût, avec une chaîne `description` | Pas de `description`. Regroupez plutôt selon les dimensions structurées : n’importe lesquelles parmi `model`, `cost_type`, `token_type`, `context_window`, `service_tier`, `inference_geo` et `speed`, qui tiennent toutes dans une seule requête. | | Un identifiant de clé API ou d’espace de travail inconnu renvoie une erreur | Il ne correspond à rien, y compris un nom `models[]` mal orthographié. Chaque liste accepte jusqu’à 100 valeurs. | | `workspace_id: null` pour l’espace de travail par défaut | Le véritable `workspace_id` de l’espace de travail par défaut (consultez [Comment l’espace de travail par défaut est-il représenté ?](https://platform.claude.com/docs/fr/manage-claude/usage-cost-analytics-api#how-is-the-default-workspace-represented)) | | `inference_geo: "not_available"` et `service_tier: "standard"` pour l’utilisation sans zone géographique ni niveau | `null` pour les deux. `inference_geos[]=not_available` correspond toujours aux lignes sans zone géographique d’inférence. | | Le `service_tier` du coût est `standard` ou `batch` ; `amount` tel que `"123.45"` | Le niveau réel ; `amount` avec six décimales, tel que `"123.450000"`, plus `list_amount`. | | Exécution de code absente du rapport d’utilisation ; aucun nombre de requêtes | L’exécution de code apparaît sous forme de lignes d’utilisation avec `model: null` ; ajoute `requests` sur les deux points de terminaison et `total_tokens` sur les lignes d’utilisation | Pour reproduire la version héritée du rapport quotidien, demandez `time_bucket_width=1d` avec le même `group_by[]`, parcourez les pages avec `limit=1000`, puis regroupez les lignes par `starting_at` et remplissez les jours manquants avec des zéros. Ajoutez `order_by=time&order=asc` pour obtenir les jours dans l’ordre. Utilisation quotidienne par modèle sur 1 semaine, avant : ```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" ``` et après : ```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 ``` Coût quotidien par espace de travail, modèle, niveau de service, fenêtre de contexte et zone géographique d’inférence, réparti par type de coût et type de token : ```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 ``` ## Migrer depuis les rapports d’utilisation et de coûts de Claude Enterprise Cette section s’adresse aux organisations Claude Enterprise qui appellent les points de terminaison de rapport `usage_report`, `cost_report`, `user_usage_report` et `user_cost_report` de la [Claude Enterprise Analytics API](https://platform.claude.com/docs/fr/manage-claude/analytics-api) sous `/v1/organizations/analytics/`. Ces points de terminaison sont hérités et restent pris en charge. Passez à `/analytics/usage` et `/analytics/cost` lorsque vous souhaitez l’un des éléments suivants : * Chaque groupe dans chaque intervalle de temps, plutôt que les 100 premiers groupes de chaque intervalle * Le regroupement par `actor` ou `actor_type` conjointement avec d’autres dimensions, à la fois pour l’utilisation et le coût * Des lignes classées selon la métrique de votre choix sur toute la plage, ou triées par intervalle de temps * Une seule intégration qui sert également les organisations Claude Console Votre clé, la date la plus ancienne, la période rétrospective de 365 jours et l’étendue de 31 jours, les noms et valeurs des filtres et des dimensions (à l’exception de `user_ids[]` et de la valeur de produit Claude Tag), les champs `actor` des utilisateurs, les champs de métriques et de montants, `data_refreshed_at`, les règles de curseur et la [limite de débit au niveau de l’organisation](https://platform.claude.com/docs/fr/manage-claude/analytics-api#working-with-the-api) restent inchangés. Le seul nouvel en-tête est l’en-tête bêta `analytics-usage-cost-2026-08-24`. Ce qui change : | Rapports Claude Enterprise | API Usage and Cost Analytics | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `usage_report` et `cost_report` renvoient des intervalles de temps, du plus ancien au plus récent, y compris les intervalles vides, chacun contenant au maximum ses 100 premiers groupes ; `bucket_width` vaut `1d` par défaut et `limit` compte les intervalles | Des lignes couvrant chaque combinaison disposant de données, classées par `order_by`, chacune avec ses propres `starting_at` et `ending_at`, les dimensions dans `group` et les métriques dans `usage` ou `cost`. `time_bucket_width` est facultatif et `limit` compte les lignes. | | Le paramètre d’intervalle de temps est `bucket_width` | Il s’agit de `time_bucket_width`, avec les mêmes valeurs | | Sur `usage_report` et `cost_report`, `ending_at` est facultatif avec `bucket_width` et les intervalles `1m` peuvent couvrir jusqu’à 31 jours | `ending_at` obligatoire avec `time_bucket_width` ; les intervalles `1m` couvrent au maximum 24 heures par requête | | `user_usage_report` et `user_cost_report` renvoient une ligne par utilisateur | `group_by[]=actor&actor_types[]=user_actor`. Sans ce filtre, vous obtenez également des lignes pour les identités non utilisateur et une ligne `actor: null` pour l’utilisation non attribuée. | | L’utilisation de Claude Tag a `product: "claude-tag"` | `product: "claude_tag"` ; `products[]` accepte l’une ou l’autre orthographe | | Un nom `models[]` non reconnu renvoie une erreur 400 | Il ne correspond à rien | | `user_ids[]` | `actor_ids[]` avec les mêmes identifiants préfixés `user_...` | | `exclude_deleted_users` sur les rapports par utilisateur | Nécessite `group_by[]=actor` ; sans cela, la requête renvoie une erreur 400. Il ne supprime que les lignes dont l’`actor` est un utilisateur avec `deleted: true` ; les lignes des autres identités et les lignes avec `actor: null` sont conservées. | Coût par utilisateur pour un mois, avant : ```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 ``` et après, en ajoutant une ventilation par produit : ```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 ``` ## Questions fréquentes ### Comment l’espace de travail par défaut est-il représenté ? L’espace de travail par défaut d’une organisation Claude Console possède son propre identifiant `wrkspc_`, comme tout autre espace de travail. Les lignes de l’espace de travail par défaut contiennent cet identifiant dans `workspace_id`, et vous pouvez filtrer sur celui-ci avec `workspace_ids[]`. [List Workspaces](https://platform.claude.com/docs/fr/api/organization/workspaces/list) omet l’espace de travail par défaut, sauf si vous transmettez `include_default=true`. Pour vérifier si un `workspace_id` inconnu correspond à l’espace de travail par défaut, transmettez-le à [Get Workspace](https://platform.claude.com/docs/fr/api/organization/workspaces/retrieve) : l’espace de travail par défaut renvoie `"name": "Default"`. ### Comment obtenir le coût par utilisateur pour Claude Code ? Appelez le point de terminaison de coûts avec `products[]=claude_code&group_by[]=actor`. Les organisations Claude Console peuvent également utiliser l’[API Claude Code Analytics](https://platform.claude.com/docs/fr/manage-claude/claude-code-analytics-api), qui rapporte l’activité Claude Code par utilisateur et le coût estimé. ## Voir aussi * [API Usage and Cost](https://platform.claude.com/docs/fr/manage-claude/usage-cost-api) (ancienne version) * [API Analytics](https://platform.claude.com/docs/fr/manage-claude/analytics-api) : quelle API d’analytique et quel type de clé votre organisation nécessite * [API Claude Code Analytics](https://platform.claude.com/docs/fr/manage-claude/claude-code-analytics-api) * [Référence de l’Admin API](https://platform.claude.com/docs/fr/api/beta/organization) * [Tarification](https://platform.claude.com/docs/fr/about-claude/pricing)