--- title: API de análisis de uso y costos url: https://platform.claude.com/docs/es/manage-claude/usage-cost-analytics-api description: Consulta el uso de tokens y el costo de tu organización de Claude Console o Claude Enterprise por modelo, espacio de trabajo, clave de API, actor y más. --- **La Admin API no está disponible para cuentas individuales.** Para colaborar con compañeros de equipo y agregar miembros, configura tu organización en la página [Organization](https://platform.claude.com/settings/organization) (`platform.claude.com/settings/organization`) en la Claude Console. La API de análisis de uso y costos informa el uso histórico de tokens y el costo de tu organización, desglosados por las dimensiones que elijas, como el modelo, el espacio de trabajo, la clave de API o el usuario o la cuenta de servicio detrás de cada solicitud. Para las organizaciones de Claude Console, estos datos son similares a los que muestran las páginas [Usage](https://platform.claude.com/usage) y [Cost](https://platform.claude.com/cost) de Claude Console. La API tiene dos endpoints: * `GET /v1/organizations/analytics/usage` informa los recuentos de tokens y de solicitudes. * `GET /v1/organizations/analytics/cost` informa el costo en USD. La API de análisis de uso y costos está en beta. Envía en cada solicitud `anthropic-beta: analytics-usage-cost-2026-08-24` como encabezado, junto con un encabezado [`anthropic-version`](https://platform.claude.com/docs/es/api/versioning). El SDK y la CLI `ant` envían ambos encabezados por ti y obtienen las páginas restantes a medida que lees los resultados, por lo que `limit` solo establece el tamaño de página. Usa esta API para: * **Atribuir el gasto:** Desglosa el costo y el uso de tokens por espacio de trabajo, clave de API, modelo, nivel de servicio o la identidad que realizó cada solicitud. * **Encontrar a los principales consumidores:** Clasifica los resultados por tokens, solicitudes o costo para responder preguntas como “¿qué claves de API gastan más este mes?” * **Crear series temporales:** Divide los resultados en intervalos diarios, por hora o por minuto para paneles e informes financieros. * **Integrar una sola vez:** Los mismos endpoints, parámetros y campos de respuesta sirven para organizaciones de Claude Console y Claude Enterprise. **Se requiere una clave de API de administrador** Las organizaciones de Claude Console usan una [clave de API de administrador](https://platform.claude.com/docs/es/manage-claude/admin-api-keys#create-a-key-for-a-claude-console-organization) u otra [credencial de la Admin API](https://platform.claude.com/docs/es/manage-claude/admin-api#authentication). Las organizaciones de Claude Enterprise usan una clave con el alcance `read:analytics`, creada en claude.ai por el propietario principal después de que se habilite la Analytics API para la organización; consulta [Obtener acceso a la Claude Enterprise Analytics API](https://platform.claude.com/docs/es/manage-claude/analytics-api#get-access-to-the-claude-enterprise-analytics-api). En cualquier caso, establece la variable de entorno `ANTHROPIC_API_KEY` con esa clave; los ejemplos de esta página leen la clave desde ella. Si llamas a estos endpoints con una clave de API de administrador, dale al servicio que recopila estos datos su propia clave, guárdala en un gestor de secretos y rótala con regularidad; establecer una [expiración de clave](https://platform.claude.com/docs/es/manage-claude/authentication#key-expiration) al crear la clave impone la rotación. Cuando puedas, usa en su lugar una regla de [Workload Identity Federation](https://platform.claude.com/docs/es/manage-claude/workload-identity-federation) con el [alcance `org:admin`](https://platform.claude.com/docs/es/manage-claude/wif-reference#oauth-scopes), para que el servicio obtenga tokens de corta duración y no haya ninguna clave de larga duración que pueda filtrarse. **Claude Platform on AWS:** Ambos endpoints están disponibles. Las solicitudes usan la URL base y la autenticación de Claude Platform on AWS en lugar de una clave de Admin API (consulta [Realizar solicitudes](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#making-requests)), y AWS IAM las autoriza mediante las [acciones `ListAccountUsage` y `ListAccountCost`](https://platform.claude.com/docs/es/api/claude-platform-on-aws-iam-actions#usage-and-cost). Cada solicitud cubre solo los espacios de trabajo de la región de AWS del endpoint al que llamas, así que llama al endpoint de cada región para cubrir toda tu organización. `user_profile_id`, `claude_tag_category`, `claude_tag_user_id` y las dimensiones de Claude Managed Agents (`agent_id`, `environment_id`, `deployment_id` y `session_id`) son `null` en todas las filas. **Claude Models on Google Cloud (Anthropic managed):** Ambos endpoints están disponibles. Llámalos a través de la [URL base a nivel de organización](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#making-requests) con credenciales de Google Cloud en lugar de una clave de Admin API. El endpoint `/usage` necesita el [permiso de IAM](https://platform.claude.com/docs/es/api/claude-models-on-google-cloud-anthropic-managed-iam-permissions) `usageAnalytics.list`, y el endpoint `/cost` necesita `costAnalytics.list`. ## Inicio rápido Obtén el uso diario de tokens de la primera semana de septiembre, con una fila por cada modelo y día: ```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 respuesta tiene una fila por cada modelo y día con uso, con el mayor `total_tokens` primero. Este ejemplo muestra una sola fila: ```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" } ``` **Establece un encabezado User-Agent para las integraciones** Si estás creando una integración, establece tu encabezado User-Agent para ayudar a Anthropic a comprender los patrones de uso: ```text wrap User-Agent: YourApp/1.0.0 (https://yourapp.com) ``` ## Cómo se estructuran los resultados * **Cada fila tiene tres partes:** `starting_at` y `ending_at` indican el período que cubre la fila, `group` contiene todas las dimensiones y `usage` (o `cost` en el endpoint de costos) contiene las métricas. * **Las dimensiones son nulas a menos que se agrupen:** Una dimensión en `group` es `null` a menos que la incluyas en `group_by[]`. Una dimensión agrupada también es `null` en las filas que no tienen valor para ella, como `model` en el uso de ejecución de código. `group_by[]` admite hasta cinco dimensiones. * **Una fila por cada combinación:** Cada fila es una combinación de las dimensiones agrupadas, y cada combinación que tiene uso o costo aparece exactamente una vez en las páginas de una consulta. Sin `group_by[]` y sin `time_bucket_width`, la respuesta es una sola fila que totaliza todo el rango. * **Los intervalos de tiempo son opcionales:** Establece `time_bucket_width` en `1m`, `1h` o `1d` para dividir cada combinación por intervalo UTC; entonces, `starting_at` y `ending_at` de cada fila son los límites de su intervalo. Los intervalos sin uso ni costo no producen filas. * **Clasificadas de forma predeterminada:** Las filas se ordenan según la métrica de `order_by` en todo el rango, de mayor a menor de forma predeterminada (`order=asc` invierte el orden). Para construir una serie temporal, establece `time_bucket_width` y `order_by=time`. Las filas se devuelven entonces un intervalo de tiempo tras otro, con el intervalo más reciente primero de forma predeterminada (`order=asc` coloca el más antiguo primero), y con las filas más grandes primero dentro de cada intervalo. Rellena los intervalos vacíos con ceros. * **Los filtros funcionan junto con la agrupación:** La mayoría de las dimensiones por las que puedes agrupar tienen un filtro de lista correspondiente en notación de corchetes, como `models[]=claude-opus-5-5`. Repite el parámetro para pasar varios valores, hasta 100. Los valores múltiples para el mismo filtro se combinan con OR, y los distintos filtros se combinan con AND. Los filtros y `group_by[]` son independientes; puedes filtrar por cualquier dimensión con o sin agrupar por ella, o al revés. Dimensiones como `model` y `actor` se aplican a todas las organizaciones. Algunas, como `api_key_id`, se aplican solo a organizaciones de Claude Console, y otras, como `slack_channel_id`, se aplican solo a organizaciones de Claude Enterprise. Una dimensión que no se aplica a tu organización es `null` en todas las filas y su filtro no coincide con nada; la excepción es `rbac_group_id`, que en su lugar devuelve un error cuando los equipos no están disponibles para tu organización. La referencia de la API de [uso](https://platform.claude.com/docs/es/api/beta/organization/analytics/usage/list) y [costos](https://platform.claude.com/docs/es/api/beta/organization/analytics/cost/list) enumera todas las dimensiones, filtros y valores. ### Actores La dimensión `actor` indica a quién se atribuye una solicitud: un usuario, una cuenta de servicio, una identidad de nube federada (un principal de AWS o Google Cloud, para organizaciones que acceden a Claude a través de su plataforma en la nube) o, cuando ninguno de ellos está detrás de la solicitud, la propia clave de API. Cuando agrupas por `actor`, el `actor` de cada fila es un objeto cuyo `type` indica de qué tipo es. El uso que no se puede atribuir a ninguna identidad tiene `actor: null`. Las [claves personales y las claves de cuenta de servicio](https://platform.claude.com/docs/es/manage-claude/authentication#key-types) actúan como el usuario o la cuenta de servicio a los que están vinculadas, por lo que sus solicitudes muestran esa identidad como `actor` y la clave en `api_key_id`. Las claves de espacio de trabajo heredadas no están vinculadas a una identidad, por lo que la clave aparece como `actor` y también como `api_key_id`. La excepción es la clave que crea Claude Code cuando un miembro inicia sesión con su cuenta de Claude Console: reside en el [espacio de trabajo de Claude Code](https://platform.claude.com/docs/es/manage-claude/workspaces#claude-code-workspace), y su uso se atribuye a ese miembro. Las solicitudes realizadas sin una clave de API, como desde Claude Console o con un token de [Workload Identity Federation](https://platform.claude.com/docs/es/manage-claude/workload-identity-federation), tienen `api_key_id: null`; el `actor` de una carga de trabajo federada es su cuenta de servicio. Para incluir el uso sin clave de API en un filtro `api_key_ids[]`, agrega una entrada vacía: `api_key_ids[]=`. Los filtros `api_key_ids[]` y `actor_ids[]` responden a preguntas diferentes. `api_key_ids[]=apikey_...` coincide con todas las solicitudes que autenticó la clave, sin importar a quién se atribuyan. `actor_ids[]=apikey_...` coincide solo con las solicitudes atribuidas a la propia clave. ## Endpoint de uso `GET /v1/organizations/analytics/usage` devuelve recuentos de tokens por tipo. `order_by` acepta `total_tokens` (el valor predeterminado), `output_tokens`, `uncached_input_tokens`, `requests` o `time`. Por ejemplo, para ver una semana de uso de un espacio de trabajo y una clave de API, desglosado por nivel de servicio (una fila por cada nivel, que cubre toda la semana): ```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 ``` Para buscar los ID de claves de API y de espacios de trabajo, usa los endpoints [List API Keys](https://platform.claude.com/docs/es/api/organization/api_keys/list) y [List Workspaces](https://platform.claude.com/docs/es/api/organization/workspaces/list) o Claude Console. Para averiguar qué usuarios, cuentas de servicio y claves de API realizaron más solicitudes en un mes: ```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 ``` ## Endpoint de costos `GET /v1/organizations/analytics/cost` acepta los mismos filtros, dimensiones e intervalos de tiempo que el endpoint `/usage`. El objeto `cost` de cada fila contiene `amount` (el costo después de descuentos y antes de aplicar cualquier crédito), `list_amount` (el costo a precios de lista), `currency` (siempre `"USD"`) y `requests`. Los importes son cadenas decimales en centavos con seis decimales: `"41280.000000"` equivale a $412.80 USD. `order_by` acepta `amount` (el valor predeterminado), `list_amount` o `time`. Existen dos dimensiones adicionales solo en este endpoint que no cuentan para el límite de cinco dimensiones: `group_by[]=cost_type` divide cada fila en una fila por cada tipo de costo, y `group_by[]=token_type` divide el costo de tokens en una fila por cada tipo de token. `limit` tampoco se aplica a estas dos dimensiones, por lo que una página puede contener más de `limit` filas. Por ejemplo, el costo por modelo, tipo de costo y tipo de token durante un mes: ```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 ``` Para cada modelo, la respuesta tiene cinco filas de `tokens` (una por cada tipo de token) más una fila para cada uno de `web_search`, `code_execution` y `session_usage`. Una de esas filas: ```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 } } ``` El objeto `group` incluye todas las dimensiones y aquí está abreviado. Cuando se especifica `group_by[]=cost_type` o `token_type`, `requests` es `null` en todas las filas. Las solicitudes atendidas bajo un compromiso de Priority Tier aparecen en el endpoint de uso con `service_tier: "priority"`, pero aportan un costo de tokens de cero a `amount` y `list_amount`, porque tu compromiso las cubre; la tarifa del compromiso se factura por separado y no está en estos datos. La búsqueda web en esas solicitudes se factura a la tarifa estándar. Las solicitudes que superan tu capacidad comprometida se atienden y se cobran en el nivel estándar. ## Rangos de fechas e intervalos de tiempo * Las marcas de tiempo siguen RFC 3339 con un desplazamiento UTC, por ejemplo `2026-09-01T00:00:00Z`. `starting_at` es inclusivo y `ending_at` es exclusivo. * `starting_at` debe ser el 1 de enero de 2026 o posterior, y estar dentro de los últimos 365 días. Una solicitud puede abarcar como máximo 31 días; `ending_at` tiene como valor predeterminado 31 días después de `starting_at` o la hora actual, lo que ocurra primero. * `ending_at` es obligatorio siempre que se establezca `time_bucket_width`, y con `time_bucket_width=1m` una solicitud puede abarcar como máximo 24 horas. * Ambos extremos del rango se redondean hacia abajo a un límite de intervalo UTC, o a la hora cuando no se establece `time_bucket_width`. Por ejemplo, con `time_bucket_width=1h`, un `starting_at` de `2026-09-01T10:43:00Z` se trata como `2026-09-01T10:00:00Z` y un `ending_at` de `2026-09-01T15:43:00Z` como `2026-09-01T15:00:00Z`, por lo que la respuesta cubre de 10:00 a 15:00 UTC. ## Actualización de los datos Cada respuesta incluye una marca de tiempo `data_refreshed_at`, y el uso posterior a ese momento falta o es parcial. Cuando todavía no hay datos disponibles para ninguna parte del rango solicitado, `data_refreshed_at` es `null` y `data` está vacío. Los datos suelen actualizarse dentro de las 4 horas posteriores al uso subyacente y pueden tardar hasta 24 horas. Los valores pueden revisarse a medida que llegan eventos tardíos y se ejecuta la conciliación, hasta aproximadamente 7 días después del final del mes calendario. Por ejemplo, los valores del 1 de octubre pueden cambiar hasta aproximadamente el 7 de noviembre. Para obtener resultados estables en llamadas repetidas, establece `ending_at` en un `data_refreshed_at` que ya hayas visto o antes; para obtener totales finales, consulta solo meses que hayan terminado hace al menos 7 días. Cada página de una consulta paginada lee la misma instantánea de datos, por lo que `data_refreshed_at` es idéntico en todas las páginas. ## Migrar desde la API de uso y costos Esta sección es para organizaciones de Claude Console que llaman a la [API de uso y costos](https://platform.claude.com/docs/es/manage-claude/usage-cost-api) heredada (`/v1/organizations/usage_report/messages` y `/v1/organizations/cost_report`). Tu clave de API de administrador, el encabezado `anthropic-version`, `starting_at` y `ending_at`, los valores de ancho de intervalo (`1m`, `1h`, `1d`), la notación de corchetes, los nombres de los campos de paginación y los nombres de los campos de tokens y costos se mantienen. Lo que cambia: | API de uso y costos | API de análisis de uso y costos | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Sin encabezado beta | `anthropic-beta: analytics-usage-cost-2026-08-24` en cada solicitud | | Los datos suelen aparecer en 5 minutos | Los datos suelen actualizarse en 4 horas y pueden tardar hasta 24 horas (consulta [Actualización de los datos](https://platform.claude.com/docs/es/manage-claude/usage-cost-analytics-api#data-freshness)) | | `data` es una lista de intervalos de tiempo, del más antiguo al más reciente, incluidos los vacíos, cada uno con una lista `results` cuyas entradas contienen dimensiones y métricas una al lado de la otra | `data` es una lista de filas clasificadas por `order_by`, cada una con sus propios `starting_at` y `ending_at`, dimensiones en `group` y métricas en `usage` o `cost`. Las combinaciones sin uso ni costo no tienen fila. | | `bucket_width`, predeterminado `1d` | `time_bucket_width`, sin valor predeterminado. Pasa `time_bucket_width=1d` para mantener filas diarias; omítelo para obtener totales de todo el rango. El endpoint de costos también acepta todos los filtros e intervalos de `1m` y `1h`. | | `limit` cuenta intervalos de tiempo por página | `limit` cuenta filas por página (de 1 a 1,000, predeterminado 20), por lo que el número de páginas depende de cuántas combinaciones tienen datos | | Cualquier rango de fechas, paginado hacia adelante por intervalo | `starting_at` el 1 de enero de 2026 o después, y dentro de los últimos 365 días, como máximo 31 días por solicitud, `ending_at` obligatorio con `time_bucket_width`, y como máximo 24 horas con intervalos de `1m` (consulta [Rangos de fechas e intervalos de tiempo](https://platform.claude.com/docs/es/manage-claude/usage-cost-analytics-api#date-ranges-and-time-buckets)). Divide los rangos más largos en varias solicitudes. | | `account_ids[]`, `service_account_ids[]`, `group_by[]=account_id`, `group_by[]=service_account_id` | `actor_ids[]` con los mismos ID etiquetados, y `group_by[]=actor` o `actor_type`; lee `actor.user_id` o `actor.service_account_id`. Consulta [Actores](https://platform.claude.com/docs/es/manage-claude/usage-cost-analytics-api#actors). | | `context_window[]` | `context_windows[]` | | `group_by[]=description` en el informe de costos, con una cadena `description` | Sin `description`. En su lugar, agrupa por las dimensiones estructuradas: cualquiera de `model`, `cost_type`, `token_type`, `context_window`, `service_tier`, `inference_geo` y `speed`, que caben todas en una sola solicitud. | | Un ID de clave de API o de espacio de trabajo desconocido devuelve un error | No coincide con nada, incluido un nombre de `models[]` mal escrito. Cada lista admite hasta 100 valores. | | `workspace_id: null` para el espacio de trabajo predeterminado | El `workspace_id` real del espacio de trabajo predeterminado (consulta [¿Cómo se representa el espacio de trabajo predeterminado?](https://platform.claude.com/docs/es/manage-claude/usage-cost-analytics-api#how-is-the-default-workspace-represented)) | | `inference_geo: "not_available"` y `service_tier: "standard"` en el uso sin geografía de inferencia ni nivel | `null` para ambos. `inference_geos[]=not_available` sigue coincidiendo con las filas sin geografía de inferencia. | | El `service_tier` de costos es `standard` o `batch`; `amount` como `"123.45"` | El nivel real; `amount` con seis decimales, como `"123.450000"`, más `list_amount`. | | La ejecución de código no aparece en el informe de uso; sin recuentos de solicitudes | La ejecución de código aparece como filas de uso con `model: null`; agrega `requests` en ambos endpoints y `total_tokens` en las filas de uso | Para reproducir el informe diario heredado, solicita `time_bucket_width=1d` con el mismo `group_by[]`, recorre las páginas con `limit=1000` y luego agrupa las filas por `starting_at` y rellena los días faltantes con ceros. Agrega `order_by=time&order=asc` para obtener los días en orden. Uso diario por modelo durante 1 semana, antes: ```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" ``` y despué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 ``` Costo diario por espacio de trabajo, modelo, nivel de servicio, ventana de contexto y geografía de inferencia, dividido por tipo de costo y tipo 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 ``` ## Migrar desde los informes de uso y costos de Claude Enterprise Esta sección es para organizaciones de Claude Enterprise que llaman a los endpoints de informes `usage_report`, `cost_report`, `user_usage_report` y `user_cost_report` de la [Claude Enterprise Analytics API](https://platform.claude.com/docs/es/manage-claude/analytics-api) bajo `/v1/organizations/analytics/`. Esos endpoints son heredados y siguen siendo compatibles. Migra a `/analytics/usage` y `/analytics/cost` cuando quieras alguna de las siguientes ventajas: * Todos los grupos de cada intervalo de tiempo, en lugar de los 100 grupos principales de cada intervalo * Agrupación por `actor` o `actor_type` junto con otras dimensiones, tanto en uso como en costos * Filas clasificadas según la métrica que elijas en todo el rango, u ordenadas por intervalo de tiempo * Una sola integración que también sirve para organizaciones de Claude Console Se mantienen tu clave, la fecha más antigua, el período retrospectivo de 365 días y el rango de 31 días, los nombres y valores de filtros y dimensiones (excepto `user_ids[]` y el valor de producto de Claude Tag), los campos de `actor` de usuario, los campos de métricas e importes, `data_refreshed_at`, las reglas del cursor y el [límite de velocidad a nivel de organización](https://platform.claude.com/docs/es/manage-claude/analytics-api#working-with-the-api). El único encabezado nuevo es el encabezado beta `analytics-usage-cost-2026-08-24`. Lo que cambia: | Informes de Claude Enterprise | API de análisis de uso y costos | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `usage_report` y `cost_report` devuelven intervalos de tiempo, del más antiguo al más reciente, incluidos los vacíos, cada uno con como máximo sus 100 grupos principales; `bucket_width` tiene como valor predeterminado `1d` y `limit` cuenta intervalos | Filas que cubren todas las combinaciones con datos, clasificadas por `order_by`, cada una con sus propios `starting_at` y `ending_at`, dimensiones en `group` y métricas en `usage` o `cost`. `time_bucket_width` es opcional y `limit` cuenta filas. | | El parámetro de intervalo de tiempo es `bucket_width` | Es `time_bucket_width`, con los mismos valores | | En `usage_report` y `cost_report`, `ending_at` es opcional con `bucket_width` y los intervalos de `1m` pueden abarcar hasta 31 días | `ending_at` obligatorio con `time_bucket_width`; los intervalos de `1m` abarcan como máximo 24 horas por solicitud | | `user_usage_report` y `user_cost_report` devuelven una fila por usuario | `group_by[]=actor&actor_types[]=user_actor`. Sin el filtro, también obtienes filas para identidades que no son usuarios y una fila `actor: null` para el uso no atribuido. | | El uso de Claude Tag tiene `product: "claude-tag"` | `product: "claude_tag"`; `products[]` acepta cualquiera de las dos grafías | | Un nombre de `models[]` no reconocido devuelve un error 400 | No coincide con nada | | `user_ids[]` | `actor_ids[]` con los mismos ID etiquetados `user_...` | | `exclude_deleted_users` en los informes por usuario | Requiere `group_by[]=actor`; sin él, la solicitud devuelve un error 400. Solo descarta las filas cuyo `actor` es un usuario con `deleted: true`; las filas de otras identidades y las filas con `actor: null` se mantienen. | Costo por usuario durante un mes, antes: ```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 ``` y después, agregando un desglose por producto: ```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 ``` ## Preguntas frecuentes ### ¿Cómo se representa el espacio de trabajo predeterminado? El espacio de trabajo predeterminado de una organización de Claude Console tiene su propio ID `wrkspc_`, como cualquier otro espacio de trabajo. Las filas del espacio de trabajo predeterminado tienen ese ID en `workspace_id`, y puedes filtrar por él con `workspace_ids[]`. [List Workspaces](https://platform.claude.com/docs/es/api/organization/workspaces/list) omite el espacio de trabajo predeterminado a menos que pases `include_default=true`. Para comprobar si un `workspace_id` desconocido es el espacio de trabajo predeterminado, pásalo a [Get Workspace](https://platform.claude.com/docs/es/api/organization/workspaces/retrieve): el espacio de trabajo predeterminado devuelve `"name": "Default"`. ### ¿Cómo obtengo el costo por usuario de Claude Code? Llama al endpoint de costos con `products[]=claude_code&group_by[]=actor`. Las organizaciones de Claude Console también pueden usar la [Claude Code Analytics API](https://platform.claude.com/docs/es/manage-claude/claude-code-analytics-api), que informa la actividad de Claude Code por usuario y el costo estimado. ## Consulta también * [API de uso y costos](https://platform.claude.com/docs/es/manage-claude/usage-cost-api) (heredada) * [APIs de analítica](https://platform.claude.com/docs/es/manage-claude/analytics-api): qué API de analítica y qué tipo de clave necesita tu organización * [Claude Code Analytics API](https://platform.claude.com/docs/es/manage-claude/claude-code-analytics-api) * [Referencia de la Admin API](https://platform.claude.com/docs/es/api/beta/organization) * [Precios](https://platform.claude.com/docs/es/about-claude/pricing)