> ## Documentation Index
> Fetch the complete documentation index at: https://docs.arouter.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# プロバイダールーティング

> ARouter はリクエストを最適な利用可能なプロバイダーに自動的にルーティングします。provider オブジェクトでルーティングをカスタマイズ——価格、スループット、レイテンシーでソート；量子化でフィルタリング；データポリシーを適用。

ARouter はモデルの可用性、プロバイダーの健全性、コスト効率に基づいて、各リクエストを最適なアップストリームプロバイダーに自動的にルーティングします。ほとんどのユースケースでは、設定なしで自動的に行われます。

高度な制御が必要な場合は、リクエストボディに `provider` オブジェクトを渡して、ルーティング決定のカスタマイズができます。

## `provider` オブジェクト

任意の `/v1/chat/completions` リクエストに `provider` オブジェクトを含めて、ルーティングのデフォルトをオーバーライドします：

```json theme={null}
{
  "model": "openai/gpt-5.4",
  "messages": [{ "role": "user", "content": "Hello!" }],
  "provider": {
    "sort": "throughput",
    "allow_fallbacks": true
  }
}
```

### フィールドリファレンス（全項目）

| フィールド                      | 型                   | デフォルト     | 説明                                               |
| -------------------------- | ------------------- | --------- | ------------------------------------------------ |
| `order`                    | `string[]`          | —         | 順番に試すプロバイダースラッグのリスト。例：`["openai", "azure"]`      |
| `allow_fallbacks`          | `boolean`           | `true`    | プライマリが利用不可の場合にバックアッププロバイダーを許可するか                 |
| `require_parameters`       | `boolean`           | `false`   | リクエスト内の全パラメータをサポートするプロバイダーのみを使用                  |
| `data_collection`          | `"allow" \| "deny"` | `"allow"` | リクエストデータを保存する可能性のあるプロバイダーの使用を制御                  |
| `zdr`                      | `boolean`           | —         | Zero Data Retention エンドポイントのみにルーティングを制限          |
| `only`                     | `string[]`          | —         | このリクエストで許可するプロバイダースラッグのリスト                       |
| `ignore`                   | `string[]`          | —         | このリクエストでスキップするプロバイダースラッグのリスト                     |
| `quantizations`            | `string[]`          | —         | 量子化レベルでフィルタリング。例：`["int4", "int8"]`              |
| `sort`                     | `string \| object`  | —         | `"price"`、`"throughput"`、`"latency"` でプロバイダーをソート |
| `preferred_min_throughput` | `number \| object`  | —         | 優先する最低スループット（tokens/秒）                           |
| `preferred_max_latency`    | `number \| object`  | —         | 優先する最大レイテンシー（秒）                                  |
| `max_price`                | `object`            | —         | トークンあたりの支払い上限価格                                  |

***

## デフォルト戦略：コストベースの負荷分散

デフォルトでは、ARouter はコストを優先しながら、正常なプロバイダー間でリクエストを負荷分散します。アルゴリズム：

1. 過去30秒間に重大な障害があったプロバイダーを除外
2. 安定したプロバイダーの中で、価格の逆数の二乗で重み付けして選択
3. 残りのプロバイダーを自動フォールバックとして使用

**例**: プロバイダーAが$1/Mトークン、プロバイダーBが$2/M、プロバイダーCが\$3/Mの場合：

* プロバイダーAはプロバイダーCより9倍選ばれやすい（逆数二乗重み付け）
* プロバイダーAが失敗した場合、次にプロバイダーCを試みる
* プロバイダーB（最近劣化）は最後に試みる

`sort` または `order` を設定すると、負荷分散は無効になり、プロバイダーは厳密な順序で試みられます。

***

## プロバイダーソート

`sort` フィールドを使用してプロバイダー属性に明示的な優先度を付けます。負荷分散は無効になり、プロバイダーは順番に試みられます。

利用可能なソート値：

* `"price"` — 最低トークンコストを優先
* `"throughput"` — 最高 tokens/秒を優先
* `"latency"` — 最低 Time-to-first-token を優先

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    import OpenAI from "openai";

    const client = new OpenAI({
      baseURL: "https://api.arouter.ai/v1",
      apiKey: "lr_live_xxxx",
    });

    const response = await client.chat.completions.create({
      model: "openai/gpt-5.4",
      messages: [{ role: "user", content: "Hello" }],
      // @ts-ignore
      provider: { sort: "throughput" },
    });
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={null}
    from openai import OpenAI

    client = OpenAI(
        base_url="https://api.arouter.ai/v1",
        api_key="lr_live_xxxx",
    )

    response = client.chat.completions.create(
        model="openai/gpt-5.4",
        messages=[{"role": "user", "content": "Hello"}],
        extra_body={"provider": {"sort": "throughput"}},
    )
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl https://api.arouter.ai/v1/chat/completions \
      -H "Authorization: Bearer lr_live_xxxx" \
      -H "Content-Type: application/json" \
      -d '{
        "model": "openai/gpt-5.4",
        "messages": [{"role": "user", "content": "Hello"}],
        "provider": {"sort": "throughput"}
      }'
    ```
  </Tab>
</Tabs>

### `:nitro` と `:floor` ショートカット

モデルスラッグにサフィックスを追加してソートの省略記法として使用：

| サフィックス   | 同等の設定                          |
| -------- | ------------------------------ |
| `:nitro` | `provider.sort = "throughput"` |
| `:floor` | `provider.sort = "price"`      |

```json theme={null}
{"model": "openai/gpt-5.4:nitro"}  // スループットでソート
{"model": "openai/gpt-5.4:floor"}  // 価格でソート
```

***

## パーティションを使った高度なソート

候補モデルリスト（`models[]`）を使用する場合、`sort` フィールドは `partition` オプションを持つオブジェクトにして、エンドポイントがモデルをまたいでどのようにソートされるかを制御できます。

| フィールド            | 型        | デフォルト     | 説明                                                |
| ---------------- | -------- | --------- | ------------------------------------------------- |
| `sort.by`        | `string` | —         | `"price"`、`"throughput"`、`"latency"`              |
| `sort.partition` | `string` | `"model"` | `"model"`（プライマリモデルを最初に試みる）または `"none"`（グローバルにソート） |

デフォルト（`partition: "model"`）では、エンドポイントはモデルごとにグループ化されます——最初のモデルのエンドポイントは常に2番目のモデルより先に試みられます。`partition: "none"` を設定すると、このグループ化が解除され、全候補モデルにわたるグローバルソートが可能になります。

### ユースケース1：複数モデルにわたる最高スループットへのルーティング

複数の許容可能なモデルがあり、現在最も速いものを使いたい場合：

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    const response = await client.chat.completions.create({
      // @ts-ignore
      models: [
        "anthropic/claude-sonnet-4.6",
        "openai/gpt-5.4",
        "google/gemini-2.5-flash",
      ],
      messages: [{ role: "user", content: "Hello" }],
      provider: {
        sort: { by: "throughput", partition: "none" },
      },
    });
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={null}
    response = client.chat.completions.create(
        model="anthropic/claude-sonnet-4.6",
        messages=[{"role": "user", "content": "Hello"}],
        extra_body={
            "models": [
                "anthropic/claude-sonnet-4.6",
                "openai/gpt-5.4",
                "google/gemini-2.5-flash",
            ],
            "provider": {
                "sort": {"by": "throughput", "partition": "none"},
            },
        },
    )
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl https://api.arouter.ai/v1/chat/completions \
      -H "Authorization: Bearer lr_live_xxxx" \
      -H "Content-Type: application/json" \
      -d '{
        "models": [
          "anthropic/claude-sonnet-4.6",
          "openai/gpt-5.4",
          "google/gemini-2.5-flash"
        ],
        "messages": [{"role": "user", "content": "Hello"}],
        "provider": {
          "sort": {"by": "throughput", "partition": "none"}
        }
      }'
    ```
  </Tab>
</Tabs>

### ユースケース2：パフォーマンス要件を満たす最安値モデル

`partition: "none"` とパフォーマンス閾値を組み合わせて、SLAを満たしながら最低コストのオプションを見つける：

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    const response = await client.chat.completions.create({
      // @ts-ignore
      models: [
        "anthropic/claude-sonnet-4.6",
        "openai/gpt-5.4",
        "google/gemini-2.5-flash",
      ],
      messages: [{ role: "user", content: "Hello" }],
      provider: {
        sort: { by: "price", partition: "none" },
        preferred_min_throughput: { p90: 50 },
      },
    });
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={null}
    response = client.chat.completions.create(
        model="anthropic/claude-sonnet-4.6",
        messages=[{"role": "user", "content": "Hello"}],
        extra_body={
            "models": [
                "anthropic/claude-sonnet-4.6",
                "openai/gpt-5.4",
                "google/gemini-2.5-flash",
            ],
            "provider": {
                "sort": {"by": "price", "partition": "none"},
                "preferred_min_throughput": {"p90": 50},
            },
        },
    )
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl https://api.arouter.ai/v1/chat/completions \
      -H "Authorization: Bearer lr_live_xxxx" \
      -H "Content-Type: application/json" \
      -d '{
        "models": [
          "anthropic/claude-sonnet-4.6",
          "openai/gpt-5.4",
          "google/gemini-2.5-flash"
        ],
        "messages": [{"role": "user", "content": "Hello"}],
        "provider": {
          "sort": {"by": "price", "partition": "none"},
          "preferred_min_throughput": {"p90": 50}
        }
      }'
    ```
  </Tab>
</Tabs>

***

## パフォーマンス閾値

プロバイダーをフィルタリングするための最低スループットまたは最大レイテンシーの設定。閾値を満たさないプロバイダーは優先度が下げられます（末尾に移動）が、完全に除外されるわけではありません。

| フィールド                      | 説明                                                |
| -------------------------- | ------------------------------------------------- |
| `preferred_min_throughput` | 最低 tokens/秒。数値（p50 に適用）またはパーセンタイルキーを持つオブジェクト      |
| `preferred_max_latency`    | 最大 Time-to-first-token（秒）。数値またはパーセンタイルキーを持つオブジェクト |

### パーセンタイルの仕組み

ARouter はローリング5分間ウィンドウでプロバイダーパフォーマンスを追跡します：

| パーセンタイル | 意味                     |
| ------- | ---------------------- |
| `p50`   | リクエストの50%がこの値より良い（中央値） |
| `p75`   | リクエストの75%がこの値より良い      |
| `p90`   | リクエストの90%がこの値より良い      |
| `p99`   | リクエストの99%がこの値より良い      |

高いパーセンタイル（p90/p99）は最悪ケースのパフォーマンスに対する信頼度を高めます。指定した全パーセンタイルカットオフを満たすプロバイダーが優先グループに入ります。

```json theme={null}
{
  "provider": {
    "preferred_min_throughput": {
      "p50": 100,
      "p90": 50
    },
    "preferred_max_latency": {
      "p99": 3.0
    }
  }
}
```

<Note>
  `preferred_min_throughput` と `preferred_max_latency` はソフトな設定です——リクエストの処理を阻害することはありません。これは `max_price` とは異なります。`max_price` はハード制限です。
</Note>

***

## 特定プロバイダーの順序指定

`order` を使用して、試みるプロバイダーとその順序を指定します。`order` が設定されると負荷分散は無効になります。

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    const response = await client.chat.completions.create({
      model: "openai/gpt-5.4",
      messages: [{ role: "user", content: "Hello" }],
      // @ts-ignore
      provider: {
        order: ["openai", "azure"],
      },
    });
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={null}
    response = client.chat.completions.create(
        model="openai/gpt-5.4",
        messages=[{"role": "user", "content": "Hello"}],
        extra_body={
            "provider": {
                "order": ["openai", "azure"],
            }
        },
    )
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl https://api.arouter.ai/v1/chat/completions \
      -H "Authorization: Bearer lr_live_xxxx" \
      -H "Content-Type: application/json" \
      -d '{
        "model": "openai/gpt-5.4",
        "messages": [{"role": "user", "content": "Hello"}],
        "provider": {"order": ["openai", "azure"]}
      }'
    ```
  </Tab>
</Tabs>

## 特定プロバイダーのみを許可

`only` を使用してルーティングを特定のプロバイダーセットに制限：

```json theme={null}
{
  "model": "meta-llama/llama-4-maverick",
  "messages": [{ "role": "user", "content": "Hello" }],
  "provider": {
    "only": ["groq", "together"]
  }
}
```

## プロバイダーの無視

`ignore` を使用してこのリクエストの特定プロバイダーをスキップ：

```json theme={null}
{
  "model": "openai/gpt-5.4",
  "messages": [{ "role": "user", "content": "Hello" }],
  "provider": {
    "ignore": ["azure"]
  }
}
```

## フォールバックの無効化

デフォルトでは、プライマリプロバイダーが利用不可の場合、ARouter は代替プロバイダーにフォールバックします。`allow_fallbacks: false` を設定すると、正確なプロバイダーを要求します：

```json theme={null}
{
  "model": "openai/gpt-5.4",
  "messages": [{ "role": "user", "content": "Hello" }],
  "provider": {
    "order": ["openai"],
    "allow_fallbacks": false
  }
}
```

指定したプロバイダーが利用不可の場合、ARouter は他の場所にルーティングする代わりに `503` エラーを返します。

***

## パラメータサポートの要求

`require_parameters: true` を設定すると、リクエスト内の全パラメータをサポートするプロバイダーのみにルーティングします。デフォルトでは、ARouter はサポートされていないパラメータを無視するプロバイダーにルーティングする場合があります。

```json theme={null}
{
  "model": "openai/gpt-5.4",
  "messages": [{ "role": "user", "content": "Hello" }],
  "tools": [...],
  "provider": {
    "require_parameters": true
  }
}
```

***

## 量子化フィルタリング

プロバイダーが提供するモデルの量子化レベルでフィルタリングします。特定の精度/パフォーマンストレードオフが必要な場合に便利です：

```json theme={null}
{
  "model": "meta-llama/llama-4-maverick",
  "messages": [{ "role": "user", "content": "Hello" }],
  "provider": {
    "quantizations": ["fp16", "bf16"]
  }
}
```

一般的な量子化値：`"fp32"`、`"fp16"`、`"bf16"`、`"int8"`、`"int4"`。

***

## データ収集ポリシー

ARouter がリクエストデータを保存する可能性のあるプロバイダーにルーティングするかどうかを制御：

| 値                | 動作                                        |
| ---------------- | ----------------------------------------- |
| `"allow"`（デフォルト） | データを保存する可能性があるプロバイダーを含む、あらゆるプロバイダーにルーティング |
| `"deny"`         | リクエスト/レスポンスデータを保存しないプロバイダーのみにルーティング       |

```json theme={null}
{
  "model": "anthropic/claude-sonnet-4.6",
  "messages": [{ "role": "user", "content": "Sensitive content" }],
  "provider": {
    "data_collection": "deny"
  }
}
```

## Zero Data Retention（ZDR）

最大限のプライバシーのために、Zero Data Retention 保証のあるプロバイダーのみにルーティングを制限：

```json theme={null}
{
  "model": "openai/gpt-5.4",
  "messages": [{ "role": "user", "content": "Hello" }],
  "provider": {
    "zdr": true
  }
}
```

ZDR プロバイダーはリクエストデータをログ記録、保存、またはトレーニングに使用しません。詳細は[データ収集](/jp/guides/privacy/data-collection)を参照してください。

***

## 最大価格

トークンあたりの支払い上限を設定します。価格要件を満たすプロバイダーがない場合、リクエストは高価なプロバイダーにルーティングされる代わりに失敗します：

```json theme={null}
{
  "model": "openai/gpt-5.4",
  "messages": [{ "role": "user", "content": "Hello" }],
  "provider": {
    "max_price": {
      "prompt": "0.000010",
      "completion": "0.000030"
    }
  }
}
```

<Note>
  パフォーマンス閾値とは異なり、`max_price` はハード制限です。価格要件を満たすプロバイダーがない場合、リクエストはエラーを返します。
</Note>

***

## プロバイダーの健全性と可用性

ARouter はサーキットブレーカーメカニズムを使用してプロバイダーの健全性を継続的に追跡します：

| ステータス    | 動作                                    |
| -------- | ------------------------------------- |
| **正常**   | プロバイダーはリクエストを通常通り受け付けている              |
| **劣化**   | 最近の障害が検出された；異なるキーでリクエストが再試行される場合がある   |
| **利用不可** | 全てのキーがサーキットブレーク済み；ARouter は `503` を返す |

これは完全に透明です——アプリケーションはプロバイダーレベルの再試行ロジックを実装する必要はありません。

***

## モデルプレフィックスによるプロバイダーの指定

どのプロバイダーがリクエストを処理するかを制御する主な方法は `provider/model` フォーマットです：

```json theme={null}
{
  "model": "openai/gpt-5.4",
  "messages": [{ "role": "user", "content": "Hello!" }]
}
```

サポートされるフォーマットの完全なリストは[モデルルーティング](/jp/model-routing)を参照してください。

## ネイティブプロバイダープロキシ

完全な制御のために、プロバイダープロキシエンドポイント `/{provider}/{path}` を使用して、ARouter のモデルルーティング層を完全にバイパスします：

```bash theme={null}
# OpenAI に直接
curl https://api.arouter.ai/openai/v1/chat/completions \
  -H "Authorization: Bearer lr_live_xxxx" \
  -d '{"model": "gpt-5.4", "messages": [...]}'

# Anthropic に直接
curl https://api.arouter.ai/anthropic/v1/messages \
  -H "Authorization: Bearer lr_live_xxxx" \
  -d '{"model": "claude-sonnet-4.6", "messages": [...]}'
```

完全なリファレンスは[プロバイダープロキシ](/jp/guides/provider-proxy)を参照してください。

***

## サポートされるプロバイダー

| プロバイダー    | プレフィックス      | モデル例                           |
| --------- | ------------ | ------------------------------ |
| OpenAI    | `openai`     | `openai/gpt-5.4`               |
| Anthropic | `anthropic`  | `anthropic/claude-sonnet-4.6`  |
| Google    | `google`     | `google/gemini-2.5-flash`      |
| DeepSeek  | `deepseek`   | `deepseek/deepseek-v3.2`       |
| xAI       | `x-ai`       | `x-ai/grok-4.20`               |
| Mistral   | `mistralai`  | `mistralai/mistral-large-2512` |
| Meta      | `meta-llama` | `meta-llama/llama-4-maverick`  |
| Qwen      | `qwen`       | `qwen/qwen3-235b`              |
| MiniMax   | `minimax`    | `minimax/minimax-m2.7`         |
| Groq      | `groq`       | `groq/llama-3.3-70b-versatile` |
| Kimi      | `moonshotai` | `moonshotai/kimi-k2.5`         |
| Dashscope | `dashscope`  | `dashscope/qwen-max`           |

機能の完全なリストは[プロバイダー](/jp/providers)を参照してください。