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

# OpenClaw

> Verbinden Sie OpenClaw über das benutzerdefinierte Provider-Onboarding oder die Konfigurationsdatei mit FlexInference.

OpenClaw erreicht jeden OpenAI-kompatiblen Endpunkt über einen benutzerdefinierten Provider. Das Onboarding erstellt den Eintrag für Sie, und die Konfigurationsdatei speichert ihn anschließend.

OpenClaw verfügt über kein eigenes Feld für eine Deadline pro Anfrage, daher wird die Deadline auf dem Schlüssel hinterlegt. Erstellen Sie zuerst einen (siehe [Agent-Schlüssel](/de/agent-keys)).

## Einrichtung mit einem Agenten

Öffnen Sie den folgenden Block und kopieren Sie ihn in einen beliebigen Coding-Agenten. Die Aufforderung fragt niemals nach Ihrem API-Schlüssel: Der Agent konfiguriert alles andere und gibt dann die eine Exportzeile aus, die Sie selbst ausführen müssen.

<Accordion title="Agenten-Setup-Prompt kopieren">
  ```text theme={null}
  Configure OpenClaw to send its requests to FlexInference through a custom provider. Use the OpenClaw CLI, not hand-edited JSON, so every write is schema-validated.

  You will never see or handle my API key. OpenClaw will read it from the `FLEXINFERENCE_API_KEY` environment variable through a secret reference, and I export that myself. Do not ask me for the key, do not pass it on any command line, and do not read it from my environment.

  Ask whether to use my default OpenClaw profile or a separate one. A separate profile isolates config, state, gateway port, and workspace, and is the safe way to try this. Prefix every command with `--profile flex` if I choose one.

  1. Confirm which config file is active with `openclaw config file`.

  2. Tell me to export the key first, and stop until I confirm. Print this line; do not run it and do not ask for the value:

  export FLEXINFERENCE_API_KEY=<paste your key here>

  3. Write the provider entry. It carries no credential. The model row is required, because OpenClaw refuses a third-party provider that declares no `models`; step 5 replaces it with the full catalog:

  openclaw config set models.providers.flexinference --merge --strict-json '{"baseUrl":"https://api.flexinference.com/v1","api":"openai-completions","models":[{"id":"gpt-5.6-sol","name":"GPT-5.6 Sol","compat":{"supportsUsageInStreaming":true}}]}'

  4. Declare an environment secrets provider, then point the provider's apiKey at it. Both commands pass only the VARIABLE NAME, never the value:

  openclaw config set secrets.providers.default \
    --provider-source env --provider-allowlist FLEXINFERENCE_API_KEY

  openclaw config set models.providers.flexinference.apiKey \
    --ref-provider default --ref-source env --ref-id FLEXINFERENCE_API_KEY

  5. Fill the model list from the live FlexInference catalog rather than by hand:

  curl -s https://api.flexinference.com/v1/models \
    -H "Authorization: Bearer $FLEXINFERENCE_API_KEY" \
  | jq '{models:{providers:{flexinference:{models:
      [.data[] | {id, name: .id, compat: {supportsUsageInStreaming: true}}]}}}}' \
  | openclaw config patch --stdin

  Run every write with `--dry-run` first and show me the diff before applying it.

  6. Verify with `openclaw models list --provider flexinference`, then run `openclaw security audit`.

  Rules that matter, do not deviate:
  - Never pass my key as an argument to an `openclaw` command, and never write it into a config file. `openclaw onboard --custom-api-key` does both, which is why step 4 uses a reference instead.
  - Step 5 is the one place the key expands, into curl's `-H` argument, where a same-user process can read it. That is a deliberate trade for a single catalog read. Do not extend it to any other command.
  - The provider id must be `flexinference` in every command. If an earlier setup derived `custom-api-flexinference-com` from the host, tell me, and use that id consistently instead of creating a second provider.
  - `api` must be `openai-completions`. That is the only adapter FlexInference's Chat Completions surface works with here.
  - The base URL must end in `/v1`.
  - You MUST list models explicitly. OpenClaw only lets its own built-in provider ids omit `models`, and it will never call `GET /v1/models` for a provider defined in config. Model discovery is a plugin capability and does not apply here.
  - Every model row needs `compat: { supportsUsageInStreaming: true }`. OpenClaw makes streaming usage opt-in for third-party endpoints, and without it every streamed turn reports zero tokens and no cost.
  - Leave `"mode": "merge"` alone so my existing providers survive.
  - Step 4 resolves the reference at write time, so it fails if I have not exported the variable yet. That failure is expected, not a reason to fall back to a literal key.
  - FlexInference's catalog publishes no context window or token ceiling, so generated rows carry neither. Do not invent values; leave them out unless I give you numbers.

  Report what you changed and which config file you wrote.
  ```
</Accordion>

## Einen benutzerdefinierten Provider einbinden

1. Starten Sie das geführte Setup.

```bash theme={null}
openclaw onboard
```

2. Wählen Sie die Option für den benutzerdefinierten Provider, wenn nach der Authentifizierung gefragt wird. Das ist `custom-api-key`.
3. Geben Sie den Router als Basis-URL ein, einschließlich des `/v1`-Suffixes.

```text theme={null}
https://api.flexinference.com/v1
```

4. Fügen Sie Ihren Agent-Schlüssel ein.
5. Lassen Sie den Kompatibilitätsmodus auf `openai`. Das ist unsere Chat Completions-Oberfläche.
6. Geben Sie eine Modell-ID ein, die wir ausführen, z. B. `gpt-5.6-sol`.

Die Aufforderung platziert Ihren Schlüssel niemals in einer Befehlszeile, weshalb dies der hier gezeigte Pfad ist.

`openclaw onboard --non-interactive` existiert ebenfalls, aber sein `custom-api-key`-Authentifizierungsmodus liest die Anmeldeinformationen aus `--custom-api-key`, sodass das Geheimnis in Ihrer Shell-Historie und in den Prozessargumenten landet. Skripten Sie das Setup stattdessen mit Konfigurationsbefehlen und einer Geheimnisreferenz, was zum gleichen Ergebnis ohne die Offenlegung führt.

Welchen Weg Sie auch wählen, legen Sie die Provider-ID selbst fest:

```bash theme={null}
openclaw config set models.providers.flexinference --merge --strict-json \
  '{"baseUrl":"https://api.flexinference.com/v1","api":"openai-completions","models":[{"id":"gpt-5.6-sol","name":"GPT-5.6 Sol","compat":{"supportsUsageInStreaming":true}}]}'
```

OpenClaw leitet die ID von sich aus vom Host ab und landet bei `custom-api-flexinference-com`, und jeder spätere Befehl auf dieser Seite müsste stattdessen diesen Namen verwenden.

Der Schreibvorgang enthält eine Modellzeile, weil dies erforderlich ist. OpenClaw lehnt einen Drittanbieter ab, der keine `models` deklariert, daher schlägt ein `baseUrl`-only-Schreibvorgang die Schema-Validierung fehl. Ersetzen Sie die gesamte Zeile im nächsten Abschnitt.

Der Kompatibilitätsmodus wird auf `api` abgebildet. `openai` schreibt `openai-completions`, was der einzige Adapter ist, mit dem unser Chat Completions-Endpunkt hier funktioniert. Die anderen Optionen sind `openai-responses` und `anthropic`.

## Die Konfigurationsdatei

Das Onboarding schreibt in `~/.openclaw/openclaw.json` unter `models.providers`. Geben Sie den Pfad aus, den OpenClaw mit `openclaw config file` verwendet.

```json theme={null}
{
  "models": {
    "mode": "merge",
    "providers": {
      "flexinference": {
        "baseUrl": "https://api.flexinference.com/v1",
        "api": "openai-completions",
        "apiKey": {
          "source": "env",
          "provider": "default",
          "id": "FLEXINFERENCE_API_KEY"
        },
        "models": [
          {
            "id": "gpt-5.6-sol",
            "name": "GPT-5.6 Sol",
            "contextWindow": 400000,
            "maxTokens": 128000,
            "input": ["text", "image"],
            "compat": { "supportsUsageInStreaming": true }
          }
        ]
      }
    }
  }
}
```

`"mode": "merge"` behält Ihre integrierten Provider bei und fügt diesen daneben hinzu.

`api` muss `openai-completions` sein. Der Onboarding-Kompatibilitätsmodus `openai` schreibt genau das.

`apiKey` akzeptiert auch einen einfachen String, was das Onboarding schreibt. Die hier gezeigte Referenz hält das Geheimnis aus der Datei heraus. Siehe Schlüssel aus der Konfigurationsdatei heraushalten.

**Listen Sie Ihre Modelle selbst auf.** Nur OpenClaws integrierte Provider-IDs dürfen `models` weglassen. Eine Drittanbieter-ID muss sowohl `baseUrl` als auch `models` deklarieren, fügen Sie also eine Zeile pro Modell hinzu, das Sie in der Auswahl haben möchten.

**Setzen Sie `compat.supportsUsageInStreaming`.** OpenClaw macht die Streaming-Nutzung für einen Drittanbieter-Endpunkt optional, da einige Server dies ablehnen. Ohne dieses Flag erhalten wir nie die Anfrage für einen Nutzungs-Frame, sodass jede gestreamte Runde null Tokens und keine Kosten meldet.

## Modellliste aus unserem Katalog füllen

OpenClaw ruft `GET /v1/models` für einen Provider, den Sie in der Konfiguration definieren, nicht auf. Die Modell-Erkennung ist eine Plugin-Funktion, und die gebündelten Plugins, die diese Funktion haben, sind die einzigen, die sie nutzen. Ein in der Konfiguration definierter Provider liest sein `models`-Array und nichts anderes.

Generieren Sie dieses Array stattdessen aus unserem Katalog und schreiben Sie es in einem einzigen Befehl.

```bash theme={null}
export FLEXINFERENCE_API_KEY=<your agent key>

curl -s https://api.flexinference.com/v1/models \
  -H "Authorization: Bearer $FLEXINFERENCE_API_KEY" \
| jq '{models:{providers:{flexinference:{models:
    [.data[] | {id, name: .id, compat: {supportsUsageInStreaming: true}}]}}}}' \
| openclaw config patch --stdin
```

`config patch` führt Objekte zusammen und ersetzt Arrays, sodass dies die Modellliste austauscht und `baseUrl` sowie `apiKey` unberührt lässt. Fügen Sie `--dry-run` hinzu, um den Schreibvorgang zuerst zu sehen.

Behalten Sie nur die Modelle, die im günstigeren Tarif enthalten sind, indem Sie nach dem eigenen Flag des Katalogs filtern.

```bash theme={null}
jq '[.data[] | select(.flexinference.flex_race) | {id, name: .id}]'
```

Unser Katalog veröffentlicht kein Kontextfenster und keine Token-Obergrenze, daher haben auf diese Weise erstellte Zeilen beides nicht. Erfinden Sie keine Werte; lassen Sie sie weg, es sei denn, Sie geben uns Zahlen.

Führen Sie den Befehl erneut aus, wenn sich unser Katalog ändert. Überprüfen Sie das Ergebnis:

```bash theme={null}
openclaw models list --provider flexinference
```

## Globale Konfiguration und Profile

OpenClaw verwaltet eine Konfiguration pro Profil, nicht eine pro Ordner. Das Arbeitsverzeichnis ändert niemals, welche Datei gelesen wird.

| Bereich     | Konfigurationspfad          | Auswahl                |
| ----------- | --------------------------- | ---------------------- |
| Standard    | `~/.openclaw/openclaw.json` | der Standard           |
| Benannt     | `~/.openclaw-<name>/`       | `--profile <name>`     |
| Entwicklung | `~/.openclaw-dev/`          | `--dev`                |
| Explizit    | beliebiger Pfad             | `OPENCLAW_CONFIG_PATH` |

Verwenden Sie ein benanntes Profil, um FlexInference auszuprobieren, ohne Ihre übliche Einrichtung zu beeinflussen.

```bash theme={null}
openclaw --profile flex onboard
```

Ein Profil isoliert sowohl den Zustand als auch die Konfiguration, sodass auch sein Gateway-Port und sein Arbeitsbereich getrennt sind.

## Schlüssel aus der Konfigurationsdatei heraushalten

Das Onboarding schreibt den Schlüssel im Klartext in `openclaw.json`. Setzen Sie `apiKey` stattdessen auf eine Geheimnisreferenz, und die Konfiguration speichert den Namen der Variable anstelle ihres Wertes.

1. Exportieren Sie den Schlüssel in der Shell, aus der Sie diese Befehle ausführen werden.

```bash theme={null}
export FLEXINFERENCE_API_KEY=<your agent key>
```

2. Deklarieren Sie einen Umgebungsvariablen-Geheimnis-Provider und erlauben Sie diese eine Variable.

```bash theme={null}
openclaw config set secrets.providers.default \
  --provider-source env --provider-allowlist FLEXINFERENCE_API_KEY
```

3. Verweisen Sie den `apiKey` des Providers darauf.

```bash theme={null}
openclaw config set models.providers.flexinference.apiKey \
  --ref-provider default --ref-source env --ref-id FLEXINFERENCE_API_KEY
```

Die Konfiguration enthält dann `{"source": "env", "provider": "default", "id": "FLEXINFERENCE_API_KEY"}` und kein Geheimnis. Der Schlüssel erreicht auch niemals eine Befehlszeile, da Schritt 3 nur den Namen der Variable übergibt.

OpenClaw löst die Referenz auf, wenn Sie Schritt 3 ausführen, exportieren Sie also zuerst die Variable. Eine fehlende oder leere Variable führt zu einem Fehler beim Schreiben mit `SecretRefResolutionError`, anstatt etwas Defektes zu speichern. Fügen Sie `--dry-run` hinzu, um dies ohne Schreiben zu überprüfen.

Überprüfen Sie mit dem integrierten Audit, was offengelegt wird.

```bash theme={null}
openclaw security audit
```

## Bestätigen, dass der Schlüssel angewendet wurde

Jede Antwort enthält `x-flexinference-defaults-applied`. OpenClaw zeigt keine Antwort-Header an, lesen Sie stattdessen die Anfrage im Dashboard unter **Logs**.

## Fehlerbehebung

**Die Modellauswahl ist kurz, oder ein Modell fehlt.** Ein in der Konfiguration definierter Provider ruft `GET /v1/models` niemals auf, daher zeigt er nur die von Ihnen geschriebenen Zeilen an. Generieren Sie die Liste aus unserem Katalog neu.

**Runden melden null Tokens und keine Kosten.** OpenClaw hat uns nicht nach Streaming-Nutzung gefragt, daher haben wir keinen Nutzungs-Frame gesendet. Setzen Sie `compat.supportsUsageInStreaming` auf `true` für jede Modellzeile.

**Eine Modell-ID wird abgelehnt.** Von Hand geschriebene Zeilen können von dem abweichen, was wir ausführen, da die `id` genau wie geschrieben ausgegeben wird. Generieren Sie die Liste aus unserem Katalog neu, anstatt IDs zu bearbeiten.

**Konfigurationsänderungen werden nicht wirksam.** Das Gateway hält die alte Konfiguration. Starten Sie es neu und vergewissern Sie sich, dass Sie die Datei bearbeitet haben, die `openclaw config file` ausgibt.

Siehe [Fehler](/de/errors) für jede Ablehnung, die wir zurückgeben, und [Agent-Schlüssel](/de/agent-keys) für diejenigen, die nicht spezifisch für OpenClaw sind.