--- title: Usage and Cost Analytics API url: https://platform.claude.com/docs/ru/manage-claude/usage-cost-analytics-api description: Запрашивайте данные об использовании токенов и затратах вашей организации Claude Console или Claude Enterprise в разбивке по модели, рабочему пространству, ключу API, субъекту и другим параметрам. --- **Admin API недоступен для индивидуальных учётных записей.** Чтобы сотрудничать с коллегами и добавлять участников, настройте свою организацию на странице [Organization](https://platform.claude.com/settings/organization) (`platform.claude.com/settings/organization`) в Claude Console. Usage and Cost Analytics API предоставляет исторические данные об использовании токенов и затратах вашей организации в разбивке по выбранным вами измерениям, таким как модель, рабочее пространство, ключ API или пользователь либо сервисный аккаунт, стоящий за каждым запросом. Для организаций Claude Console эти данные аналогичны тем, что отображаются на страницах [Usage](https://platform.claude.com/usage) и [Cost](https://platform.claude.com/cost) в Claude Console. API имеет две конечные точки: * `GET /v1/organizations/analytics/usage` возвращает количество токенов и количество запросов. * `GET /v1/organizations/analytics/cost` возвращает затраты в долларах США. Usage and Cost Analytics API находится в стадии бета-тестирования. В каждом запросе отправляйте `anthropic-beta: analytics-usage-cost-2026-08-24` в качестве заголовка, а также заголовок [`anthropic-version`](https://platform.claude.com/docs/ru/api/versioning). SDK и CLI `ant` отправляют оба заголовка за вас и загружают оставшиеся страницы по мере чтения результатов, поэтому `limit` задаёт только размер страницы. Используйте этот API, чтобы: * **Распределять расходы:** разбивать затраты и использование токенов по рабочим пространствам, ключам API, моделям, уровням обслуживания или по идентичности, выполнившей каждый запрос. * **Находить крупнейших потребителей:** ранжировать результаты по токенам, запросам или затратам, чтобы отвечать на такие вопросы, как «какие ключи API тратят больше всего в этом месяце?» * **Строить временные ряды:** разбивать результаты на ежедневные, ежечасные или поминутные интервалы для дашбордов и финансовых отчётов. * **Интегрироваться один раз:** одни и те же конечные точки, параметры и поля ответа обслуживают организации Claude Console и Claude Enterprise. **Требуется ключ Admin API** Организации Claude Console используют [ключ Admin API](https://platform.claude.com/docs/ru/manage-claude/admin-api-keys#create-a-key-for-a-claude-console-organization) или другие [учётные данные Admin API](https://platform.claude.com/docs/ru/manage-claude/admin-api#authentication). Организации Claude Enterprise используют ключ с областью `read:analytics`, созданный в claude.ai основным владельцем после включения Analytics API для организации; см. [Получение доступа к Claude Enterprise Analytics API](https://platform.claude.com/docs/ru/manage-claude/analytics-api#get-access-to-the-claude-enterprise-analytics-api). В любом случае задайте этот ключ в переменной окружения `ANTHROPIC_API_KEY`; примеры на этой странице считывают ключ из неё. Если вы вызываете эти конечные точки с ключом Admin API, выделите сервису, который собирает эти данные, собственный ключ, храните его в менеджере секретов и регулярно выполняйте ротацию; установка [срока действия ключа](https://platform.claude.com/docs/ru/manage-claude/authentication#key-expiration) при его создании обеспечивает обязательную ротацию. Где это возможно, используйте вместо этого правило [Workload Identity Federation](https://platform.claude.com/docs/ru/manage-claude/workload-identity-federation) с [областью `org:admin`](https://platform.claude.com/docs/ru/manage-claude/wif-reference#oauth-scopes), чтобы сервис получал краткосрочные токены и не было долгоживущего ключа, который может утечь. **Claude Platform on AWS:** Доступны обе конечные точки. Запросы используют базовый URL и аутентификацию Claude Platform on AWS вместо ключа Admin API (см. [Выполнение запросов](https://platform.claude.com/docs/ru/build-with-claude/claude-platform-on-aws#making-requests)), а AWS IAM авторизует их через [действия `ListAccountUsage` и `ListAccountCost`](https://platform.claude.com/docs/ru/api/claude-platform-on-aws-iam-actions#usage-and-cost). Каждый запрос охватывает только рабочие пространства в регионе AWS той конечной точки, которую вы вызываете, поэтому вызывайте конечную точку каждого региона, чтобы охватить всю организацию. `user_profile_id`, `claude_tag_category`, `claude_tag_user_id` и измерения Claude Managed Agents (`agent_id`, `environment_id`, `deployment_id` и `session_id`) имеют значение `null` в каждой строке. **Claude Models on Google Cloud (Anthropic managed):** доступны обе конечные точки. Вызывайте их через [базовый URL уровня организации](https://platform.claude.com/docs/ru/build-with-claude/claude-models-on-google-cloud/anthropic-managed#making-requests) с учётными данными Google Cloud вместо ключа Admin API. Для конечной точки `/usage` требуется [разрешение IAM](https://platform.claude.com/docs/ru/api/claude-models-on-google-cloud-anthropic-managed-iam-permissions) `usageAnalytics.list`, а для конечной точки `/cost` — `costAnalytics.list`. ## Быстрый старт Получите ежедневное использование токенов за первую неделю сентября, по одной строке для каждой модели и дня: ```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 ``` Ответ содержит по одной строке для каждой модели и дня, в которых было использование, начиная с наибольшего `total_tokens`. В этом примере показана одна строка: ```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" } ``` **Задайте заголовок User-Agent для интеграций** Если вы создаёте интеграцию, задайте заголовок User-Agent, чтобы помочь Anthropic понимать закономерности использования: ```text wrap User-Agent: YourApp/1.0.0 (https://yourapp.com) ``` ## Структура результатов * **Каждая строка состоит из трёх частей:** `starting_at` и `ending_at` задают период, который охватывает строка, `group` содержит все измерения, а `usage` (или `cost` на конечной точке затрат) содержит метрики. * **Измерения равны null, если по ним нет группировки:** измерение в `group` имеет значение `null`, если вы не указали его в `group_by[]`. Сгруппированное измерение также имеет значение `null` в строках, где для него нет значения, например `model` для использования выполнения кода. `group_by[]` принимает до пяти измерений. * **Одна строка для каждой комбинации:** каждая строка — это одна комбинация сгруппированных измерений, и каждая комбинация, для которой есть использование или затраты, встречается ровно один раз на всех страницах запроса. Без `group_by[]` и без `time_bucket_width` ответ состоит из одной строки с итогом за весь диапазон. * **Временные интервалы необязательны:** задайте `time_bucket_width` равным `1m`, `1h` или `1d`, чтобы разбить каждую комбинацию по интервалам UTC; тогда `starting_at` и `ending_at` каждой строки являются границами её интервала. Интервалы без использования или затрат не порождают строк. * **По умолчанию строки ранжируются:** строки упорядочиваются по метрике `order_by` за весь диапазон, по умолчанию от наибольшей (`order=asc` меняет порядок на обратный). Чтобы построить временной ряд, задайте `time_bucket_width` и `order_by=time`. Тогда строки возвращаются интервал за интервалом, по умолчанию начиная с самого нового интервала (`order=asc` ставит первым самый старый), а внутри каждого интервала первыми идут наибольшие строки. Заполните пустые интервалы нулями. * **Фильтры работают вместе с группировкой:** для большинства измерений, по которым можно группировать, есть соответствующий списочный фильтр в скобочной нотации, например `models[]=claude-opus-5-5`. Повторите параметр, чтобы передать несколько значений, до 100. Несколько значений одного фильтра объединяются через OR, а разные фильтры — через AND. Фильтры и `group_by[]` независимы: вы можете фильтровать по любому измерению с группировкой по нему или без неё, и наоборот. Такие измерения, как `model` и `actor`, применимы ко всем организациям. Некоторые, например `api_key_id`, применимы только к организациям Claude Console, а другие, например `slack_channel_id`, — только к организациям Claude Enterprise. Измерение, которое не применимо к вашей организации, равно `null` в каждой строке, а его фильтр ничему не соответствует; исключение — `rbac_group_id`, который вместо этого возвращает ошибку, если команды недоступны вашей организации. Справочник API по [использованию](https://platform.claude.com/docs/ru/api/beta/organization/analytics/usage/list) и [затратам](https://platform.claude.com/docs/ru/api/beta/organization/analytics/cost/list) перечисляет все измерения, фильтры и значения. ### Субъекты Измерение `actor` — это субъект, которому приписывается запрос: пользователь, сервисный аккаунт, федеративная облачная идентичность (принципал AWS или Google Cloud для организаций, которые получают доступ к Claude через свою облачную платформу) или, если ни одного из них за запросом нет, сам ключ API. При группировке по `actor` поле `actor` каждой строки является объектом, чьё поле `type` указывает его вид. Использование, которое невозможно приписать какой-либо идентичности, имеет `actor: null`. [Персональные ключи и ключи сервисных аккаунтов](https://platform.claude.com/docs/ru/manage-claude/authentication#key-types) действуют от имени пользователя или сервисного аккаунта, с которым они связаны, поэтому их запросы показывают эту идентичность как `actor`, а ключ — в `api_key_id`. Устаревшие ключи рабочих пространств не связаны с идентичностью, поэтому ключ отображается и как `actor`, и как `api_key_id`. Исключение — ключ, который Claude Code создаёт, когда участник входит со своей учётной записью Claude Console: он находится в [рабочем пространстве Claude Code](https://platform.claude.com/docs/ru/manage-claude/workspaces#claude-code-workspace), и его использование приписывается этому участнику. Запросы, выполненные без ключа API, например из Claude Console или с токеном [Workload Identity Federation](https://platform.claude.com/docs/ru/manage-claude/workload-identity-federation), имеют `api_key_id: null`; `actor` федеративной рабочей нагрузки — это её сервисный аккаунт. Чтобы включить использование без ключа API в фильтр `api_key_ids[]`, добавьте пустую запись: `api_key_ids[]=`. Фильтры `api_key_ids[]` и `actor_ids[]` отвечают на разные вопросы. `api_key_ids[]=apikey_...` соответствует каждому запросу, аутентифицированному ключом, кому бы он ни был приписан. `actor_ids[]=apikey_...` соответствует только запросам, приписанным самому ключу. ## Конечная точка использования `GET /v1/organizations/analytics/usage` возвращает количество токенов по типам. `order_by` принимает `total_tokens` (по умолчанию), `output_tokens`, `uncached_input_tokens`, `requests` или `time`. Например, чтобы увидеть использование за неделю для одного рабочего пространства и одного ключа API с разбивкой по уровню обслуживания (по одной строке для каждого уровня, охватывающей всю неделю): ```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 ``` Чтобы найти идентификаторы ключей API и рабочих пространств, используйте конечные точки [List API Keys](https://platform.claude.com/docs/ru/api/organization/api_keys/list) и [List Workspaces](https://platform.claude.com/docs/ru/api/organization/workspaces/list) или Claude Console. Чтобы узнать, какие пользователи, сервисные аккаунты и ключи API выполнили больше всего запросов за месяц: ```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 ``` ## Конечная точка затрат `GET /v1/organizations/analytics/cost` принимает те же фильтры, измерения и временные интервалы, что и конечная точка `/usage`. Объект `cost` каждой строки содержит `amount` (стоимость после скидок и до применения каких-либо кредитов), `list_amount` (стоимость по прейскурантным ценам), `currency` (всегда `"USD"`) и `requests`. Суммы представлены десятичными строками в центах с шестью знаками после запятой: `"41280.000000"` — это $412,80 USD. `order_by` принимает `amount` (по умолчанию), `list_amount` или `time`. Два дополнительных измерения существуют только на этой конечной точке и не учитываются в ограничении в пять измерений: `group_by[]=cost_type` разбивает каждую строку на отдельные строки для каждого типа затрат, а `group_by[]=token_type` разбивает затраты на токены на отдельные строки для каждого типа токенов. `limit` также не применяется к этим двум измерениям, поэтому страница может содержать больше строк, чем `limit`. Например, затраты по модели, типу затрат и типу токенов за месяц: ```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 ``` Для каждой модели ответ содержит пять строк `tokens` (по одной для каждого типа токенов) плюс по одной строке для `web_search`, `code_execution` и `session_usage`. Одна из этих строк: ```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 } } ``` Объект `group` содержит все измерения и здесь сокращён. Если указано `group_by[]=cost_type` или `token_type`, `requests` равно `null` в каждой строке. Запросы, обслуженные в рамках обязательства Priority Tier, отображаются в конечной точке использования с `service_tier: "priority"`, но вносят нулевые затраты на токены в `amount` и `list_amount`, поскольку их покрывает ваше обязательство; плата за обязательство выставляется отдельно и не входит в эти данные. Веб-поиск в таких запросах оплачивается по стандартному тарифу. Запросы сверх вашей зарезервированной мощности обслуживаются и тарифицируются по стандартному уровню. ## Диапазоны дат и временные интервалы * Временные метки указываются в формате RFC 3339 со смещением UTC, например `2026-09-01T00:00:00Z`. `starting_at` включается в диапазон, а `ending_at` — нет. * `starting_at` должен быть не ранее 1 января 2026 года и в пределах последних 365 дней. Запрос может охватывать не более 31 дня; `ending_at` по умолчанию равен 31 дню после `starting_at` или текущему времени, в зависимости от того, что наступает раньше. * `ending_at` обязателен, если задан `time_bucket_width`, а при `time_bucket_width=1m` запрос может охватывать не более 24 часов. * Оба конца диапазона округляются вниз до границы интервала в UTC или до часа, если `time_bucket_width` не задан. Например, при `time_bucket_width=1h` значение `starting_at`, равное `2026-09-01T10:43:00Z`, обрабатывается как `2026-09-01T10:00:00Z`, а значение `ending_at`, равное `2026-09-01T15:43:00Z`, — как `2026-09-01T15:00:00Z`, поэтому ответ охватывает период с 10:00 до 15:00 UTC. ## Актуальность данных Каждый ответ включает метку времени `data_refreshed_at`, и использование после этого момента отсутствует или неполно. Если для какой-либо части запрошенного диапазона данные ещё недоступны, `data_refreshed_at` имеет значение `null`, а `data` пуст. Данные обычно обновляются в течение 4 часов после фактического использования, но это может занять до 24 часов. Значения могут пересматриваться по мере поступления запоздалых событий и выполнения сверки — примерно до 7 дней после окончания календарного месяца. Например, значения за 1 октября могут меняться примерно до 7 ноября. Для стабильных результатов при повторных вызовах задавайте `ending_at` не позже уже полученного вами значения `data_refreshed_at`; для окончательных итогов запрашивайте только месяцы, закончившиеся не менее 7 дней назад. Каждая страница запроса с пагинацией читает один и тот же снимок данных, поэтому `data_refreshed_at` одинаков на всех страницах. ## Миграция с Usage and Cost API Этот раздел предназначен для организаций Claude Console, которые вызывают устаревший [Usage and Cost API](https://platform.claude.com/docs/ru/manage-claude/usage-cost-api) (`/v1/organizations/usage_report/messages` и `/v1/organizations/cost_report`). Ваш ключ Admin API, заголовок `anthropic-version`, `starting_at` и `ending_at`, значения ширины интервала (`1m`, `1h`, `1d`), скобочная нотация, имена полей пагинации, а также имена полей токенов и затрат остаются прежними. Что меняется: | Usage and Cost API | Usage and Cost Analytics API | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Без бета-заголовка | `anthropic-beta: analytics-usage-cost-2026-08-24` в каждом запросе | | Данные обычно появляются в течение 5 минут | Данные обычно обновляются в течение 4 часов, но это может занять до 24 часов (см. [Актуальность данных](https://platform.claude.com/docs/ru/manage-claude/usage-cost-analytics-api#data-freshness)) | | `data` — это список временных интервалов, начиная с самого раннего, включая пустые, каждый со списком `results`, элементы которого содержат измерения и метрики рядом друг с другом | `data` — это список строк, ранжированных по `order_by`, каждая со своими `starting_at` и `ending_at`, измерениями в `group` и метриками в `usage` или `cost`. Для комбинаций без использования или затрат строк нет. | | `bucket_width`, по умолчанию `1d` | `time_bucket_width`, без значения по умолчанию. Передайте `time_bucket_width=1d`, чтобы сохранить ежедневные строки; опустите его для итогов за весь диапазон. Конечная точка затрат также принимает все фильтры и интервалы `1m` и `1h`. | | `limit` считает временные интервалы на странице | `limit` считает строки на странице (от 1 до 1 000, по умолчанию 20), поэтому количество страниц зависит от того, сколько комбинаций содержат данные | | Любой диапазон дат, постраничный переход вперёд по интервалам | `starting_at` не ранее 1 января 2026 года и в пределах последних 365 дней, не более 31 дня на запрос, `ending_at` обязателен при `time_bucket_width`, и не более 24 часов при интервалах `1m` (см. [Диапазоны дат и временные интервалы](https://platform.claude.com/docs/ru/manage-claude/usage-cost-analytics-api#date-ranges-and-time-buckets)). Разбивайте более длинные диапазоны на несколько запросов. | | `account_ids[]`, `service_account_ids[]`, `group_by[]=account_id`, `group_by[]=service_account_id` | `actor_ids[]` с теми же тегированными ID и `group_by[]=actor` или `actor_type`; читайте `actor.user_id` или `actor.service_account_id`. См. [Субъекты](https://platform.claude.com/docs/ru/manage-claude/usage-cost-analytics-api#actors). | | `context_window[]` | `context_windows[]` | | `group_by[]=description` в отчёте о затратах, со строкой `description` | Без `description`. Вместо этого группируйте по структурированным измерениям: любым из `model`, `cost_type`, `token_type`, `context_window`, `service_tier`, `inference_geo` и `speed` — все они помещаются в один запрос. | | Неизвестный ключ API или ID рабочего пространства возвращает ошибку | Ничему не соответствует, включая имя в `models[]` с опечаткой. Каждый список принимает до 100 значений. | | `workspace_id: null` для рабочего пространства по умолчанию | Реальный `workspace_id` рабочего пространства по умолчанию (см. [Как представлено рабочее пространство по умолчанию?](https://platform.claude.com/docs/ru/manage-claude/usage-cost-analytics-api#how-is-the-default-workspace-represented)) | | `inference_geo: "not_available"` и `service_tier: "standard"` для использования без географии или уровня | `null` для обоих. `inference_geos[]=not_available` по-прежнему соответствует строкам без географии инференса. | | `service_tier` затрат — `standard` или `batch`; `amount`, например `"123.45"` | Фактический уровень; `amount` с шестью знаками после запятой, например `"123.450000"`, плюс `list_amount`. | | Выполнение кода отсутствует в отчёте об использовании; нет количества запросов | Выполнение кода отображается как строки использования с `model: null`; добавлены `requests` на обеих конечных точках и `total_tokens` в строках использования | Чтобы воспроизвести устаревший ежедневный отчёт, запросите `time_bucket_width=1d` с тем же `group_by[]`, пролистайте страницы с `limit=1000`, затем сгруппируйте строки по `starting_at` и заполните отсутствующие дни нулями. Добавьте `order_by=time&order=asc`, чтобы получить дни по порядку. Ежедневное использование по моделям за 1 неделю, до: ```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" ``` и после: ```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 ``` Ежедневные затраты по рабочему пространству, модели, уровню обслуживания, контекстному окну и географии инференса в разбивке по типу затрат и типу токенов: ```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 ``` ## Миграция с отчётов об использовании и затратах Claude Enterprise Этот раздел предназначен для организаций Claude Enterprise, которые вызывают конечные точки отчётов [Claude Enterprise Analytics API](https://platform.claude.com/docs/ru/manage-claude/analytics-api) `usage_report`, `cost_report`, `user_usage_report` и `user_cost_report` в `/v1/organizations/analytics/`. Эти конечные точки являются устаревшими, но по-прежнему поддерживаются. Переходите на `/analytics/usage` и `/analytics/cost`, если вам нужно что-либо из следующего: * Все группы в каждом временном интервале, а не только 100 крупнейших групп в каждом интервале * Группировка по `actor` или `actor_type` вместе с другими измерениями — как для использования, так и для затрат * Строки, ранжированные по выбранной вами метрике за весь диапазон или упорядоченные по временным интервалам * Одна интеграция, которая также обслуживает организации Claude Console Ваш ключ, самая ранняя дата, ретроспектива в 365 дней и диапазон в 31 день, имена и значения фильтров и измерений (кроме `user_ids[]` и значения продукта Claude Tag), поля `actor` для пользователей, поля метрик и сумм, `data_refreshed_at`, правила курсора и [ограничение скорости на уровне организации](https://platform.claude.com/docs/ru/manage-claude/analytics-api#working-with-the-api) остаются прежними. Единственный новый заголовок — бета-заголовок `analytics-usage-cost-2026-08-24`. Что меняется: | Отчёты Claude Enterprise | Usage and Cost Analytics API | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `usage_report` и `cost_report` возвращают временные интервалы, начиная с самого раннего, включая пустые, каждый из которых содержит не более 100 крупнейших групп; `bucket_width` по умолчанию равен `1d`, а `limit` считает интервалы | Строки, охватывающие все комбинации с данными, ранжированные по `order_by`, каждая со своими `starting_at` и `ending_at`, измерениями в `group` и метриками в `usage` или `cost`. `time_bucket_width` необязателен, а `limit` считает строки. | | Параметр временного интервала — `bucket_width` | Это `time_bucket_width` с теми же значениями | | В `usage_report` и `cost_report` `ending_at` необязателен при `bucket_width`, а интервалы `1m` могут охватывать до 31 дня | `ending_at` обязателен при `time_bucket_width`; интервалы `1m` охватывают не более 24 часов на запрос | | `user_usage_report` и `user_cost_report` возвращают по одной строке на пользователя | `group_by[]=actor&actor_types[]=user_actor`. Без фильтра вы также получаете строки для идентичностей, не являющихся пользователями, и строку `actor: null` для неатрибутированного использования. | | Использование Claude Tag имеет `product: "claude-tag"` | `product: "claude_tag"`; `products[]` принимает любое написание | | Нераспознанное имя в `models[]` возвращает ошибку 400 | Ничему не соответствует | | `user_ids[]` | `actor_ids[]` с теми же тегированными ID `user_...` | | `exclude_deleted_users` в отчётах по пользователям | Требует `group_by[]=actor`; без него запрос возвращает ошибку 400. Отбрасывает только строки, в которых `actor` — пользователь с `deleted: true`; строки для других идентичностей и строки с `actor: null` остаются. | Затраты по пользователям за месяц, до: ```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 ``` и после, с добавлением разбивки по продукту: ```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 ``` ## Часто задаваемые вопросы ### Как представлено рабочее пространство по умолчанию? Рабочее пространство по умолчанию организации Claude Console имеет собственный ID `wrkspc_`, как и любое другое рабочее пространство. Строки для рабочего пространства по умолчанию содержат этот ID в `workspace_id`, и вы можете фильтровать по нему с помощью `workspace_ids[]`. [List Workspaces](https://platform.claude.com/docs/ru/api/organization/workspaces/list) не включает рабочее пространство по умолчанию, если вы не передадите `include_default=true`. Чтобы проверить, является ли незнакомый `workspace_id` рабочим пространством по умолчанию, передайте его в [Get Workspace](https://platform.claude.com/docs/ru/api/organization/workspaces/retrieve): рабочее пространство по умолчанию возвращает `"name": "Default"`. ### Как получить затраты по пользователям для Claude Code? Вызовите конечную точку затрат с `products[]=claude_code&group_by[]=actor`. Организации Claude Console также могут использовать [Claude Code Analytics API](https://platform.claude.com/docs/ru/manage-claude/claude-code-analytics-api), который предоставляет данные об активности Claude Code по пользователям и оценочные затраты. ## См. также * [Usage and Cost API](https://platform.claude.com/docs/ru/manage-claude/usage-cost-api) (устаревший) * [API аналитики](https://platform.claude.com/docs/ru/manage-claude/analytics-api): какой API аналитики и тип ключа нужны вашей организации * [Claude Code Analytics API](https://platform.claude.com/docs/ru/manage-claude/claude-code-analytics-api) * [Справочник Admin API](https://platform.claude.com/docs/ru/api/beta/organization) * [Цены](https://platform.claude.com/docs/ru/about-claude/pricing)