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

# Routing Options

> Optimize for cost, latency, or throughput

Auriko selects a provider for each request based on your routing configuration. Pass routing options in the `gateway.routing` object to control strategy, constraints, and provider filtering.

## Prerequisites

* An [Auriko API key](https://auriko.ai/signup?redirectTo=%2Fdashboard%3Ftab%3Dapi-keys)
* Python 3.10+ with the OpenAI SDK (`pip install openai`) or the auriko SDK (`pip install auriko`)
  * OR Node.js 18+ with the OpenAI SDK (`npm install openai`) or `@auriko/sdk` (`npm install @auriko/sdk`)

## Compare strategies

Auriko supports seven optimization strategies:

| Strategy               | Description                               | Best For                                         |
| ---------------------- | ----------------------------------------- | ------------------------------------------------ |
| `cost`                 | Cost-optimized, well-rounded              | Cost-conscious production, budget-sensitive apps |
| `cost-focus` (default) | Aggressively minimize cost                | Maximum cost savings, no latency requirements    |
| `ttft`                 | TTFT-optimized, well-rounded              | Streaming UX, interactive apps                   |
| `ttft-focus`           | Aggressively minimize time to first token | Real-time applications, chatbots                 |
| `tps`                  | Throughput-optimized, well-rounded        | High-volume processing                           |
| `tps-focus`            | Aggressively maximize tokens per second   | Maximum throughput, pipeline processing          |
| `balanced`             | All dimensions weighted evenly            | General-purpose, mixed workloads                 |

### Base vs. focus

Base strategies (`cost`, `ttft`, `tps`) optimize for the named dimension while still considering other quality factors.

Focus strategies (`cost-focus`, `ttft-focus`, `tps-focus`) optimize almost entirely for the named dimension. Other factors have minimal influence.

| Type                                            | Behavior                                   | Use when                                                            |
| ----------------------------------------------- | ------------------------------------------ | ------------------------------------------------------------------- |
| Base (`cost`, `ttft`, `tps`)                    | Favors the named dimension, well-rounded   | Production workloads needing reliable performance                   |
| Focus (`cost-focus`, `ttft-focus`, `tps-focus`) | Aggressively optimizes the named dimension | Batch processing, real-time streaming UI, high-throughput pipelines |

For custom weight configurations beyond the preset strategies, see [Set custom weights](/guides/advanced-routing#set-custom-weights).

## Optimize for cost

Auriko computes the expected cost of each request at every available provider and routes to the cheapest one. The cost model accounts for caching and pricing tiers.

See [Cost optimization](/guides/cost-optimization) for configuration, code examples, and the full cost model.

## Optimize for latency

Route requests to low-latency providers:

<CodeGroup>
  ```python Python OpenAI theme={null}
  import os
  from openai import OpenAI

  client = OpenAI(
      api_key=os.environ["AURIKO_API_KEY"],
      base_url="https://api.auriko.ai/v1"
  )

  response = client.chat.completions.create(
      model="gpt-4o",
      messages=[{"role": "user", "content": "Quick answer: 2+2?"}],
      extra_body={"gateway": {"routing": {"optimize": "ttft-focus"}}}
  )
  ```

  ```typescript TypeScript OpenAI theme={null}
  import OpenAI from "openai";

  const client = new OpenAI({
      apiKey: process.env.AURIKO_API_KEY,
      baseURL: "https://api.auriko.ai/v1",
  });

  const response = await client.chat.completions.create({
      model: "gpt-4o",
      messages: [{ role: "user", content: "Quick answer: 2+2?" }],
      gateway: { routing: { optimize: "ttft-focus" } },
  });

  console.log(response.choices[0].message.content);
  ```

  ```python Python Auriko theme={null}
  response = client.chat.completions.create(
      model="gpt-4o",
      messages=[{"role": "user", "content": "Quick answer: 2+2?"}],
      gateway={
          "routing": {
              "optimize": "ttft-focus",
          },
      }
  )

  print(f"Provider: {response.routing_metadata.provider}")
  ```

  ```typescript TypeScript Auriko theme={null}
  const response = await client.chat.completions.create({
      model: "gpt-4o",
      messages: [{ role: "user", content: "Quick answer: 2+2?" }],
      gateway: {
          routing: {
              optimize: "ttft-focus",
          },
      },
  });

  console.log(`Provider: ${response.routing_metadata?.provider}`);
  ```

  ```bash cURL theme={null}
  curl https://api.auriko.ai/v1/chat/completions \
    -H "Authorization: Bearer $AURIKO_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "gpt-4o",
      "messages": [{"role": "user", "content": "Quick answer: 2+2?"}],
      "gateway": {"routing": {"optimize": "ttft-focus"}}
    }'
  ```
</CodeGroup>

## Set latency constraints

Set maximum time-to-first-token (TTFT):

<CodeGroup>
  ```python Python OpenAI theme={null}
  import os
  from openai import OpenAI

  client = OpenAI(
      api_key=os.environ["AURIKO_API_KEY"],
      base_url="https://api.auriko.ai/v1"
  )

  response = client.chat.completions.create(
      model="gpt-5.4",
      messages=[{"role": "user", "content": "Hello!"}],
      extra_body={"gateway": {"routing": {
          "optimize": "cost",
          "max_ttft_ms": 1000,
          "ttft_percentile": "p50",
      }}}
  )
  ```

  ```typescript TypeScript OpenAI theme={null}
  import OpenAI from "openai";

  const client = new OpenAI({
      apiKey: process.env.AURIKO_API_KEY,
      baseURL: "https://api.auriko.ai/v1",
  });

  const response = await client.chat.completions.create({
      model: "gpt-5.4",
      messages: [{ role: "user", content: "Hello!" }],
      gateway: { routing: {
          optimize: "cost",
          max_ttft_ms: 1000,
          ttft_percentile: "p50",
      } },
  });

  console.log(response.choices[0].message.content);
  ```

  ```python Python Auriko theme={null}
  response = client.chat.completions.create(
      model="gpt-5.4",
      messages=[{"role": "user", "content": "Hello!"}],
      gateway={
          "routing": {
              "optimize": "cost",
              "max_ttft_ms": 1000,  # Must start responding within 1s
              "ttft_percentile": "p50",
          },
      }
  )
  ```

  ```typescript TypeScript Auriko theme={null}
  const response = await client.chat.completions.create({
      model: "gpt-5.4",
      messages: [{ role: "user", content: "Hello!" }],
      gateway: {
          routing: {
              optimize: "cost",
              max_ttft_ms: 1000, // Must start responding within 1s
              ttft_percentile: "p50",
          },
      },
  });
  ```

  ```bash cURL theme={null}
  curl https://api.auriko.ai/v1/chat/completions \
    -H "Authorization: Bearer $AURIKO_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "gpt-5.4",
      "messages": [{"role": "user", "content": "Hello!"}],
      "gateway": {"routing": {"optimize": "cost", "max_ttft_ms": 1000, "ttft_percentile": "p50"}}
    }'
  ```
</CodeGroup>

If no provider can meet the latency constraint, Auriko returns a 400 error.

<Note>
  `max_ttft_ms` evaluates against median (p50) metrics by default. To constrain on worst-case latency, set `ttft_percentile` to `"p95"`. See [Choose metric percentile](/guides/advanced-routing#choose-metric-percentile).
</Note>

## Set cost ceilings

Exclude providers that exceed a per-1M-token budget:

<CodeGroup>
  ```python Python OpenAI theme={null}
  import os
  from openai import OpenAI

  client = OpenAI(
      api_key=os.environ["AURIKO_API_KEY"],
      base_url="https://api.auriko.ai/v1"
  )

  response = client.chat.completions.create(
      model="gpt-5.4",
      messages=[{"role": "user", "content": "Hello!"}],
      extra_body={"gateway": {"routing": {
          "optimize": "cost",
          "max_cost_per_1m": 10.00,
      }}}
  )
  ```

  ```typescript TypeScript OpenAI theme={null}
  import OpenAI from "openai";

  const client = new OpenAI({
      apiKey: process.env.AURIKO_API_KEY,
      baseURL: "https://api.auriko.ai/v1",
  });

  const response = await client.chat.completions.create({
      model: "gpt-5.4",
      messages: [{ role: "user", content: "Hello!" }],
      gateway: { routing: {
          optimize: "cost",
          max_cost_per_1m: 10.00,
      } },
  });

  console.log(response.choices[0].message.content);
  ```

  ```python Python Auriko theme={null}
  import os
  from auriko import Client

  client = Client(
      api_key=os.environ["AURIKO_API_KEY"],
      base_url="https://api.auriko.ai/v1"
  )

  response = client.chat.completions.create(
      model="gpt-5.4",
      messages=[{"role": "user", "content": "Hello!"}],
      gateway={
          "routing": {
              "optimize": "cost",
              "max_cost_per_1m": 10.00,  # Max $10 per 1M tokens (average of input + output)
          },
      }
  )
  ```

  ```typescript TypeScript Auriko theme={null}
  const response = await client.chat.completions.create({
      model: "gpt-5.4",
      messages: [{ role: "user", content: "Hello!" }],
      gateway: {
          routing: {
              optimize: "cost",
              max_cost_per_1m: 10.0, // Max $10 per 1M tokens (average of input + output)
          },
      },
  });
  ```

  ```bash cURL theme={null}
  curl https://api.auriko.ai/v1/chat/completions \
    -H "Authorization: Bearer $AURIKO_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "gpt-5.4",
      "messages": [{"role": "user", "content": "Hello!"}],
      "gateway": {"routing": {"optimize": "cost", "max_cost_per_1m": 10.00}}
    }'
  ```
</CodeGroup>

Auriko calculates cost as the average of input and output price per 1M tokens. Providers exceeding this ceiling are excluded from routing.

For fine-grained constraints, see [Advanced routing](/guides/advanced-routing) and [Cost optimization](/guides/cost-optimization#set-cost-ceilings).

## Require supported parameters

Set `require_parameters` to `true` to only route to providers that accept all optional parameters you sent (like `seed`, `logit_bias`, or `top_logprobs`). Without this flag, Auriko drops unsupported parameters and adds a warning to the response.

<CodeGroup>
  ```python Python OpenAI theme={null}
  import os
  from openai import OpenAI

  client = OpenAI(
      api_key=os.environ["AURIKO_API_KEY"],
      base_url="https://api.auriko.ai/v1"
  )

  response = client.chat.completions.create(
      model="gpt-4o",
      messages=[{"role": "user", "content": "Hello!"}],
      seed=42,
      extra_body={"gateway": {"routing": {
          "optimize": "cost",
          "require_parameters": True,
      }}}
  )
  ```

  ```typescript TypeScript OpenAI theme={null}
  import OpenAI from "openai";

  const client = new OpenAI({
      apiKey: process.env.AURIKO_API_KEY,
      baseURL: "https://api.auriko.ai/v1",
  });

  const response = await client.chat.completions.create({
      model: "gpt-4o",
      messages: [{ role: "user", content: "Hello!" }],
      seed: 42,
      gateway: { routing: {
          optimize: "cost",
          require_parameters: true,
      } },
  });

  console.log(response.choices[0].message.content);
  ```

  ```python Python Auriko theme={null}
  response = client.chat.completions.create(
      model="gpt-4o",
      messages=[{"role": "user", "content": "Hello!"}],
      seed=42,
      gateway={
          "routing": {
              "optimize": "cost",
              "require_parameters": True,
          },
      }
  )
  ```

  ```typescript TypeScript Auriko theme={null}
  const response = await client.chat.completions.create({
      model: "gpt-4o",
      messages: [{ role: "user", content: "Hello!" }],
      seed: 42,
      gateway: {
          routing: {
              optimize: "cost",
              require_parameters: true,
          },
      },
  });
  ```

  ```bash cURL theme={null}
  curl https://api.auriko.ai/v1/chat/completions \
    -H "Authorization: Bearer $AURIKO_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "gpt-4o",
      "messages": [{"role": "user", "content": "Hello!"}],
      "seed": 42,
      "gateway": {"routing": {"optimize": "cost", "require_parameters": true}}
    }'
  ```
</CodeGroup>

If no provider supports the parameters you sent, Auriko returns a 400 error with code `required_params_not_supported`. See [Filter by parameter support](/guides/advanced-routing#filter-by-parameter-support) for the full list of parameters this applies to.

## Prefer or exclude providers

Prefer or exclude specific providers:

<CodeGroup>
  ```python Python OpenAI theme={null}
  import os
  from openai import OpenAI

  client = OpenAI(
      api_key=os.environ["AURIKO_API_KEY"],
      base_url="https://api.auriko.ai/v1"
  )

  # Only consider these providers
  response = client.chat.completions.create(
      model="gpt-4o",
      messages=[{"role": "user", "content": "Hello!"}],
      extra_body={"gateway": {"routing": {"providers": ["openai", "anthropic"]}}}
  )

  # Exclude providers
  response = client.chat.completions.create(
      model="gpt-5.4",
      messages=[{"role": "user", "content": "Hello!"}],
      extra_body={"gateway": {"routing": {"exclude_providers": ["deepseek"]}}}
  )
  ```

  ```typescript TypeScript OpenAI theme={null}
  import OpenAI from "openai";

  const client = new OpenAI({
      apiKey: process.env.AURIKO_API_KEY,
      baseURL: "https://api.auriko.ai/v1",
  });

  // Only consider these providers
  const response = await client.chat.completions.create({
      model: "gpt-4o",
      messages: [{ role: "user", content: "Hello!" }],
      gateway: { routing: { providers: ["openai", "anthropic"] } },
  });

  // Exclude providers
  const response2 = await client.chat.completions.create({
      model: "gpt-5.4",
      messages: [{ role: "user", content: "Hello!" }],
      gateway: { routing: { exclude_providers: ["deepseek"] } },
  });

  console.log(response.choices[0].message.content);
  ```

  ```python Python Auriko theme={null}
  # Only consider these providers
  response = client.chat.completions.create(
      model="gpt-4o",
      messages=[{"role": "user", "content": "Hello!"}],
      gateway={
          "routing": {
              "providers": ["openai", "anthropic"],
          },
      }
  )

  # Exclude providers
  response = client.chat.completions.create(
      model="gpt-5.4",
      messages=[{"role": "user", "content": "Hello!"}],
      gateway={
          "routing": {
              "exclude_providers": ["deepseek"],
          },
      }
  )
  ```

  ```typescript TypeScript Auriko theme={null}
  // Only consider these providers
  const response = await client.chat.completions.create({
      model: "gpt-4o",
      messages: [{ role: "user", content: "Hello!" }],
      gateway: {
          routing: {
              providers: ["openai", "anthropic"],
          },
      },
  });

  // Exclude providers
  const response2 = await client.chat.completions.create({
      model: "gpt-5.4",
      messages: [{ role: "user", content: "Hello!" }],
      gateway: {
          routing: {
              exclude_providers: ["deepseek"],
          },
      },
  });
  ```

  ```bash cURL theme={null}
  # Only consider these providers
  curl https://api.auriko.ai/v1/chat/completions \
    -H "Authorization: Bearer $AURIKO_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "gpt-4o",
      "messages": [{"role": "user", "content": "Hello!"}],
      "gateway": {"routing": {"providers": ["openai", "anthropic"]}}
    }'

  # Exclude providers
  curl https://api.auriko.ai/v1/chat/completions \
    -H "Authorization: Bearer $AURIKO_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "gpt-5.4",
      "messages": [{"role": "user", "content": "Hello!"}],
      "gateway": {"routing": {"exclude_providers": ["deepseek"]}}
    }'
  ```
</CodeGroup>

You can hint at a preferred provider without restricting the candidate pool:

<CodeGroup>
  ```python Python OpenAI theme={null}
  response = client.chat.completions.create(
      model="gpt-4o",
      messages=[{"role": "user", "content": "Hello!"}],
      extra_body={"gateway": {"routing": {"prefer": "openai"}}}
  )
  ```

  ```typescript TypeScript OpenAI theme={null}
  const response = await client.chat.completions.create({
      model: "gpt-4o",
      messages: [{ role: "user", content: "Hello!" }],
      gateway: { routing: { prefer: "openai" } },
  });

  console.log(response.choices[0].message.content);
  ```

  ```python Python Auriko theme={null}
  response = client.chat.completions.create(
      model="gpt-4o",
      messages=[{"role": "user", "content": "Hello!"}],
      gateway={
          "routing": {
              "prefer": "openai",
          },
      }
  )
  ```

  ```typescript TypeScript Auriko theme={null}
  const response = await client.chat.completions.create({
      model: "gpt-4o",
      messages: [{ role: "user", content: "Hello!" }],
      gateway: {
          routing: {
              prefer: "openai",
          },
      },
  });
  ```

  ```bash cURL theme={null}
  curl https://api.auriko.ai/v1/chat/completions \
    -H "Authorization: Bearer $AURIKO_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "gpt-4o",
      "messages": [{"role": "user", "content": "Hello!"}],
      "gateway": {"routing": {"prefer": "openai"}}
    }'
  ```
</CodeGroup>

<Note>
  `prefer` is a soft hint. If the preferred provider is available, Auriko routes to it. If not, routing proceeds normally. Unlike `providers`, a `prefer` miss doesn't fail the request.
</Note>

## Restrict key source

Force requests to use only BYOK (bring-your-own-key) or only platform-managed keys:

<CodeGroup>
  ```python Python OpenAI theme={null}
  import os
  from openai import OpenAI

  client = OpenAI(
      api_key=os.environ["AURIKO_API_KEY"],
      base_url="https://api.auriko.ai/v1"
  )

  # Use only your own provider keys
  response = client.chat.completions.create(
      model="gpt-5.4",
      messages=[{"role": "user", "content": "Hello!"}],
      extra_body={"gateway": {"routing": {"only_byok": True}}}
  )

  # Use only Auriko platform keys
  response = client.chat.completions.create(
      model="gpt-5.4",
      messages=[{"role": "user", "content": "Hello!"}],
      extra_body={"gateway": {"routing": {"only_platform": True}}}
  )
  ```

  ```typescript TypeScript OpenAI theme={null}
  import OpenAI from "openai";

  const client = new OpenAI({
      apiKey: process.env.AURIKO_API_KEY,
      baseURL: "https://api.auriko.ai/v1",
  });

  // Use only your own provider keys
  const response = await client.chat.completions.create({
      model: "gpt-5.4",
      messages: [{ role: "user", content: "Hello!" }],
      gateway: { routing: { only_byok: true } },
  });

  // Use only Auriko platform keys
  const response2 = await client.chat.completions.create({
      model: "gpt-5.4",
      messages: [{ role: "user", content: "Hello!" }],
      gateway: { routing: { only_platform: true } },
  });

  console.log(response.choices[0].message.content);
  ```

  ```python Python Auriko theme={null}
  import os
  from auriko import Client

  client = Client(
      api_key=os.environ["AURIKO_API_KEY"],
      base_url="https://api.auriko.ai/v1"
  )

  # Use only your own provider keys
  response = client.chat.completions.create(
      model="gpt-5.4",
      messages=[{"role": "user", "content": "Hello!"}],
      gateway={
          "routing": {
              "only_byok": True,
          },
      }
  )

  # Use only Auriko platform keys
  response = client.chat.completions.create(
      model="gpt-5.4",
      messages=[{"role": "user", "content": "Hello!"}],
      gateway={
          "routing": {
              "only_platform": True,
          },
      }
  )
  ```

  ```typescript TypeScript Auriko theme={null}
  // Use only your own provider keys
  const response = await client.chat.completions.create({
      model: "gpt-5.4",
      messages: [{ role: "user", content: "Hello!" }],
      gateway: {
          routing: {
              only_byok: true,
          },
      },
  });

  // Use only Auriko platform keys
  const response2 = await client.chat.completions.create({
      model: "gpt-5.4",
      messages: [{ role: "user", content: "Hello!" }],
      gateway: {
          routing: {
              only_platform: true,
          },
      },
  });
  ```

  ```bash cURL theme={null}
  # Use only your own provider keys
  curl https://api.auriko.ai/v1/chat/completions \
    -H "Authorization: Bearer $AURIKO_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "gpt-5.4",
      "messages": [{"role": "user", "content": "Hello!"}],
      "gateway": {"routing": {"only_byok": true}}
    }'

  # Use only Auriko platform keys
  curl https://api.auriko.ai/v1/chat/completions \
    -H "Authorization: Bearer $AURIKO_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "gpt-5.4",
      "messages": [{"role": "user", "content": "Hello!"}],
      "gateway": {"routing": {"only_platform": true}}
    }'
  ```
</CodeGroup>

Both are booleans, default `false`. Setting both to `true` returns a 400 error. They're mutually exclusive.

When no key of the requested type is available, the request fails with no fallback. See [Bring Your Own Key](/platform/byok) for BYOK setup.

## Opt in to premium tiers

Premium-tier offerings are excluded from routing by default to prevent accidental cost escalation. Set `tier` to opt in.

| Value             | Effect                                                       |
| ----------------- | ------------------------------------------------------------ |
| `"priority"`      | Includes Anthropic Fast Mode offerings (2.5x speed, 6x cost) |
| omitted (default) | Excludes premium-tier offerings                              |

<CodeGroup>
  ```python Python OpenAI theme={null}
  import os
  from openai import OpenAI

  client = OpenAI(
      api_key=os.environ["AURIKO_API_KEY"],
      base_url="https://api.auriko.ai/v1"
  )

  response = client.chat.completions.create(
      model="claude-opus-4-6",
      messages=[{"role": "user", "content": "Hello!"}],
      extra_body={"gateway": {"routing": {"tier": "priority"}}}
  )
  ```

  ```typescript TypeScript OpenAI theme={null}
  const response = await client.chat.completions.create({
      model: "claude-opus-4-6",
      messages: [{ role: "user", content: "Hello!" }],
      gateway: { routing: { tier: "priority" } },
  });

  console.log(response.choices[0].message.content);
  ```

  ```python Python Auriko theme={null}
  response = client.chat.completions.create(
      model="claude-opus-4-6",
      messages=[{"role": "user", "content": "Hello!"}],
      gateway={
          "routing": {
              "tier": "priority",
          },
      }
  )
  ```

  ```typescript TypeScript Auriko theme={null}
  const response = await client.chat.completions.create({
      model: "claude-opus-4-6",
      messages: [{ role: "user", content: "Hello!" }],
      gateway: {
          routing: {
              tier: "priority",
          },
      },
  });
  ```

  ```bash cURL theme={null}
  curl https://api.auriko.ai/v1/chat/completions \
    -H "Authorization: Bearer $AURIKO_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "claude-opus-4-6",
      "messages": [{"role": "user", "content": "Hello!"}],
      "gateway": {"routing": {"tier": "priority"}}
    }'
  ```
</CodeGroup>

<Note>
  Auriko's "priority" tier refers to Anthropic Fast Mode, not Anthropic's separate Priority Tier (committed capacity SLA).
</Note>

Without `tier`, requests to models available only under a premium tier return [`tier_opt_in_required`](/errors/tier_opt_in_required).

## Read routing metadata

Every response carries routing information:

<CodeGroup>
  ```python Python Auriko theme={null}
  response = client.chat.completions.create(
      model="gpt-4o",
      messages=[{"role": "user", "content": "Hello!"}]
  )

  metadata = response.routing_metadata
  print(f"Provider: {metadata.provider}")
  print(f"Model: {metadata.provider_model_id}")
  print(f"Strategy: {metadata.routing_strategy}")
  print(f"Cost: ${metadata.cost.usd:.6f}")
  ```

  ```typescript TypeScript Auriko theme={null}
  const response = await client.chat.completions.create({
      model: "gpt-4o",
      messages: [{ role: "user", content: "Hello!" }],
  });

  const metadata = response.routing_metadata;
  console.log(`Provider: ${metadata?.provider}`);
  console.log(`Model: ${metadata?.provider_model_id}`);
  console.log(`Strategy: ${metadata?.routing_strategy}`);
  console.log(`Cost: $${metadata?.cost?.usd}`);
  ```
</CodeGroup>

For routing metadata with the OpenAI SDK, see [OpenAI Compatibility](/openai-compatibility#access-routing-metadata).

For the complete field reference including fallback chain, warnings, and all optional fields, see [Response Extensions](/api-reference/overview#response-extensions).

## Combine routing options

<CodeGroup>
  ```python Python OpenAI theme={null}
  import os
  from openai import OpenAI

  client = OpenAI(
      api_key=os.environ["AURIKO_API_KEY"],
      base_url="https://api.auriko.ai/v1"
  )

  response = client.chat.completions.create(
      model="gpt-5.4",
      messages=[
          {"role": "system", "content": "You are a helpful assistant."},
          {"role": "user", "content": "What's the capital of France?"}
      ],
      extra_body={"gateway": {"routing": {
          "optimize": "ttft-focus",
          "max_ttft_ms": 1000,
      }}}
  )

  print(response.choices[0].message.content)
  ```

  ```typescript TypeScript OpenAI theme={null}
  import OpenAI from "openai";

  const client = new OpenAI({
      apiKey: process.env.AURIKO_API_KEY,
      baseURL: "https://api.auriko.ai/v1",
  });

  const response = await client.chat.completions.create({
      model: "gpt-5.4",
      messages: [
          { role: "system", content: "You are a helpful assistant." },
          { role: "user", content: "What's the capital of France?" },
      ],
      gateway: { routing: {
          optimize: "ttft-focus",
          max_ttft_ms: 1000,
      } },
  });

  console.log(response.choices[0].message.content);
  ```

  ```python Python Auriko theme={null}
  import os
  from auriko import Client

  client = Client(
      api_key=os.environ["AURIKO_API_KEY"],
      base_url="https://api.auriko.ai/v1"
  )

  # For a chatbot: optimize TTFT with cost ceiling
  response = client.chat.completions.create(
      model="gpt-5.4",
      messages=[
          {"role": "system", "content": "You are a helpful assistant."},
          {"role": "user", "content": "What's the capital of France?"}
      ],
      gateway={
          "routing": {
              "optimize": "ttft-focus",
              "max_ttft_ms": 1000,
          },
      }
  )

  print(response.choices[0].message.content)
  print(f"\n--- Routing Info ---")
  print(f"Provider: {response.routing_metadata.provider}")
  print(f"Strategy: {response.routing_metadata.routing_strategy}")
  print(f"Cost: ${response.routing_metadata.cost.usd:.6f}")
  ```

  ```typescript TypeScript Auriko theme={null}
  import { Client } from "@auriko/sdk";

  const client = new Client({
      apiKey: process.env.AURIKO_API_KEY,
      baseUrl: "https://api.auriko.ai/v1",
  });

  const response = await client.chat.completions.create({
      model: "gpt-5.4",
      messages: [
          { role: "system", content: "You are a helpful assistant." },
          { role: "user", content: "What's the capital of France?" },
      ],
      gateway: {
          routing: {
              optimize: "ttft-focus",
              max_ttft_ms: 1000,
          },
      },
  });

  console.log(response.choices[0].message.content);
  console.log(`\n--- Routing Info ---`);
  console.log(`Provider: ${response.routing_metadata?.provider}`);
  console.log(`Strategy: ${response.routing_metadata?.routing_strategy}`);
  console.log(`Cost: $${response.routing_metadata?.cost?.usd}`);
  ```

  ```bash cURL theme={null}
  curl https://api.auriko.ai/v1/chat/completions \
    -H "Authorization: Bearer $AURIKO_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "gpt-5.4",
      "messages": [
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What'\''s the capital of France?"}
      ],
      "gateway": {"routing": {"optimize": "ttft-focus", "max_ttft_ms": 1000}}
    }'
  ```
</CodeGroup>