---
title: Níveis de serviço
url: https://platform.claude.com/docs/pt-BR/api/service-tiers
description: Diferentes níveis de serviço permitem que você equilibre disponibilidade, desempenho e custos previsíveis com base nas necessidades da sua aplicação.
---

<Warning>
  Os compromissos de capacidade do Priority Tier não estão mais disponíveis para compra. Organizações com um compromisso existente podem continuar a usar o Priority Tier até a data de término do contrato, e esta página permanece disponível como referência para elas. Se você precisa de capacidade garantida, [entre em contato com vendas](https://claude.com/contact-sales).
</Warning>

A Anthropic oferece três "service tiers" (níveis de serviço):

* **Priority Tier:** Disponível apenas para organizações com um compromisso de capacidade existente
* **Standard:** Nível padrão tanto para pilotos quanto para escalar casos de uso do dia a dia
* **Batch:** Melhor para fluxos de trabalho assíncronos que podem esperar ou se beneficiar de estar fora da sua capacidade normal

## Nível Standard

O nível standard é o nível de serviço padrão para todas as requisições de API. A API prioriza essas requisições junto com todas as outras requisições com disponibilidade de melhor esforço.

## Priority Tier

A API prioriza as requisições neste nível acima de todas as outras requisições. Essa priorização ajuda a minimizar [erros de "servidor sobrecarregado"](https://platform.claude.com/docs/pt-BR/api/errors#http-errors), mesmo durante horários de pico.

Para mais informações, consulte [Compromissos existentes do Priority Tier](https://platform.claude.com/docs/pt-BR/api/service-tiers#existing-priority-tier-commitments).

## Como as requisições são atribuídas aos níveis

Ao processar uma requisição, a Anthropic decide atribuir uma requisição ao Priority Tier nos seguintes cenários:

* Sua organização tem capacidade suficiente do Priority Tier em tokens de **entrada** por minuto
* Sua organização tem capacidade suficiente do Priority Tier em tokens de **saída** por minuto

A Anthropic contabiliza o uso em relação à capacidade do Priority Tier da seguinte forma:

**Tokens de entrada**

* Leituras de cache como 0,1 token por token lido do cache
* Escritas de cache como 1,25 token por token escrito no cache com um TTL de 5 minutos
* Escritas de cache como 2,00 tokens por token escrito no cache com um TTL de 1 hora
* Para requisições de [inferência somente nos EUA](https://platform.claude.com/docs/pt-BR/manage-claude/data-residency) (`inference_geo: "us"`) nos modelos Claude 4.6 e posteriores, os tokens de entrada são 1,1 token por token
* Todos os outros tokens de entrada são 1 token por token

**Tokens de saída**

* Para requisições de [inferência somente nos EUA](https://platform.claude.com/docs/pt-BR/manage-claude/data-residency) (`inference_geo: "us"`) nos modelos Claude 4.6 e posteriores, os tokens de saída são 1,1 token por token
* Todos os outros tokens de saída são 1 token por token

Caso contrário, as requisições prosseguem no nível standard.

<Note>
  Essas taxas de consumo refletem o preço relativo de cada tipo de token. Por exemplo, a inferência somente nos EUA tem preço de 1,1x nos modelos Claude 4.6 e posteriores, portanto cada token consumido com `inference_geo: "us"` deduz 1,1 token da sua capacidade do Priority Tier.
</Note>

<Note>
  Requisições atribuídas ao Priority Tier consomem tanto da capacidade do Priority Tier quanto dos limites de taxa regulares. Se atender à requisição exceder os limites de taxa, a requisição é recusada.
</Note>

## Usando níveis de serviço

Você pode controlar quais níveis de serviço podem ser usados para uma requisição definindo o 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 automaticamente o Priority Tier quando disponível, com fallback para o padrão
  	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 automaticamente o Priority Tier quando disponível, com fallback para o padrão
      .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>

O parâmetro `service_tier` aceita os seguintes valores:

* `"auto"` (padrão) - Usa a capacidade do Priority Tier se disponível, recorrendo à sua outra capacidade caso contrário
* `"standard_only"` - Usa apenas a capacidade do nível standard, útil se você não quiser usar sua capacidade do Priority Tier

O objeto `usage` da resposta também inclui o nível de serviço atribuído à requisição:

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

Isso permite que você determine qual nível de serviço foi atribuído à requisição.

Ao solicitar `service_tier="auto"` com um modelo que possui um compromisso do Priority Tier, estes cabeçalhos de resposta fornecem informações:

```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
```

Você pode usar a presença desses cabeçalhos para detectar se sua requisição era elegível para o Priority Tier, mesmo que estivesse acima do limite.

## Compromissos existentes do Priority Tier

Um compromisso do Priority Tier consiste em:

* Um número de tokens de entrada por minuto
* Um número de tokens de saída por minuto
* Uma duração do compromisso (1, 3, 6 ou 12 meses)
* Uma versão específica de modelo

O Priority Tier tem como meta 99,5% de disponibilidade com recursos computacionais priorizados. Requisições além da sua capacidade contratada recorrem automaticamente ao nível standard.

### Modelos suportados

O Priority Tier é suportado em todos os modelos Claude disponíveis, exceto 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 e Claude Sonnet 5.

Consulte a [Visão geral dos modelos](https://platform.claude.com/docs/pt-BR/models/overview) para mais detalhes sobre os modelos disponíveis.