---
title: Tingkat layanan
url: https://platform.claude.com/docs/id/api/service-tiers
description: Berbagai tingkat layanan memungkinkan Anda menyeimbangkan ketersediaan, performa, dan biaya yang dapat diprediksi berdasarkan kebutuhan aplikasi Anda.
---

<Warning>
  Komitmen kapasitas Priority Tier tidak lagi tersedia untuk dibeli. Organisasi yang memiliki komitmen yang sudah ada dapat terus menggunakan Priority Tier hingga tanggal berakhirnya kontrak mereka, dan halaman ini tetap tersedia sebagai referensi bagi mereka. Jika Anda memerlukan kapasitas yang terjamin, [hubungi tim penjualan](https://claude.com/contact-sales).
</Warning>

Anthropic menawarkan tiga "service tiers" (tingkat layanan):

* **Priority Tier:** Hanya tersedia bagi organisasi yang memiliki komitmen kapasitas yang sudah ada
* **Standard:** Tingkat default untuk uji coba maupun penskalaan kasus penggunaan sehari-hari
* **Batch:** Paling cocok untuk alur kerja asinkron yang dapat menunggu atau diuntungkan dengan berada di luar kapasitas normal Anda

## Tingkat standar

Standard tier adalah tingkat layanan default untuk semua permintaan API. API memprioritaskan permintaan ini bersama semua permintaan lainnya dengan ketersediaan best-effort (upaya terbaik).

## Priority Tier

API memprioritaskan permintaan dalam tingkat ini di atas semua permintaan lainnya. Prioritas ini membantu meminimalkan [error "server overloaded"](https://platform.claude.com/docs/id/api/errors#http-errors), bahkan pada waktu puncak.

Untuk informasi lebih lanjut, lihat [Komitmen Priority Tier yang sudah ada](https://platform.claude.com/docs/id/api/service-tiers#existing-priority-tier-commitments).

## Cara permintaan ditetapkan ke tingkat layanan

Saat menangani permintaan, Anthropic memutuskan untuk menetapkan permintaan ke Priority Tier dalam skenario berikut:

* Organisasi Anda memiliki kapasitas Priority Tier token **input** per menit yang mencukupi
* Organisasi Anda memiliki kapasitas Priority Tier token **output** per menit yang mencukupi

Anthropic menghitung penggunaan terhadap kapasitas Priority Tier sebagai berikut:

**Token input**

* Pembacaan cache dihitung sebagai 0,1 token per token yang dibaca dari cache
* Penulisan cache dihitung sebagai 1,25 token per token yang ditulis ke cache dengan TTL 5 menit
* Penulisan cache dihitung sebagai 2,00 token per token yang ditulis ke cache dengan TTL 1 jam
* Untuk permintaan [inferensi khusus AS](https://platform.claude.com/docs/id/manage-claude/data-residency) (`inference_geo: "us"`) pada model Claude 4.6 dan yang lebih baru, token input dihitung sebagai 1,1 token per token
* Semua token input lainnya dihitung sebagai 1 token per token

**Token output**

* Untuk permintaan [inferensi khusus AS](https://platform.claude.com/docs/id/manage-claude/data-residency) (`inference_geo: "us"`) pada model Claude 4.6 dan yang lebih baru, token output dihitung sebagai 1,1 token per token
* Semua token output lainnya dihitung sebagai 1 token per token

Jika tidak, permintaan diproses pada standard tier.

<Note>
  Laju burndown (pengurangan kapasitas) ini mencerminkan harga relatif dari setiap jenis token. Misalnya, inferensi khusus AS dihargai 1,1x pada model Claude 4.6 dan yang lebih baru, sehingga setiap token yang dikonsumsi dengan `inference_geo: "us"` mengurangi 1,1 token dari kapasitas Priority Tier Anda.
</Note>

<Note>
  Permintaan yang ditetapkan ke Priority Tier mengambil dari kapasitas Priority Tier maupun "rate limits" (batas laju) reguler. Jika melayani permintaan tersebut akan melampaui batas laju, permintaan akan ditolak.
</Note>

## Menggunakan tingkat layanan

Anda dapat mengontrol tingkat layanan mana yang dapat digunakan untuk suatu permintaan dengan mengatur parameter `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!")),
  	},
  	// Otomatis gunakan Priority Tier jika tersedia, fallback ke standar
  	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!")
      // Otomatis gunakan Priority Tier jika tersedia, fallback ke standar
      .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>

Parameter `service_tier` menerima nilai-nilai berikut:

* `"auto"` (default) - Menggunakan kapasitas Priority Tier jika tersedia, dan beralih ke kapasitas Anda yang lain jika tidak tersedia
* `"standard_only"` - Hanya menggunakan kapasitas standard tier, berguna jika Anda tidak ingin menggunakan kapasitas Priority Tier Anda

Objek `usage` pada respons juga menyertakan tingkat layanan yang ditetapkan untuk permintaan tersebut:

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

Ini memungkinkan Anda menentukan tingkat layanan mana yang ditetapkan untuk permintaan tersebut.

Saat meminta `service_tier="auto"` dengan model yang memiliki komitmen Priority Tier, header respons berikut memberikan informasi:

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

Anda dapat menggunakan keberadaan header ini untuk mendeteksi apakah permintaan Anda memenuhi syarat untuk Priority Tier, meskipun permintaan tersebut melampaui batas.

## Komitmen Priority Tier yang sudah ada

Komitmen Priority Tier terdiri dari:

* Sejumlah token input per menit
* Sejumlah token output per menit
* Durasi komitmen (1, 3, 6, atau 12 bulan)
* Versi model tertentu

Priority Tier menargetkan uptime 99,5% dengan sumber daya komputasi yang diprioritaskan. Permintaan yang melampaui kapasitas komitmen Anda secara otomatis beralih ke standard tier.

### Model yang didukung

Priority Tier didukung pada semua model Claude yang tersedia kecuali 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, dan Claude Sonnet 5.

Lihat [Ikhtisar model](https://platform.claude.com/docs/id/models/overview) untuk detail lebih lanjut tentang model yang tersedia.