---
title: Niveles de servicio
url: https://platform.claude.com/docs/es/api/service-tiers
description: Los diferentes niveles de servicio te permiten equilibrar la disponibilidad, el rendimiento y los costos predecibles según las necesidades de tu aplicación.
---

<Warning>
  Los compromisos de capacidad de Priority Tier ya no están disponibles para su compra. Las organizaciones con un compromiso existente pueden seguir usando Priority Tier hasta la fecha de finalización de su contrato, y esta página permanece disponible como referencia para ellas. Si necesitas capacidad garantizada, [contacta a ventas](https://claude.com/contact-sales).
</Warning>

Anthropic ofrece tres "service tiers" (niveles de servicio):

* **Priority Tier:** Disponible únicamente para organizaciones con un compromiso de capacidad existente
* **Standard:** Nivel predeterminado tanto para pruebas piloto como para escalar casos de uso cotidianos
* **Batch:** Ideal para flujos de trabajo asíncronos que pueden esperar o que se benefician de estar fuera de tu capacidad normal

## Nivel estándar

El nivel standard es el nivel de servicio predeterminado para todas las solicitudes a la API. La API prioriza estas solicitudes junto con todas las demás solicitudes con disponibilidad de mejor esfuerzo.

## Priority Tier

La API prioriza las solicitudes de este nivel por encima de todas las demás solicitudes. Esta priorización ayuda a minimizar los [errores de "servidor sobrecargado"](https://platform.claude.com/docs/es/api/errors#http-errors), incluso durante las horas pico.

Para obtener más información, consulta [Compromisos existentes de Priority Tier](https://platform.claude.com/docs/es/api/service-tiers#existing-priority-tier-commitments).

## Cómo se asignan los niveles a las solicitudes

Al procesar una solicitud, Anthropic decide asignar una solicitud a Priority Tier en los siguientes escenarios:

* Tu organización tiene suficiente capacidad de Priority Tier en tokens de **entrada** por minuto
* Tu organización tiene suficiente capacidad de Priority Tier en tokens de **salida** por minuto

Anthropic contabiliza el uso contra la capacidad de Priority Tier de la siguiente manera:

**Tokens de entrada**

* Las lecturas de caché cuentan como 0.1 tokens por cada token leído de la caché
* Las escrituras en caché cuentan como 1.25 tokens por cada token escrito en la caché con un TTL de 5 minutos
* Las escrituras en caché cuentan como 2.00 tokens por cada token escrito en la caché con un TTL de 1 hora
* Para solicitudes de [inferencia solo en EE. UU.](https://platform.claude.com/docs/es/manage-claude/data-residency) (`inference_geo: "us"`) en modelos Claude 4.6 y posteriores, los tokens de entrada cuentan como 1.1 tokens por token
* Todos los demás tokens de entrada cuentan como 1 token por token

**Tokens de salida**

* Para solicitudes de [inferencia solo en EE. UU.](https://platform.claude.com/docs/es/manage-claude/data-residency) (`inference_geo: "us"`) en modelos Claude 4.6 y posteriores, los tokens de salida cuentan como 1.1 tokens por token
* Todos los demás tokens de salida cuentan como 1 token por token

De lo contrario, las solicitudes se procesan en el nivel standard.

<Note>
  Estas tasas de consumo reflejan el precio relativo de cada tipo de token. Por ejemplo, la inferencia solo en EE. UU. tiene un precio de 1.1x en modelos Claude 4.6 y posteriores, por lo que cada token consumido con `inference_geo: "us"` descuenta 1.1 tokens de tu capacidad de Priority Tier.
</Note>

<Note>
  Las solicitudes asignadas a Priority Tier consumen tanto de la capacidad de Priority Tier como de los "rate limits" (límites de velocidad) regulares. Si atender la solicitud excediera los límites de velocidad, la solicitud se rechaza.
</Note>

## Uso de los niveles de servicio

Puedes controlar qué niveles de servicio se pueden usar para una solicitud configurando el parámetro `service_tier`:

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-4-8",
      "max_tokens": 1024,
      "messages": [{"role": "user", "content": "Hello, Claude!"}],
      "service_tier": "auto"
    }'
  ```

  ```bash CLI
  ant messages create --transform usage.service_tier --raw-output <<'YAML'
  model: claude-opus-4-8
  max_tokens: 1024
  messages:
    - role: user
      content: Hello, Claude!
  service_tier: auto  # Automatically use Priority Tier when available, fallback to standard
  YAML
  ```

  ```python Python
  client = anthropic.Anthropic()

  message = client.messages.create(
      model="claude-opus-4-8",
      max_tokens=1024,
      messages=[{"role": "user", "content": "Hello, Claude!"}],
      service_tier="auto",  # Automatically use Priority Tier when available, fallback to standard
  )
  print(message.usage.service_tier)
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const message = await client.messages.create({
    model: "claude-opus-4-8",
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude!" }],
    service_tier: "auto" // Automatically use Priority Tier when available, fallback to standard
  });
  console.log(message.usage.service_tier);
  ```

  ```csharp C#
  AnthropicClient client = new();

  var message = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus4_8,
      MaxTokens = 1024,
      Messages = [new() { Role = Role.User, Content = "Hello, Claude!" }],
      ServiceTier = ServiceTier.Auto, // Automatically use Priority Tier when available, fallback to standard
  });
  Console.WriteLine(message.Usage.ServiceTier);
  ```

  ```go Go
  client := anthropic.NewClient()

  message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus4_8,
  	MaxTokens: 1024,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude!")),
  	},
  	// Usa automáticamente Priority Tier cuando esté disponible; si no, recurre al estándar
  	ServiceTier: anthropic.MessageNewParamsServiceTierAuto,
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(message.Usage.ServiceTier)
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_OPUS_4_8)
      .maxTokens(1024L)
      .addUserMessage("Hello, Claude!")
      // Usa automáticamente Priority Tier cuando esté disponible; si no, recurre al estándar
      .serviceTier(MessageCreateParams.ServiceTier.AUTO)
      .build();

  Message message = client.messages().create(params);
  IO.println(message.usage().serviceTier().orElseThrow());
  ```

  ```php PHP
  $client = new Client();

  $message = $client->messages->create(
      model: 'claude-opus-4-8',
      maxTokens: 1024,
      messages: [['role' => 'user', 'content' => 'Hello, Claude!']],
      serviceTier: 'auto', // Automatically use Priority Tier when available, fallback to standard
  );
  echo $message->usage->serviceTier;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  message = client.messages.create(
    model: "claude-opus-4-8",
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude!" }],
    service_tier: :auto # Automatically use Priority Tier when available, fallback to standard
  )
  puts(message.usage.service_tier)
  ```
</CodeGroup>

El parámetro `service_tier` acepta los siguientes valores:

* `"auto"` (predeterminado) - Usa la capacidad de Priority Tier si está disponible y, si no, recurre a tu otra capacidad
* `"standard_only"` - Usa únicamente la capacidad del nivel standard; útil si no quieres usar tu capacidad de Priority Tier

El objeto `usage` de la respuesta también incluye el nivel de servicio asignado a la solicitud:

```json
{
  "usage": {
    "input_tokens": 410,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0,
    "output_tokens": 585,
    "service_tier": "priority"
  }
}
```

Esto te permite determinar qué nivel de servicio se asignó a la solicitud.

Al solicitar `service_tier="auto"` con un modelo que tiene un compromiso de Priority Tier, estos encabezados de respuesta proporcionan información:

```text wrap
anthropic-priority-input-tokens-limit: 10000
anthropic-priority-input-tokens-remaining: 9618
anthropic-priority-input-tokens-reset: 2025-01-12T23:11:59Z
anthropic-priority-output-tokens-limit: 10000
anthropic-priority-output-tokens-remaining: 6000
anthropic-priority-output-tokens-reset: 2025-01-12T23:12:21Z
```

Puedes usar la presencia de estos encabezados para detectar si tu solicitud era elegible para Priority Tier, incluso si superó el límite.

## Compromisos existentes de Priority Tier

Un compromiso de Priority Tier consiste en:

* Una cantidad de tokens de entrada por minuto
* Una cantidad de tokens de salida por minuto
* Una duración del compromiso (1, 3, 6 o 12 meses)
* Una versión específica del modelo

Priority Tier tiene como objetivo un tiempo de actividad del 99.5% con recursos computacionales priorizados. Las solicitudes que superen tu capacidad comprometida recurren automáticamente al nivel standard.

### Modelos compatibles

Priority Tier es compatible con todos los modelos de Claude disponibles, excepto Claude Fable 5.1, Claude Haiku 5.5, Claude Mythos 5.1, Claude Mythos 5, [Claude Mythos Preview](https://anthropic.com/glasswing), Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5 y Claude Sonnet 5.

Consulta la [descripción general de los modelos](https://platform.claude.com/docs/es/models/overview) para obtener más detalles sobre los modelos disponibles.