# Qwen Code einrichten

> **Zuletzt geprüft**: 2026-10-13 · 📄 Laut offizieller Dokumentation (Qwen Code 0.25.1)

## Auf einen Blick

| Punkt | Details |
|---|---|
| Verwendbare Modelle | Claude ✅ (auf der Anthropic-Seite eingetragen) · GPT ✅ · Chinesische Modelle ✅ (auf der OpenAI-kompatiblen Seite eingetragen) · Gemini ❌ — QCode bietet die Gemini-Reihe nicht an, bitte Claude, GPT oder ein chinesisches Modell verwenden |
| Protokoll und Basis-URL | Anthropic: `https://api.qcode.cc/api` · OpenAI-kompatibel: `https://api.qcode.cc/openai/v1` |
| Wo eingerichtet wird | Der Schlüssel `modelProviders` in `~/.qwen/settings.json`; innerhalb der Sitzung `/auth`, `/model`, `/doctor` |
| Offizielle Dokumentation | [Authentifizierung](https://qwenlm.github.io/qwen-code-docs/en/users/configuration/auth/) · [Einstellungsreferenz](https://qwenlm.github.io/qwen-code-docs/en/users/configuration/settings/) |

Qwen Code ist ein quelloffener Coding-Assistent für das Terminal und wird in npm als `@qwen-code/qwen-code` veröffentlicht; diese Seite wurde gegen Version `0.25.1` geprüft. Die Dokumentation ordnet das Verbinden mit „Drittanbietern wie OpenAI, Anthropic, Google, Azure OpenAI, OpenRouter, Requesty, ModelScope oder einem selbst betriebenen Endpunkt“ der Authentifizierung per API-Schlüssel zu — genau diesen Weg nutzt QCode. Über `modelProviders` erklären Sie, welche Modelle existieren und wie sie erreichbar sind, und wechseln zur Laufzeit mit `/model`.

## Welches Protokoll

| Gewünschte Modelle | `modelProviders`-Schlüssel (auth type) | Einzutragende Basis-URL |
|---|---|---|
| Claude | `anthropic` | `https://api.qcode.cc/api` |
| GPT und chinesische Modelle | `openai` | `https://api.qcode.cc/openai/v1` |

Qwen Code schreibt das Protokoll als Schlüssel des Anbieters fest: Für eingebaute Anbieter muss der Schlüssel ein gültiger auth type sein (`openai`, `anthropic`, `gemini`, `vertex-ai`). Jedes Modell wird eindeutig durch sein Protokoll, seine `id` und die konfigurierte `baseUrl` bestimmt.

🔴 **Rufen Sie Claude niemals über die OpenAI-kompatible Basis-URL auf.** QCodes OpenAI-Endpunkt lehnt Claude-Modell-IDs ab; die Antwort lautet `Model '<id>' is not available on this endpoint`. Claude wird auf der `anthropic`-Seite mit `https://api.qcode.cc/api` eingerichtet. GPT-IDs funktionieren auf der Anthropic-Seite ebenfalls nicht.

Geben Sie die Basis-URL genau wie in der Tabelle an: **ohne abschließenden Schrägstrich**, und schreiben Sie den Anfragepfad nicht in das Feld — Sie tragen die Basis ein, nicht `.../v1/messages` oder `.../chat/completions`. Wenn Sie einen regionalen Knoten nutzen, wird aus der Anthropic-Basis `https://asia.qcode.cc/api` oder `https://us.qcode.cc/api`; der Schlüssel bleibt derselbe.

## Installation

Die Installation über npm setzt Node.js 22 oder neuer voraus:

```bash
npm install -g @qwen-code/qwen-code@latest
```

Unter macOS und Linux können Sie stattdessen Homebrew nutzen:

```bash
brew install qwen-code
```

Anschließend öffnen Sie ein Terminal in Ihrem Projekt und starten die CLI:

```bash
cd /path/to/your-project
qwen
```

Im Begrüßungsbildschirm zeigt Ihnen `/help` die verfügbaren Befehle.

## Claude einrichten (Anthropic-Seite)

Der empfohlene Weg der Dokumentation ist eine einzelne Datei: `~/.qwen/settings.json`. Alle Feldnamen unten stehen wörtlich so in der Dokumentation: `modelProviders` enthält je auth type ein Array, jedes Modell braucht eine `id`, und `name`, `baseUrl` sowie `generationConfig` sind optional; `envKey` nennt die Umgebungsvariable, in der der Schlüssel steht.

```json
{
  "modelProviders": {
    "anthropic": [
      {
        "id": "claude-sonnet-5",
        "name": "claude-sonnet-5",
        "envKey": "ANTHROPIC_API_KEY",
        "baseUrl": "https://api.qcode.cc/api"
      }
    ]
  },
  "env": {
    "ANTHROPIC_API_KEY": "cr_your_qcode_key"
  },
  "security": {
    "auth": {
      "selectedType": "anthropic"
    }
  },
  "model": {
    "name": "claude-sonnet-5"
  }
}
```

Die vier Blöcke tun Folgendes, in den Worten der offiziellen Feldtabelle: `modelProviders` erklärt, welche Modelle verfügbar sind und wie man sie verbindet; `env` hält API-Schlüssel in `settings.json` als Rückfallebene, wobei `export` in der Shell und `.env`-Dateien den Vorzug haben; `security.auth.selectedType` teilt Qwen Code mit, welches Protokoll beim Start verwendet wird; `model.name` ist das beim Start aktivierte Standardmodell und muss mit einem Ihrer `id`-Werte übereinstimmen.

Für das Anthropic-Protokoll gibt es auch eine Form mit Umgebungsvariablen — Qwen Code listet dafür `ANTHROPIC_API_KEY`, `ANTHROPIC_BASE_URL` und `ANTHROPIC_MODEL` auf:

```bash
export ANTHROPIC_API_KEY="cr_your_qcode_key"
export ANTHROPIC_BASE_URL="https://api.qcode.cc/api"
export ANTHROPIC_MODEL="claude-sonnet-5"
qwen
```

Sie können in der CLI auch `/auth` ausführen: Die dritte Option im oberen Menü, **Custom Provider**, ist laut Dokumentation der Einstieg, um „einen lokalen Server, einen Proxy oder einen nicht unterstützten Anbieter manuell zu verbinden“, und sie unterstützt kompatible Endpunkte von OpenAI, Anthropic, Gemini und andere.

> **Zum Anfragepfad auf der Anthropic-Seite.** Die offiziellen Anthropic-Beispiele schreiben die `baseUrl` bis zur Endung `/v1` (`"baseUrl": "https://api.anthropic.com/v1"`), wie der Anthropic-Endpunkt den Anfragepfad aus der Basis bildet, bleibt in der Dokumentation offen. Diese Seite nennt deshalb nur den für QCode dokumentierten Wert: Tragen Sie als Basis `https://api.qcode.cc/api` ein und nichts weiter. Über eine andere Schreibweise behaupten wir nichts, was wir geprüft hätten.

## GPT und chinesische Modelle einrichten (OpenAI-kompatible Seite)

Die Dokumentation beschreibt den auth type `openai` als Unterstützung nicht nur für OpenAIs eigenes API, sondern für jede OpenAI-kompatible Endpunkt-Lösung einschließlich gebündelter Anbieter — das ist der Endpunkt, auf dem QCode GPT und chinesische Modelle ausliefert. Die offizielle Regel für einen gehosteten Gateway gilt hier: Setzen Sie in `baseUrl` den `/v1`-Wurzelbereich der API, nicht den vollständigen chat-Pfad, denn das SDK hängt den Anfragepfad selbst an. `https://api.qcode.cc/openai/v1` ist genau dieser Wurzelbereich.

```json
{
  "modelProviders": {
    "openai": [
      {
        "id": "gpt-6.1-sol",
        "name": "gpt-6.1-sol",
        "envKey": "OPENAI_API_KEY",
        "baseUrl": "https://api.qcode.cc/openai/v1"
      },
      {
        "id": "deepseek-v4.1-flash",
        "name": "deepseek-v4.1-flash",
        "envKey": "OPENAI_API_KEY",
        "baseUrl": "https://api.qcode.cc/openai/v1"
      }
    ]
  },
  "env": {
    "OPENAI_API_KEY": "cr_your_qcode_key"
  },
  "security": {
    "auth": {
      "selectedType": "openai"
    }
  },
  "model": {
    "name": "gpt-6.1-sol"
  }
}
```

Nur `/model` zeigt die nicht standardmäßigen auth types an, also nehmen Sie die gewünschten Modelle in das Array auf und wählen Sie sie dort. Die Modell-IDs stammen aus dem QCode-Katalog: `gpt-6.1-sol`, `gpt-6-sol`, `gpt-5.6-terra` oder eine chinesische ID wie [`glm-5.3`](/docs/usage/cn-models), [`deepseek-v4.1-flash`](/docs/usage/cn-models) oder `qwen3.8-max`.

Die Form mit Umgebungsvariablen nutzt die drei Variablen, die Qwen Code für dieses Protokoll aufführt:

```bash
export OPENAI_API_KEY="cr_your_qcode_key"
export OPENAI_BASE_URL="https://api.qcode.cc/openai/v1"
export OPENAI_MODEL="gpt-6.1-sol"
qwen
```

## Verbindung prüfen

Fragen Sie zuerst die CLI selbst, was sie sieht:

```text
/doctor
/model
```

`/doctor` ist der dokumentierte Weg, die eigene Konfiguration jederzeit zu prüfen; in der Befehlstabelle des Schnellstarts lautet der Eintrag dazu „Check current authentication and environment“. `/model` öffnet die Auswahl über die von Ihnen erklärten Einträge, und zwar ohne Neustart: Änderungen an `modelProviders` in `settings.json` übernimmt eine laufende interaktive Sitzung, Sie müssen `/model` nur erneut öffnen, um die neuen Einträge zu sehen.

Prüfen Sie danach den Endpunkt unabhängig von der CLI. Die Anthropic-Messages-Anfrage trägt den Schlüssel in `x-api-key` und die Version in `anthropic-version`:

```bash
KEY="cr_your_qcode_key"
curl -X POST https://api.qcode.cc/api/v1/messages \
  -H "x-api-key: $KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model":"claude-sonnet-5","max_tokens":32,"messages":[{"role":"user","content":"ping"}]}'
```

Diese Seite entsteht aus der Dokumentation, und wir besitzen keinen Test-Schlüssel; deshalb wird hier keine Antwort auf diese Anfrage behauptet. Wenn curl durchläuft, die CLI aber nicht, liegt es an Ihrem `~/.qwen/settings.json`; wenn schon curl scheitert, prüfen Sie Basis-URL und Schlüssel und fahren Sie dann mit der [Fehlersuche](/docs/reference/troubleshooting) fort.

## Bekannte Einschränkungen und Fehlersuche

| Symptom | Bedeutung | Vorgehen |
|---|---|---|
| Eine Claude-ID scheitert über die OpenAI-kompatible Basis-URL | QCode liefert Claude ausschließlich über das Anthropic-Protokoll | Verschieben Sie das Modell in das `anthropic`-Array und setzen Sie `baseUrl` auf `https://api.qcode.cc/api` |
| In Ihrer Konfiguration stehen noch `security.auth.apiKey` oder `security.auth.baseUrl` | Beide Einstellungen sind in der Dokumentation als veraltet markiert, mit dem Hinweis auf die Migration zu `modelProviders` (bei der ersten über `envKey`) | Entfernen Sie sie und erklären Sie das Modell in `modelProviders` |
| `wireApi` steht in einem Anthropic-Eintrag | Die Dokumentation zählt das zu den Konfigurationsfehlern: `wireApi` ist ein Feld der OpenAI-Seite | Nehmen Sie es aus den Anthropic-Einträgen heraus |
| `extra_body` zeigt keine Wirkung | Es wird nur für die OpenAI-kompatiblen Anbieter `openai` und `qwen-oauth` unterstützt; für Anthropic- und Gemini-Anbieter wird es laut Dokumentation ignoriert | Für provider-Modelle ist die dokumentierte Stelle `modelProviders[].generationConfig.extra_body` |
| `model.name` greift nicht | Der Wert muss mit einem `id`-Wert in Ihren `modelProviders` übereinstimmen | Nutzen Sie eine erklärte `id` oder wählen Sie das Modell über `/model` |
| Das gewünschte Modell fehlt in der Auswahl | Nicht standardmäßige auth types erscheinen nur über `/model`, und Anthropic-Modelle müssen in `modelProviders` erklärt sein | Tragen Sie den Eintrag in `~/.qwen/settings.json` ein und öffnen Sie `/model` erneut |

Weitere Punkte:

- **Gemini**: Qwen Code lässt sich selbst für den auth type `gemini` konfigurieren, aber QCode bietet die Gemini-Reihe nicht an — verwenden Sie [Claude, GPT oder ein chinesisches Modell](/docs/usage/cn-models).
- **Nicht im Angebot**: QCode bietet `gpt-6-luna` und `gpt-5.6-luna` nicht an; wählen Sie ein anderes GPT-Modell wie `gpt-6.1-sol`, `gpt-6-sol` oder `gpt-5.6-terra`. Welches Modell zu welcher Aufgabe passt, steht unter [Modell wählen](/docs/usage/model-selection).
- **Neustart oder nicht**: Änderungen an `modelProviders` übernimmt die laufende Sitzung, `providerProtocol` wird dagegen einmal beim Start gelesen und erfordert einen Neustart.
- **Zugangsdaten ohne Befehls-Flag**: Die beiden offiziellen Seiten schreiben das Flag für die OpenAI-Basis-URL unterschiedlich, daher werden Zugangsdaten auf dieser Seite nur über `~/.qwen/settings.json` oder Umgebungsvariablen gesetzt.
- **Sauberkeit der Basis-URL**: kein Schrägstrich am Ende, und der Anfragepfad gehört nicht in das Feld `baseUrl`.
- **Kosten**: Die Gebühren richten sich nach der Token-Menge; die Preise je Modell stehen auf [qcode.cc/models](https://qcode.cc/models). Beträge nennt diese Seite nicht.

## Verwandte Dokumentation

- [Endpunkte und API-Pfade](/docs/getting-started/endpoints-and-api-paths) — welches Protokoll welche Modellfamilie bedient
- [Werkzeug-Kompatibilität](/docs/ide/tool-compatibility) — weitere Tools, die Anthropic oder OpenAI-kompatibel sprechen
- [OpenCode einrichten](/docs/ide/opencode) — eine weitere Terminal-CLI auf denselben beiden Endpunkten
- [Chinesische Modelle](/docs/usage/cn-models)
- [Modell wählen](/docs/usage/model-selection)
- [Fehlersuche](/docs/reference/troubleshooting)