# Open WebUI anbinden

> **Zuletzt geprüft**: 2026-10-13 · 📄 Laut offizieller Dokumentation (Open WebUI v0.12.0)

## Auf einen Blick

| Punkt | Details |
|---|---|
| Verwendbare Modelle | Claude ❌ **nicht verfügbar** (siehe die beiden nächsten Abschnitte) · GPT ✅ · Chinesische Modelle ✅ · Gemini ❌ (die Gemini-Familie bietet QCode nicht an — nutzen Sie stattdessen ein GPT- oder ein chinesisches Modell) |
| Protokoll & Base URL | Nur OpenAI Chat Completions: `https://api.qcode.cc/openai/v1` |
| Wo eingerichtet wird | **Settings → Admin → Connections**, in der Liste **Manage OpenAI API Connections** |
| Offizielle Dokumentation | [docs.openwebui.com](https://docs.openwebui.com/) |

🔴 **Claude ist in Open WebUI nicht verfügbar.** Open WebUI versendet ausschließlich OpenAI-Chat-Completions-Anfragen, und die Claude-Modelle bei QCode laufen nur über den Anthropic-Messages-Endpunkt ⇒ für Claude bitte ein Werkzeug mit Anthropic-Protokoll oder Claude Code verwenden. Welche Werkzeuge was können, zeigt die [Übersicht zur Werkzeugkompatibilität](/docs/ide/tool-compatibility).

Open WebUI ist eine selbst gehostete Chat-Weboberfläche, die Sie mit Docker, pip oder uv starten. Die Dokumentation steckt den Rahmen selbst ab: Open WebUI „connects to any server or provider that implements the OpenAI-compatible API“, und während Open WebUI Oberfläche und Werkzeuge übernimmt, gilt: „it expects your backend to follow the universal Chat Completions standard“. Geprüft wurde **v0.12.0**, veröffentlicht am 2026-10-10. Abgerechnet wird pro Token; die Preise je Modell stehen auf [qcode.cc/models](https://qcode.cc/models).

## Welches Protokoll

Die Dokumentation nennt mehrere Verbindungsprotokolle — Ollama, OpenAI-kompatible APIs und eine experimentelle Unterstützung von Open Responses. Diese Seite behandelt nur den Weg **OpenAI Chat Completions**, und genau den bedient der OpenAI-Endpunkt von QCode.

| Modellfamilie | In Open WebUI nutzbar | Was Sie eintragen |
|---|---|---|
| GPT — `gpt-6.1-sol`, `gpt-6-sol`, `gpt-6-astra`, `gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.5` | ✅ | URL `https://api.qcode.cc/openai/v1` |
| GLM / Kimi / DeepSeek / Qwen — `deepseek-v4.1-flash`, `deepseek-v4-flash`, `deepseek-v4-pro`, `glm-5.3`, `glm-5.2`, `qwen3.8-max`, `qwen3.8-flash`, `qwen3.7-plus`, `kimi-k3` | ✅ | dieselbe URL |
| Claude | ❌ **nicht verfügbar** — nutzen Sie ein Werkzeug mit Anthropic-Protokoll oder Claude Code | Die Claude-Modelle bei QCode werden nur über den Anthropic-Messages-Endpunkt `https://api.qcode.cc/api` angeboten; Open WebUI ruft dieses Protokoll nicht auf |
| Gemini-Familie | ❌ bietet QCode nicht an | nutzen Sie ein GPT- oder ein chinesisches Modell |

Warum die Claude-Zeile ein klares Nein ist, in den Worten des Projekts:

- Open WebUI bezeichnet sich als „a **protocol-centric** platform“ und unterstützt selbst OpenAI-Modelle „mainly through the **OpenAI Chat Completions API protocol**“. Die Grenze ist eindeutig formuliert: „We do not implement provider-specific, non-standard APIs in the core“, und die FAQ wiederholt: „We avoid implementing proprietary, provider-specific APIs in the core“.
- Die eingebaute Anthropic-Ausnahme ist eng gefasst. Die offizielle Anthropic-Seite schreibt: „Open WebUI detects Anthropic URLs (any URL containing `api.anthropic.com`)“ — und selbst für eine solche URL gilt: „Chat requests themselves are sent unchanged to Anthropic's OpenAI-compatible `/v1/chat/completions` with Bearer auth.“ Die Ausnahme spricht also ebenfalls Chat Completions und ist an genau einen Hostnamen gebunden; in der QCode-Verbindungsadresse kommt er nicht vor.
- Im Quelltext derselben Version (`backend/open_webui/config.py` am Tag `v0.12.0`) sind die Variablen für die OpenAI-Basisadresse sämtlich vorhanden, eine Suche nach `anthropic` ohne Berücksichtigung der Großschreibung liefert **null** Treffer — es gibt keine ausgehende Anthropic-Messages-Einstellung, die Sie auf ein Fremdgateway richten könnten.
- Ein Detail wird häufig missverstanden: Open WebUI stellt durchaus ein eigener Anthropic-Messages-kompatibler Endpunkt zur Verfügung, doch die Dokumentation nennt den Zweck so: „This allows tools, SDKs, and applications built for the Anthropic API to work directly against Open WebUI“ — die Richtung geht **nach innen**. Open WebUI wird dadurch kein Anthropic-Protokoll-Client gegenüber Ihrem Anbieter.
- Für APIs, die Open WebUI nicht implementiert, nennt die Dokumentation Pipe-Funktionen oder Übersetzungs-Proxys wie LiteLLM. Beides haben wir an QCode nicht geprüft, deshalb gibt es hier kein Rezept dafür. Wenn Sie Claude heute brauchen, greifen Sie zu einem Client, der das Anthropic-Protokoll spricht.

Die vollständige Matrix aus Protokollen und Modellfamilien steht unter [Endpunkte und API-Pfade](/docs/getting-started/endpoints-and-api-paths).

## Installation

Alle drei Befehle folgen wörtlich dem offiziellen Quick Start.

**Docker** — Docker ist Voraussetzung; ersetzen Sie `your-secret-key` durch die Ausgabe von `openssl rand -hex 32`:

```bash
docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data -e WEBUI_SECRET_KEY=your-secret-key --name open-webui --restart always ghcr.io/open-webui/open-webui:main
```

Wie die Portzuordnung zu lesen ist, steht in der offiziellen Parametertabelle: „The UI is on port 3000 of your machine. Change the left number if 3000 is taken.“

**pip**:

```bash
pip install open-webui
open-webui serve
```

Laut Dokumentation ist „Open WebUI is now on [http://localhost:8080](http://localhost:8080). Set `DATA_DIR` to choose where your data lives“.

**uv** (ohne globale Installation, Beispiel für macOS/Linux):

```bash
DATA_DIR=~/.open-webui uvx --python 3.11 open-webui@latest serve
```

Python-Versionen: „Open WebUI supports **Python 3.11 and 3.12**. **Python 3.13 is not supported yet**“.

## Konfiguration

### Über die Verbindungsseite der Verwaltung (empfohlen)

1. Öffnen Sie Open WebUI im Browser.
2. Wörtlich aus der Dokumentation: „Go to **Settings > Admin > Connections** and find the **Manage OpenAI API Connections** list.“
3. „Click ➕ **Add Connection**.“
4. **Connection Type** auf External lassen.
5. **URL**: `https://api.qcode.cc/openai/v1`. Die Dokumentation merkt an: „The URL field will **suggest common provider endpoints** as you type“ — diese Vorschläge sind Adressen anderer Anbieter, die QCode-Adresse geben Sie daher vollständig von Hand ein. Ob die Adresse eines Fremd-Gateways zwingend auf `/v1` enden muss, sagt die Dokumentation nicht; maßgeblich ist die Adresse, die Ihr Gateway angibt. Bei QCode ist das `https://api.qcode.cc/openai/v1`, ohne abschließenden Schrägstrich.
6. **API Key**: Ihr QCode-Schlüssel (beginnt mit `cr_`).
7. **Model IDs** (unter **Advanced**): tragen Sie jede ID, die im Modellauswahlmenü erscheinen soll, einzeln ein — die offizielle Beschreibung lautet „In the connection settings, find **Model IDs**, type the model ID, and click the **+** icon, then save.“ Nach einer erfolgreichen Verbindungsprüfung gilt: „the **Model IDs** field suggests the provider's model IDs as you type“.
   Solange das Feld leer bleibt, bleibt die automatische Erkennung aktiv („_Default (Empty)_: Auto-detects all available models from the provider.“); ist es gefüllt, ändert sich das Verhalten: „Open WebUI stops calling the provider's `/models` for that connection and lists exactly the IDs you typed“.
8. **Prefix ID** (optional): die Dokumentation empfiehlt einen Präfix, wenn „you connect multiple providers that have models with the same name“, und hält fest: „Open WebUI joins the prefix and the model ID with a dot“ — mit dem Präfix `qcode` und der ID `glm-5.3` steht in der Auswahl also `qcode.glm-5.3`.
9. **Provider** (unter **Advanced**): lassen Sie es auf **Default** — „Leaving it at **Default** is always safe.“ Die Auswahlliste existiert nur bei OpenAI-Verbindungen.
10. Klicken Sie auf **Save**. Jede gespeicherte Verbindung besitzt außerdem einen Schalter, mit dem Sie sie deaktivieren können, ohne sie zu löschen.

Welche IDs Sie wählen, steht bei [Chinesische Modelle](/docs/usage/cn-models) und [Modellauswahl](/docs/usage/model-selection); abgerechnet wird pro Token, die Preise auf [qcode.cc/models](https://qcode.cc/models).

### Umgebungsvariablen (selbst gehostete Instanzen)

Die Dokumentation behandelt beide Wege als gleichwertig: „Open WebUI is configured via environment variables, and you can also set the same values from the Open WebUI admin panel.“

```bash
# diese -e-Flags zur obigen docker-Anweisung hinzufügen oder vor `open-webui serve` exportieren
OPENAI_API_BASE_URL=https://api.qcode.cc/openai/v1
OPENAI_API_KEY=cr_your_qcode_key
```

Offiziell bedeutet das: `OPENAI_API_BASE_URL` „Configures the OpenAI base API URL“ (mitgelieferter Standardwert ist `https://api.openai.com/v1`), `OPENAI_API_KEY` „Sets the OpenAI API key“. Wer zwei Gateways in einer Instanz verteilen möchte, nutzt `OPENAI_API_BASE_URLS` mit dem Text „Supports balanced OpenAI base API URLs, semicolon-separated.“

Zwei Hinweise direkt aus derselben Referenzseite:

- Diese Variablen sind als `ConfigVar` markiert, deshalb gilt: „After the initial launch, if you restart the container, `ConfigVar` environment variables will no longer use the external environment variable values. Instead, they will use the internally stored values.“ Setzen Sie sie vor dem ersten Start — oder ändern Sie sie später in der Verwaltungsoberfläche.
- Dieselbe Seite nennt sich selbst „is up-to-date with Open WebUI release version [v0.11.1]“, geprüft wurde hier jedoch v0.12.0 — nach einem Upgrade sollten Sie die Variablennamen erneut nachschlagen.

### Chinesische Modelle

Die chinesischen Familien laufen über dieselbe OpenAI-kompatible Verbindung: `deepseek-v4.1-flash`, `deepseek-v4-flash`, `deepseek-v4-pro`, `glm-5.3`, `glm-5.2`, `qwen3.8-max`, `qwen3.8-flash`, `qwen3.7-plus`, `kimi-k3`. Nehmen Sie die gewünschten IDs in **Model IDs** auf; die Unterschiede stehen unter [Chinesische Modelle](/docs/usage/cn-models).

## Verbindung prüfen

Die Dokumentation legt die Erwartung selbst fest: „**Saving a connection does not test it.**“ Auch der Knopf neben dem URL-Feld ist dort beschrieben: „Clicking the **Verify Connection** button beside the URL field calls the provider's `/models` endpoint using a standard `Bearer` token and reports **Server connection verified**.“ Anbieter ohne diesen Endpunkt oder mit anderer Authentifizierung reagieren laut Dokumentation so: „The connection verification will **fail with an error** (e.g., 400, 401 or 403).“ — und: „This does **not** mean the provider is incompatible: **chat completions will still work**.“ Das offizielle Mittel dagegen ist das manuelle Eintragen der Modellnamen: „You just need to **manually add model names** to the **Model IDs** allowlist in the connection settings.“

In der Praxis also:

1. Tragen Sie die IDs, die Sie nutzen wollen, in **Model IDs** ein — das ist der verlässliche Weg, ganz gleich, was die Prüfungsmeldung sagt.
2. Senden Sie in der Oberfläche eine Nachricht an ein Modell aus dieser Liste; erst dieser Hin- und Rückweg ist der eigentliche Test.
3. Um die QCode-Seite von der Open-WebUI-Seite zu trennen, können Sie den Endpunkt direkt ansprechen:

```bash
curl -X POST https://api.qcode.cc/openai/v1/chat/completions \
  -H "Authorization: Bearer $QCODE_KEY" \
  -H "content-type: application/json" \
  -d '{"model":"deepseek-v4.1-flash","messages":[{"role":"user","content":"ping"}]}'
```

Wir haben in dieser Runde keinen Test-Key, deshalb steht oben nur 📄: Hier wird weder ein Statuscode noch ein Antwortinhalt behauptet. Was Ihre eigene Anfrage zurückgibt, ordnen Sie im [Handbuch zur Fehlerbehebung](/docs/reference/troubleshooting) ein.

## Bekannte Einschränkungen

| Symptom | Offizieller Wortlaut | Was zu tun ist |
|---|---|---|
| Modelliste ist leer oder unvollständig | Der Endpunkt `/models` ist zuständig für: „Used for model discovery and selecting models in the UI. If not available, add models to the allowlist manually.“ | Jede ID unter **Model IDs** eintragen |
| Das Laden der Modelliste dauert, oder eine gespeicherte unerreichbare Adresse bremst die Oberfläche | „Raise the timeout for slower connections. The default is 10 seconds, and an empty value disables it“, z. B. `AIOHTTP_CLIENT_TIMEOUT_MODEL_LIST=30` | Variable setzen oder die fehlerhafte Adresse entfernen |
| Ein Dienst auf Ihrem Rechner ist aus dem Container nicht erreichbar | „If running Open WebUI in Docker and your model server is on the host machine, replace `localhost` with `host.docker.internal` in the URL.“ | URL umschreiben |
| Verwaltete Verbindung schlägt fehl, eigene Verbindungen der Nutzer funktionieren | Die Dokumentation listet „502 Bad Gateway on admin-configured connections while user connections work fine“ und erklärt, dass bei Verwaltungs- und Globalanfragen „the Open WebUI backend resolves that hostname, and inside a Docker container, it may resolve to `127.0.0.1`“; der offizielle Rat: „For backend/admin connections, use the **internal URL** that the backend can actually reach“ | Prüfen Sie die Adresse, die das Backend auflöst — nicht die, die Ihr Browser sieht |
| Installation mit pip oder uv schlägt fehl | „Open WebUI supports **Python 3.11 and 3.12**. **Python 3.13 is not supported yet**“ | 3.11 oder 3.12 verwenden |
| Die Provider-Auswahl fehlt bei einem anderen Verbindungstyp | „The **Provider** dropdown belongs to OpenAI connections only.“ | Dort ist sie schlicht nicht vorgesehen |

Grenzen auf Seiten von QCode, die Sie vor einer Einführung kennen sollten:

- **Claude ist mit diesem Werkzeug nicht erreichbar.** QCode bietet keinen Claude-Pfad über den OpenAI-kompatiblen Endpunkt an; Claude-Anfragen gehören auf den Anthropic-Messages-Endpunkt, und den ruft Open WebUI nicht auf. Nutzen Sie für Claude ein Werkzeug mit Anthropic-Protokoll oder Claude Code — siehe [Übersicht zur Werkzeugkompatibilität](/docs/ide/tool-compatibility).
- `gpt-6-luna` / `gpt-5.6-luna` bietet QCode nicht an, ebenso wenig die Gemini-Familie; verwenden Sie `gpt-6.1-sol`, `gpt-6-sol`, `gpt-5.6-terra` oder ein chinesisches Modell.
- **Direct Connections** (der Browser des Nutzers geht direkt zum Anbieter) sind offiziell „currently **experimental**“ und standardmäßig aus — der Administrator schaltet sie an: „**Settings > Admin > Connections > Direct Connections**: Toggle **On**“ oder `ENABLE_DIRECT_CONNECTIONS=true`, was „Enables or disables direct connections.“; der Schlüssel liegt dort clientseitig: „keys are stored in the browser's local storage“. Weil der Browser die Anfrage stellt, verlangt die Dokumentation, dass „the API provider must have **Cross-Origin Resource Sharing (CORS)** configured to allow requests from your Open WebUI domain“; ob QCode browserdirekte Anfragen für Ihre Domain beantwortet, wurde hier nicht geprüft — rechnen Sie mit der Verbindungsseite der Verwaltung.
- Nichts auf dieser Seite wurde mit einem echten Schlüssel ausgeführt. Feldnamen, Menüpfade, Variablennamen und Befehle sind wörtlich der offiziellen Dokumentation entnommen; die QCode-Endpunktwerte stammen aus [Endpunkte und API-Pfade](/docs/getting-started/endpoints-and-api-paths).

## Weiteres

- [Endpunkte und API-Pfade](/docs/getting-started/endpoints-and-api-paths) — welche Modellfamilie auf welchem Protokoll läuft
- [Übersicht zur Werkzeugkompatibilität](/docs/ide/tool-compatibility) — Werkzeuge mit Anthropic-Protokoll, wenn Sie Claude brauchen
- [Chinesische Modelle](/docs/usage/cn-models) — IDs und Unterschiede für GLM / Kimi / DeepSeek / Qwen
- [Modellauswahl](/docs/usage/model-selection) — die passende ID für eine Aufgabe
- [Fehlerbehebung](/docs/reference/troubleshooting) — Fehlerbilder auf QCode-Seite
- [Cherry Studio anbinden](/docs/ide/cherry-studio) — ein Client mit Anthropic-typischer Verbindung
- [SillyTavern anbinden](/docs/ide/sillytavern) — ein weiterer OpenAI-kompatibler Client