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

# Anbieter nach Preis, Latenz oder Durchsatz sortieren

> Nutze die anfragebezogene Anbietersortierung, um für ein Modell die günstigste, schnellste oder leistungsstärkste Route zu bevorzugen.

Nutze dieses Rezept, wenn das Modell gleich bleibt, das Gateway die Anbieterangebote für eine Anfrage aber anders sortieren soll.

## Ziel

* Den günstigsten Anbieter für eine Anfrage bevorzugen.
* Für interaktive Abläufe den Anbieter mit der niedrigsten Latenz bevorzugen.
* Für die Massengenerierung den Anbieter mit dem höchsten Durchsatz bevorzugen.

## 1. `provider.sort` zur Anfrage hinzufügen

Lege bei Textanfragen die gewünschte Sortierung direkt im Objekt `provider` fest.

<CodeGroup>
  ```bash cURL theme={null}
  curl https://api.phaseo.app/v1/responses \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "google/gemini-3.1-flash-lite",
      "input": "Give me one release-note bullet for the last deploy.",
      "provider": {
        "sort": "price"
      }
    }'
  ```

  ```typescript TypeScript SDK theme={null}
  import Phaseo from "@phaseo/sdk";

  const client = new Phaseo({ apiKey: process.env.PHASEO_API_KEY! });

  const response = await client.generateResponse({
    model: "google/gemini-3.1-flash-lite",
    input: "Give me one release-note bullet for the last deploy.",
    provider: {
      sort: "price",
    },
  });

  console.log(response.output_text);
  ```

  ```python Python SDK theme={null}
  from phaseo import Phaseo

  client = Phaseo(api_key="YOUR_API_KEY")

  response = client.generate_response(
      {
          "model": "google/gemini-3.1-flash-lite",
          "input": "Give me one release-note bullet for the last deploy.",
          "provider": {
              "sort": "price",
          },
      }
  )

  print(response.get("output_text"))
  ```

  ```go Go SDK theme={null}
  package main

  import (
    "context"
    "fmt"

    phaseo "github.com/phaseoteam/Phaseo/packages/sdk/sdk-go/v3"
  )

  func main() {
    client := phaseo.New("YOUR_API_KEY", "https://api.phaseo.app/v1")

    response, err := client.GenerateResponse(context.Background(), phaseo.ResponsesRequest{
      Model: "google/gemini-3.1-flash-lite",
      Input: "Give me one release-note bullet for the last deploy.",
      Provider: map[string]interface{}{
        "sort": "price",
      },
    })
    if err != nil {
      panic(err)
    }

    fmt.Println(response)
  }
  ```

  ```csharp C# SDK theme={null}
  using PhaseoSdk;
  using System.Collections.Generic;

  var client = new Phaseo("YOUR_API_KEY");

  var response = await client.GenerateResponse(new Dictionary<string, object>
  {
      ["model"] = "google/gemini-3.1-flash-lite",
      ["input"] = "Give me one release-note bullet for the last deploy.",
      ["provider"] = new Dictionary<string, object>
      {
          ["sort"] = "price"
      }
  });

  Console.WriteLine(response);
  ```

  ```php PHP SDK theme={null}
  <?php
  require 'vendor/autoload.php';

  use Phaseo\Sdk\Phaseo;

  $client = new Phaseo(getenv('PHASEO_API_KEY') ?: 'YOUR_API_KEY');

  $response = $client->generateResponse([
      'model' => 'google/gemini-3.1-flash-lite',
      'input' => 'Give me one release-note bullet for the last deploy.',
      'provider' => [
          'sort' => 'price',
      ],
  ]);

  print_r($response);
  ```

  ```ruby Ruby SDK theme={null}
  require 'phaseo_sdk'

  client = PhaseoSdk::Phaseo.new(api_key: ENV.fetch('PHASEO_API_KEY', 'YOUR_API_KEY'))

  response = client.generate_response(
    model: 'google/gemini-3.1-flash-lite',
    input: 'Give me one release-note bullet for the last deploy.',
    provider: {
      sort: 'price'
    }
  )

  puts response
  ```
</CodeGroup>

Für diesen Ablauf werden folgende Routing-Sortierungen unterstützt:

* `price`
* `latency`
* `throughput`

## 2. Die passende Sortierung für die Workload wählen

Verwende:

* `price`, wenn Kosten wichtiger als die Latenz am Verteilungsende sind
* `latency` für Chat, Copilots und Tools mit menschlicher Beteiligung
* `throughput` für umfangreiche Generierung oder Backfills

## 3. Verstehen, was das Gateway vergleicht

Bei einer expliziten anfragebezogenen Sortierung ordnet das Gateway die Kandidaten deterministisch, statt die übliche ausgewogene, gewichtete Zufallsauswahl zu verwenden.

Bei Textmodellen:

* `price` vergleicht eine gemeinsame Preisgrundlage der geeigneten Anbieter
* wenn gemeinsame Textzähler vorhanden sind, bevorzugt das Gateway übereinstimmende `input_text_tokens` und `output_text_tokens`
* `latency` verwendet die neuesten Latenzdaten der Anbieter
* `throughput` verwendet die neuesten Durchsatzmessungen

## 4. Einen realistischen Anbieterkreis beibehalten

Die Sortierung funktioniert am besten, wenn du den Kandidatenkreis bei Bedarf zuvor eingrenzt.

Sortiere beispielsweise nur innerhalb einer genehmigten Anbieterauswahl:

<CodeGroup>
  ```bash cURL theme={null}
  curl https://api.phaseo.app/v1/responses \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "google/gemini-3.1-flash-lite",
      "input": "Summarize the incident in one sentence.",
      "provider": {
        "only": ["google-vertex", "google-vertex-eu"],
        "sort": "latency"
      }
    }'
  ```

  ```typescript TypeScript SDK theme={null}
  import Phaseo from "@phaseo/sdk";

  const client = new Phaseo({ apiKey: process.env.PHASEO_API_KEY! });

  const response = await client.generateResponse({
    model: "google/gemini-3.1-flash-lite",
    input: "Summarize the incident in one sentence.",
    provider: {
      only: ["google-vertex", "google-vertex-eu"],
      sort: "latency",
    },
  });

  console.log(response.output_text);
  ```

  ```python Python SDK theme={null}
  from phaseo import Phaseo

  client = Phaseo(api_key="YOUR_API_KEY")

  response = client.generate_response(
      {
          "model": "google/gemini-3.1-flash-lite",
          "input": "Summarize the incident in one sentence.",
          "provider": {
              "only": ["google-vertex", "google-vertex-eu"],
              "sort": "latency",
          },
      }
  )

  print(response.get("output_text"))
  ```

  ```go Go SDK theme={null}
  package main

  import (
    "context"
    "fmt"

    phaseo "github.com/phaseoteam/Phaseo/packages/sdk/sdk-go/v3"
  )

  func main() {
    client := phaseo.New("YOUR_API_KEY", "https://api.phaseo.app/v1")

    response, err := client.GenerateResponse(context.Background(), phaseo.ResponsesRequest{
      Model: "google/gemini-3.1-flash-lite",
      Input: "Summarize the incident in one sentence.",
      Provider: map[string]interface{}{
        "only": []string{"google-vertex", "google-vertex-eu"},
        "sort": "latency",
      },
    })
    if err != nil {
      panic(err)
    }

    fmt.Println(response)
  }
  ```

  ```csharp C# SDK theme={null}
  using PhaseoSdk;
  using System.Collections.Generic;

  var client = new Phaseo("YOUR_API_KEY");

  var response = await client.GenerateResponse(new Dictionary<string, object>
  {
      ["model"] = "google/gemini-3.1-flash-lite",
      ["input"] = "Summarize the incident in one sentence.",
      ["provider"] = new Dictionary<string, object>
      {
          ["only"] = new[] { "google-vertex", "google-vertex-eu" },
          ["sort"] = "latency"
      }
  });

  Console.WriteLine(response);
  ```

  ```php PHP SDK theme={null}
  <?php
  require 'vendor/autoload.php';

  use Phaseo\Sdk\Phaseo;

  $client = new Phaseo(getenv('PHASEO_API_KEY') ?: 'YOUR_API_KEY');

  $response = $client->generateResponse([
      'model' => 'google/gemini-3.1-flash-lite',
      'input' => 'Summarize the incident in one sentence.',
      'provider' => [
          'only' => ['google-vertex', 'google-vertex-eu'],
          'sort' => 'latency',
      ],
  ]);

  print_r($response);
  ```

  ```ruby Ruby SDK theme={null}
  require 'phaseo_sdk'

  client = PhaseoSdk::Phaseo.new(api_key: ENV.fetch('PHASEO_API_KEY', 'YOUR_API_KEY'))

  response = client.generate_response(
    model: 'google/gemini-3.1-flash-lite',
    input: 'Summarize the incident in one sentence.',
    provider: {
      only: ['google-vertex', 'google-vertex-eu'],
      sort: 'latency'
    }
  )

  puts response
  ```
</CodeGroup>

## 5. Das Ranking-Ergebnis prüfen

Prüfe beim Debugging die Anfrage unter **Gateway -> Nutzung** auf folgende Angaben:

* berücksichtigte Anbieter
* gerankte Anbieter
* die Routing-Bewertungsfaktoren für Preis, Latenz oder Durchsatz

So kannst du leicht prüfen, ob das Gateway wie erwartet sortiert hat.

## Verwandte Leitfäden

* [Routing und Fallbacks](../guides/routing-and-fallbacks.mdx)
* [Presets ausrollen und Routing debuggen](./preset-rollout-and-routing-debug.mdx)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.