# Coze an QCode anbinden: eine Anleitung

Mit den folgenden 7 Schritten wählen Sie passend zu Ihrer Coze-Kontoversion den richtigen Weg, binden QCodes Claude-, GPT- und chinesische Modelle in Coze-Agenten oder -Workflows ein und prüfen die Anfragen anschließend im Backend nach.


**Kurz gesagt**: Coze hat keinen Schalter für eine globale Base-URL benutzerdefinierter Modelle, der persönlichen Konten offensteht. **Persönliche Konten und Team-Konten** verbinden sich über ein „benutzerdefiniertes Plugin“ oder einen „HTTP-Anfrage-Knoten im Workflow“ direkt mit der QCode-Schnittstelle und können dabei sowohl `claude-opus-5-5` (Anthropic-Schnittstelle) als auch `gpt-6.2-sol` (OpenAI-kompatible Schnittstelle) aufrufen; **Administratoren der Enterprise-Flaggschiff-Edition** können in „Coze-Programmierung (`code.coze.cn`) → Unternehmensorganisation verwalten → Modellanbindung → Benutzerdefiniertes Modell“ `gpt-6.2-sol` und chinesische Modelle nativ anbinden, doch dort ist das Protokoll fest auf OpenAI Chat Completions festgelegt und **Claude wird nicht unterstützt**.

| Anbindungsweg | Geeignete Konten | Verfügbare QCode-Modelle | Anbindungsadresse | Authentifizierung |
|---|---|---|---|---|
| Benutzerdefiniertes Plugin / Workflow-HTTP (Claude) | Alle Coze-Konten | `claude-opus-5-5` und weitere Claude-Modelle | `https://api.qcode.cc/api/v1/messages` | Anfrage-Header `x-api-key: cr_xxxxxxxx` und `anthropic-version: 2023-06-01` |
| Benutzerdefiniertes Plugin / Workflow-HTTP (GPT / chinesische Modelle) | Alle Coze-Konten | `gpt-6.2-sol`, chinesische Modelle | `https://api.qcode.cc/openai/v1/chat/completions` | Anfrage-Header `Authorization: Bearer cr_xxxxxxxx` |
| Natives benutzerdefiniertes Modell (Coze-Programmierungs-Backend) | Nur Administratoren einer Enterprise-Flaggschiff-Organisation | `gpt-6.2-sol`, chinesische Modelle (**Claude nicht unterstützt**) | `https://api.qcode.cc/openai/v1` (`/chat/completions` wird automatisch angehängt) | Authentifizierung `Authorization` mit `cr_xxxxxxxx` (alternativ Header) |

Geprüft am 2026-11-22 · Coze (coze.cn) und Coze-Programmierung (code.coze.cn) · Strukturierte Textanleitung


[Coze (扣子)](https://www.coze.cn) ist eine Cloud-Plattform zum Bauen von Agenten und Workflows und besteht aus zwei Oberflächen: dem Hauptprodukt „Coze“ (`www.coze.cn`) und der „Coze-Programmierung“ (扣子编程, `code.coze.cn`) für Unternehmen und Low-Code-Verwaltung. Bevor Sie loslegen, sollten Sie vier reale Produktgrenzen kennen, damit Sie nicht wiederholt nach Optionen suchen, die es in der Oberfläche nicht gibt:

> **Reale Unterstützung und Grenzen**:
> 1. **Anmeldung bei Coze ist Pflicht**: Ob Web- oder Desktop-Version, Sie müssen sich mit Mobilfunknummer, E-Mail oder QR-Code am Coze-Konto anmelden; ein Offline-Betrieb ohne Plattformkonto ist nicht möglich.
> 2. **Die native „Modellanbindung“ ist nur für Administratoren der Enterprise-Flaggschiff-Edition**: Laut offizieller Coze-Dokumentation ist der Eintrag „Modellanbindung → Benutzerdefiniertes Modell“ **nur für die Enterprise-Flaggschiff-Edition freigegeben, und nur der Organisations-Superadministrator oder ein Administrator kann ihn sehen und konfigurieren**; normale persönliche Konten und normale Arbeitsbereiche sehen diesen Eintrag nicht.
> 3. **Native benutzerdefinierte Modelle unterstützen Claude nicht**: Das API-Protokoll nativer benutzerdefinierter Coze-Modelle ist fest auf OpenAI Chat/completions gelegt, und der Upstream muss zwingend Streaming-Antworten (`stream=true`) unterstützen; eine Option für das Anthropic-Messages-Protokoll gibt es nicht. Der OpenAI-kompatible Endpunkt von QCode nimmt keine Claude-Modelle an, deshalb lässt sich `claude-opus-5-5` **ausschließlich über ein benutzerdefiniertes Plugin oder eine HTTP-Anfrage im Workflow aufrufen**.
> 4. **Grenzen der HTTP-Plugin- und Workflow-Lösung**: Wenn persönliche Konten und Team-Konten QCode per HTTP-Anfrage aufrufen, läuft QCode als externes Werkzeug des Agenten oder als Verarbeitungsknoten im Workflow; das standardmäßige Hauptsteuerungsmodell des Agenten lässt sich damit nicht ersetzen, und das Ergebnis erscheint erst nach Eintreffen der vollständigen JSON-Antwort (also keine native zeichenweise Streaming-Ausgabe).


- **Gilt für**: Browser-Webversion (`www.coze.cn` / `code.coze.cn`); optional Desktop-Version für Windows / macOS
- **Anbindungsweg**: benutzerdefiniertes Plugin / HTTP-Anfrage im Workflow (alle Konten); natives benutzerdefiniertes Modell (nur Administratoren der Enterprise-Flaggschiff-Edition)
- **Inhalt geprüft am**: 2026-11-22
- **Zeitbedarf**: 10–15 Minuten
- **Sie brauchen**: ein angemeldetes Coze-Konto; einen QCode-API-Key, der mit `cr_` beginnt



- Sie haben ein Coze-Konto registriert und können sich anmelden ([www.coze.cn](https://www.coze.cn)); wenn Sie native benutzerdefinierte Modelle nutzen möchten, prüfen Sie, dass Ihre Organisation die **Enterprise-Flaggschiff-Edition** hat, Ihr Konto **Organisations-Superadministrator oder Administrator** ist und Sie die Coze-Programmierung ([code.coze.cn](https://code.coze.cn)) öffnen können
- Sie haben sich bei QCode.cc registriert und im [Dashboard](https://qcode.cc/de/dashboard) den API-Key kopiert, der mit `cr_` beginnt. Noch kein Konto? [Registrieren](https://qcode.cc/de/auth/sign-up?utm_source=docs.qcode.cc&utm_medium=tut_before&utm_campaign=knowledge_base&src=docs-ide-coze-before) Sie sich zuerst bei QCode, wählen Sie auf der [Preisseite](https://qcode.cc/de/pricing?utm_source=docs.qcode.cc&utm_medium=tut_before&utm_campaign=knowledge_base&src=docs-ide-coze-before) einen passenden Tarif und erstellen Sie den Key danach im [Dashboard](https://qcode.cc/de/dashboard)
- Sie wissen, welches Modell Sie aufrufen möchten: für `claude-opus-5-5` wählen Sie **Weg A (HTTP-Plugin / Workflow)**; für `gpt-6.2-sol` oder chinesische Modelle wählen persönliche Konten **Weg A**, Administratoren der Enterprise-Flaggschiff-Edition können **Weg B (natives benutzerdefiniertes Modell)** nutzen
- Ihr aktuelles Netzwerk erreicht `www.coze.cn`, `code.coze.cn`, `api.qcode.cc` und `probe.qcode.cc`


**Brauchen Sie einen API-Key?**

Wenn Sie noch kein QCode-Konto haben, [Registrieren](https://qcode.cc/de/auth/sign-up?utm_source=docs.qcode.cc&utm_medium=tut_key_step&utm_campaign=knowledge_base&src=docs-ide-coze-key) Sie sich zuerst bei QCode. Wenn Sie lieber nach tatsächlichem Verbrauch zahlen, kaufen Sie zunächst ein [Nutzungspaket](https://qcode.cc/de/pay-as-you-go?utm_source=docs.qcode.cc&utm_medium=tut_key_step&utm_campaign=knowledge_base&src=docs-ide-coze-key) und erstellen Sie anschließend im [Dashboard](https://qcode.cc/de/dashboard) den vollständigen API-Key ab `cr_` und kopieren Sie ihn. Bezahlen können Sie mit Kredit- oder Debitkarte (Visa / Mastercard) — siehe [Zahlungsarten](/docs/reference/payment-methods).


## Vorbereitung: Einstieg prüfen und Anbindungsweg wählen

Die gesamte Konfiguration in Coze lässt sich direkt im Browser erledigen; ein eigener Desktop-Client ist nicht nötig. Wenn Sie lieber die Desktop-Version nutzen, können Sie sie nur über die Startseite von [Coze](https://www.coze.cn) herunterladen, indem Sie den Mauszeiger auf „Desktop-Version herunterladen“ (下载桌面端) bewegen und das Installationspaket für Windows oder macOS herunterladen (Coze ist keine Open-Source-Desktopsoftware, es gibt also keine GitHub Releases, kein winget und kein Paket im Microsoft Store; nach der Installation landet man standardmäßig in der Coze-Agenten-Workbench, und für die Konfiguration unternehmenseigener Modelle muss man dennoch den Browser mit `code.coze.cn` öffnen).

Wählen Sie anhand Ihrer Kontoversion und Ihres Zielmodells unten den passenden Weg:

**Weg A: persönliche Konten / Team-Konten (benutzerdefiniertes Plugin / HTTP-Anfrage)**

- **Für wen**: alle Coze-Konten (einschließlich normaler persönlicher Konten, Team-Arbeitsbereiche und Unternehmensnutzer, die `claude-opus-5-5` aufrufen möchten).
- **Unterstützte Modelle**: sowohl `claude-opus-5-5` (über den Anthropic-Endpunkt `https://api.qcode.cc/api/v1/messages`) als auch `gpt-6.2-sol` und chinesische Modelle (über den OpenAI-kompatiblen Endpunkt `https://api.qcode.cc/openai/v1/chat/completions`).
- **Vorgehen**: erledigen Sie unten **Schritt 1 → Schritt 2 → Schritt 3 → Schritt 4 → Schritt 7** (Schritt 5 und 6 gelten nur für Unternehmensadministratoren und werden übersprungen).


**Weg B: Administratoren der Enterprise-Flaggschiff-Edition (natives benutzerdefiniertes Modell)**

- **Für wen**: Nutzer, deren Organisation die **Enterprise-Flaggschiff-Edition** von Coze gebucht hat und deren Konto **Organisations-Superadministrator oder Administrator** ist.
- **Unterstützte Modelle**: `gpt-6.2-sol` und chinesische Modelle (über `https://api.qcode.cc/openai/v1`); **Claude-Modelle werden nicht unterstützt** (der native Coze-Einstieg bietet kein Anthropic-Protokoll).
- **Hauptvorteil**: Nach der Anbindung und der Freigabe für einen Arbeitsbereich können Mitglieder das Modell im Modellauswahlfeld der Agentenkonfiguration wie ein eingebautes Modell direkt umschalten, und Streaming-Antworten werden nativ unterstützt.
- **Vorgehen**: erledigen Sie unten **Schritt 1 → Schritt 5 → Schritt 6 → Schritt 7** (das HTTP-Plugin aus Schritt 2–4 ist nicht nötig).


## Schritt-für-Schritt-Konfiguration



### Zuerst den QCode-Key und den Endpunkt lokal prüfen

Bevor Sie das Coze-Backend öffnen, senden Sie im lokalen Terminal (Windows PowerShell, macOS-Terminal oder Linux-Shell) eine minimale Testanfrage und prüfen Sie, ob Ihr `cr_`-Key und das Zielmodell funktionieren. So können Sie bei einem späteren Fehler in Coze sofort erkennen, ob das Problem an der Formularkonfiguration in Coze liegt und nicht am Key selbst.

Wechseln Sie je nach Modellfamilie, die Sie aufrufen möchten, auf die passende Registerkarte, ersetzen Sie `cr_xxxxxxxx` durch Ihren echten Key und führen Sie den Befehl aus:

**Claude prüfen (claude-opus-5-5)**

```bash
curl -sS https://api.qcode.cc/api/v1/messages \
  -H "Content-Type: application/json" \
  -H "x-api-key: cr_xxxxxxxx" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-opus-5-5",
    "max_tokens": 256,
    "messages": [
      {"role": "user", "content": "Hallo, stell dich bitte in einem Satz vor"}
    ]
  }'
```


**GPT prüfen (gpt-6.2-sol)**

```bash
curl -sS https://api.qcode.cc/openai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer cr_xxxxxxxx" \
  -d '{
    "model": "gpt-6.2-sol",
    "stream": false,
    "messages": [
      {"role": "user", "content": "Hallo, stell dich bitte in einem Satz vor"}
    ]
  }'
```



Richtig gemacht sehen Sie: Das Terminal gibt ein vollständiges JSON zurück; im Feld `content[0].text` der Claude-Antwort beziehungsweise im Feld `choices[0].message.content` der GPT-Antwort steht eine Selbstvorstellung, und es gibt kein `error`-Objekt.


**Hängt es? Der lokale Test gibt 401 oder model_not_available_on_endpoint zurück**

Prüfen Sie drei Punkte der Reihe nach: 1) Der Key muss vollständig mit `cr_` beginnen; hängen Sie hinter Anführungszeichen und Doppelpunkt keine zusätzlichen Zeilenumbrüche oder überflüssigen Leerzeichen ein. 2) `claude-opus-5-5` muss an `https://api.qcode.cc/api/v1/messages` mit dem Header `x-api-key` gehen und darf nicht an `/openai/v1` gesendet werden. 3) `gpt-6.2-sol` muss an `https://api.qcode.cc/openai/v1/chat/completions` mit `Authorization: Bearer cr_xxxxxxxx` gehen. Falls es in Windows PowerShell Probleme mit der Maskierung einfacher Anführungszeichen gibt, nutzen Sie `curl.exe` oder prüfen Sie direkt über die Testfunktion des HTTP-Knotens im Coze-Workflow.




### Weg A: die QCode-Schnittstelle im HTTP-Knoten des Workflows oder im benutzerdefinierten Plugin eintragen

Melden Sie sich auf der [Coze-Hauptseite](https://www.coze.cn) an, öffnen Sie den Ziel-Arbeitsbereich und wählen Sie je nach Nutzungsart eine der beiden Varianten:

- **HTTP-Anfrage-Knoten im Workflow (am schnellsten)**: Erstellen oder öffnen Sie einen Workflow, fügen Sie auf der Arbeitsfläche den Knoten „HTTP-Anfrage“ (HTTP 请求) hinzu und setzen Sie die Anfragemethode auf `POST`.
- **Benutzerdefiniertes Plugin (besser für mehrere Agenten wiederverwendbar)**: Öffnen Sie im Arbeitsbereich die Seite für Plugins / Ressourcen, erstellen Sie ein benutzerdefiniertes Plugin auf Basis eines vorhandenen HTTP-Dienstes und fügen Sie ein Werkzeug mit der Methode `POST` hinzu.

Füllen Sie je nach Modellfamilie auf der passenden Registerkarte URL, Anfrage-Header (Headers) und JSON-Anfragekörper (Body) aus. Dabei steht `{{user_prompt}}` für die Textvariable, die Sie im Eingabeknoten des Coze-Workflows oder in den Eingabeparametern des Plugins definiert haben; bei der eigentlichen Konfiguration fügen Sie sie einfach über den Variablenauswähler der Coze-Oberfläche ein:

**Claude (Anthropic-Protokoll · claude-opus-5-5)**

| Konfigurationspunkt | Eintrag |
|---|---|
| Anfragemethode | `POST` |
| Vollständige Anfrage-URL | `https://api.qcode.cc/api/v1/messages` (wenn das Plugin Basis-URL und Pfad getrennt abfragt: Basis-URL `https://api.qcode.cc/api`, Pfad `/v1/messages`) |
| Header 1 | `Content-Type`: `application/json` |
| Header 2 | `x-api-key`: `cr_xxxxxxxx` (durch Ihren Key ersetzen, **ohne** Präfix `Bearer `) |
| Header 3 | `anthropic-version`: `2023-06-01` |

Wählen Sie als Body-Typ `JSON` und tragen Sie ein:

```json
{
  "model": "claude-opus-5-5",
  "max_tokens": 2048,
  "messages": [
    {
      "role": "user",
      "content": "{{user_prompt}}"
    }
  ]
}
```


**GPT / chinesische Modelle (OpenAI-kompatibel · gpt-6.2-sol)**

| Konfigurationspunkt | Eintrag |
|---|---|
| Anfragemethode | `POST` |
| Vollständige Anfrage-URL | `https://api.qcode.cc/openai/v1/chat/completions` (wenn das Plugin Basis-URL und Pfad getrennt abfragt: Basis-URL `https://api.qcode.cc/openai/v1`, Pfad `/chat/completions`) |
| Header 1 | `Content-Type`: `application/json` |
| Header 2 | `Authorization`: `Bearer cr_xxxxxxxx` (zwischen `Bearer` und Key genau ein ASCII-Leerzeichen) |

Wählen Sie als Body-Typ `JSON` und tragen Sie ein:

```json
{
  "model": "gpt-6.2-sol",
  "stream": false,
  "messages": [
    {
      "role": "user",
      "content": "{{user_prompt}}"
    }
  ]
}
```

Wenn Sie stattdessen ein chinesisches Modell nutzen möchten, ändern Sie einfach `"model"` in eine vom OpenAI-kompatiblen Endpunkt unterstützte Modell-ID wie `glm-5.3`, `kimi-k3`, `deepseek-v4-pro` oder `qwen3.8-max`.



Richtig gemacht sehen Sie: Die Anfragemethode ist `POST`, URL und Protokoll der Modellfamilie passen exakt zusammen, in den Headers sind Key und Versions-Header vollständig, und im JSON-Editor erscheint keine rote Syntaxwarnung.


**Hängt es? Das JSON meldet einen Formatfehler, oder Sie wissen nicht, wie mehrstufige Verlaufsnachrichten einzutragen sind**

Prüfen Sie zuerst, dass alle Anführungszeichen halbbreite ASCII-Doppelzeichen `"` sind, dass hinter dem letzten Feld kein überflüssiges Komma steht und dass `"stream"` auf `false` bleibt (HTTP-Knoten im Workflow und Plugins analysieren standardmäßig eine einzelne JSON-Antwort; mit aktiviertem Streaming wird der Antwortkörper zu mehrzeiligen `data:`-Fragmenten und lässt sich nicht mehr parsen). Wenn die Nutzereingabe Anführungszeichen oder Zeilenumbrüche enthalten kann, übergeben Sie sie am besten über die „JSON-Parameterbindung / strukturierte Eingabeparameter“ des Coze-Workflows oder Plugins und kleben Sie unmaskierten Langtext nicht direkt in den JSON-String.




### Weg A: Feldextraktion für die Antwort konfigurieren und Probelauf starten

Sobald die HTTP-Anfrage läuft, muss der Textinhalt aus der zurückgegebenen JSON-Antwort extrahiert werden, damit der Ausgabeknoten des Workflows oder der Agent ihn lesen kann. Die Antwortpfade der beiden Protokolle unterscheiden sich; tragen Sie die Zuordnung der Ausgabeparameter passend zu Ihrer konfigurierten Schnittstelle ein:

**Claude-Antwort extrahieren (Anthropic-Format)**

Typische Antwortstruktur:

```json
{
  "id": "msg_01...",
  "type": "message",
  "role": "assistant",
  "model": "claude-opus-5-5",
  "content": [
    {
      "type": "text",
      "text": "Hallo, ich bin Claude und unterstütze dich bei Denkaufgaben, beim Schreiben und beim Programmieren."
    }
  ],
  "usage": {
    "input_tokens": 18,
    "output_tokens": 32
  }
}
```

- **Pfad zum Textinhalt**: `content[0].text` (im Workflow können Sie mit einem „Code-Knoten“ oder über die Konfiguration der Ausgabeparameter direkt `body.content[0].text` lesen).


**GPT- / chinesische Antwort extrahieren (OpenAI-kompatibles Format)**

Typische Antwortstruktur:

```json
{
  "id": "chatcmpl-...",
  "object": "chat.completion",
  "model": "gpt-6.2-sol",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hallo, ich helfe dir bei Fragen und Antworten, bei Analysen und beim Schreiben von Code."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 18,
    "completion_tokens": 24,
    "total_tokens": 42
  }
}
```

- **Pfad zum Textinhalt**: `choices[0].message.content` (mit `body.choices[0].message.content` erhalten Sie direkt die reine Textantwort).


Klicken Sie nach der Konfiguration der Ausgabeparameter im Workflow oder beim Plugin-Werkzeug auf „Probelauf / Debuggen“, übergeben Sie für `user_prompt` den Satz „Hallo, stell dich bitte in einem Satz vor“ und beobachten Sie den zurückgegebenen Statuscode und das extrahierte Textergebnis.


Richtig gemacht sehen Sie: Der Debug-Lauf gibt den HTTP-Statuscode `200` zurück, und im Ausgabefenster wurde erfolgreich eine reine Textantwort ohne die umgebende JSON-Struktur extrahiert.


**Hängt es? Der Probelauf läuft in einen Timeout, oder das Ausgabefeld bleibt leer**

1) Bei einem Timeout verkleinern Sie zuerst `max_tokens` etwas (zum Beispiel `1024`) und testen eine kurze Antwort; wechseln Sie außerdem die URL-Domain von `api.qcode.cc` auf den Asien-Knoten `asia.qcode.cc` (zum Beispiel `https://asia.qcode.cc/api/v1/messages` oder `https://asia.qcode.cc/openai/v1/chat/completions`). 2) Wenn der Statuscode `200` ist, das extrahierte Feld aber leer bleibt, klappen Sie den rohen Antwortkörper `body` auf und prüfen Sie, ob Sie `content[0].text` und `choices[0].message.content` vertauscht haben oder ob Sie vergessen haben, den Antwortkörper-String zuerst in ein JSON-Objekt zu parsen.




### Weg A: veröffentlichen und an den Coze-Agenten binden

Wenn das Debuggen geklappt hat, veröffentlichen Sie Ihr benutzerdefiniertes Plugin oder Ihren Workflow im aktuellen Arbeitsbereich und öffnen Sie dann die Konfigurationsseite des Ziel-Agenten:

1. Fügen Sie im Bereich „Fähigkeiten“ (技能) der Konfigurationsseite das soeben veröffentlichte Plugin oder den Workflow zum Agenten hinzu.
2. Schreiben Sie in „Persönlichkeit und Antwortlogik (Systemprompt)“ klare Auslöseregeln, damit das Standardmodell von Coze das Plugin nicht überspringt und selbst antwortet. Zum Beispiel:

```text
Wenn der Nutzer komplexen Code, eine tiefgehende Analyse oder ausdrücklich eine Antwort mit einem QCode-Modell verlangt, muss das gebundene QCode-Plugin bzw. der gebundene QCode-Workflow aufgerufen, die vollständige Frage des Nutzers in den Parameter `user_prompt` übergeben und das vom Werkzeug zurückgegebene Textergebnis korrekt an den Nutzer ausgegeben werden; erfinden Sie keine Ersatzantworten.
```

Senden Sie nach dem Speichern im Dialog „Vorschau und Debuggen“ auf der rechten Seite eine Nachricht, die die genannte Bedingung auslöst (zum Beispiel „Bitte rufe das QCode-Werkzeug auf und stell dich in einem Satz vor“), und beobachten Sie, ob im Debug-Protokoll tatsächlich das Plugin oder der Workflow aufgerufen wird.


Richtig gemacht sehen Sie: Im Aufrufverlauf der Vorschau erscheint ein Ausführungseintrag des soeben gebundenen Plugins oder Workflows mit erfolgreichem Status, und in der Sprechblase wird die von QCode gelieferte Antwort ausgegeben.


**Hängt es? Der Agent ruft das Plugin nicht auf und antwortet selbst**

Prüfen Sie vorrangig drei Stellen: 1) Plugin oder Workflow müssen tatsächlich über „Veröffentlichen“ (发布) veröffentlicht sein; ein bloß gespeicherter Entwurf wird vom Agenten nicht zuverlässig aufgerufen. 2) Beschreibung des Plugin-Werkzeugs sowie die Erläuterung des Parameters `user_prompt` sollten den Zweck klar benennen, damit das steuernde Modell sie erkennt. 3) Wenn Sie möchten, dass **jede Nutzereingabe zwingend über QCode läuft und nicht das Standardmodell über die Auslösung entscheidet**, können Sie den Agenten in den workflowgesteuerten Modus umstellen, sodass die Nutzereingabe direkt in einen Workflow mit QCode-HTTP-Knoten gelangt.




### Weg B (nur Administratoren der Enterprise-Flaggschiff-Edition): natives benutzerdefiniertes Modell im Coze-Programmierungs-Backend anbinden

> Dieser Schritt und Schritt 6 gelten **ausschließlich für Organisations-Superadministratoren oder Administratoren der Enterprise-Flaggschiff-Edition von Coze**. Wenn Sie ein normales persönliches Konto haben, springen Sie direkt zu Schritt 7 und prüfen die Anfrageprotokolle.

1. Öffnen Sie im Browser die Coze-Programmierung [code.coze.cn](https://code.coze.cn) und melden Sie sich mit Ihrem Unternehmensadministrator-Konto an.
2. Klicken Sie unten links auf der Seite auf Ihr Profilbild, wählen Sie das zugehörige **Unternehmenskonto** und klicken Sie dann auf das Symbol „Einstellungen“ der Unternehmensorganisation, um „Unternehmensorganisation verwalten“ zu öffnen.
3. Gehen Sie in „Unternehmensorganisation verwalten“ nacheinander zu **„Modellanbindung → Benutzerdefiniertes Modell“** und klicken Sie auf **„Modell anbinden“**.
4. Tragen Sie im Dialog die Parameter gemäß der folgenden Tabelle ein, setzen Sie anschließend bei Bedarf die Modellfähigkeiten (etwa Werkzeugaufrufe, tiefes Nachdenken) und die Kontextlänge und speichern Sie:

| Formularfeld | Eintrag | Erläuterung |
|---|---|---|
| Anzeigename des Modells | `QCode GPT 6.2 Sol` (frei wählbar) | Beeinflusst nur den Namen, den Mitglieder in der Oberfläche sehen |
| Eindeutige Modellkennung | `gpt-6.2-sol` | Wird direkt in das Feld `model` der Anfrage geschrieben; auch eine chinesische Modell-ID wie `glm-5.3` ist möglich, **auf keinen Fall aber ein Claude-Modell** |
| Modell-API-URL | `https://api.qcode.cc/openai/v1` | Coze hängt `/chat/completions` automatisch an, schreiben Sie `/chat/completions` **nicht** zusätzlich hin |
| API-Protokoll | `OpenAI Chat/completions` | Feste Plattformoption, nicht änderbar |
| Authentifizierungsart | `Authorization` | Alternative Methode `Header` (siehe ausklappbaren Hinweis unten) |
| Authentifizierungsschlüssel | `cr_xxxxxxxx` | QCode-Key eintragen; als Speicherart genügt Klartext, eine Anbindung an Volcano KMS ist nicht nötig |


Richtig gemacht sehen Sie: Nach dem erfolgreichen Speichern kehren Sie zur Liste „Benutzerdefiniertes Modell“ zurück, und das soeben angebundene `QCode GPT 6.2 Sol` erscheint dort regulär, ohne Hinweis auf Stilllegung oder eine Störung.


**Hängt es? Sie finden „Modellanbindung“ nicht, oder der Verbindungstest meldet 401 / 404**

- **„Modellanbindung“ ist gar nicht sichtbar**: Prüfen Sie, ob aktuell das Unternehmenskonto und nicht ein persönliches Konto ausgewählt ist, ob die Unternehmensorganisation die **Enterprise-Flaggschiff-Edition** gebucht hat und ob Ihre Rolle Organisations-Superadministrator oder Administrator ist. Sind die Bedingungen nicht erfüllt, wird der Eintrag nicht angezeigt; nutzen Sie dann Weg A.
- **Meldung <code>404</code>**: Prüfen Sie, ob die „Modell-API-URL“ nur bis `/openai/v1` ausgefüllt ist und am Ende kein `/chat/completions` und kein überflüssiger Schrägstrich steht.
- **Meldung <code>401</code> / Authentifizierung fehlgeschlagen**: Prüfen Sie zuerst, ob der Key mit `cr_` beginnt und keine überflüssigen Leerzeichen enthält; wenn mit `Authorization` weiterhin `401` kommt, wechseln Sie auf die Authentifizierungsart `Header`, tragen Sie als Header Key `Authorization` und als Header Value `Bearer cr_xxxxxxxx` ein und speichern und testen Sie erneut.




### Weg B (nur Administratoren der Enterprise-Flaggschiff-Edition): Arbeitsbereiche freigeben und im Agenten auswählen

Nach der Anbindung eines benutzerdefinierten Modells in Coze ist es **standardmäßig für alle Arbeitsbereiche nicht verfügbar**; ein Administrator muss die Freigabe manuell aktivieren, damit Mitglieder es sehen:

1. Bleiben Sie in der Liste „Unternehmensorganisation verwalten → Modellanbindung → Benutzerdefiniertes Modell“, suchen Sie das soeben angebundene Modell und klicken Sie rechts in dieser Zeile auf **„… → Verfügbare Bereiche ändern“** (修改可用空间).
2. Aktivieren Sie im Dialog den Schalter für den Ziel-Arbeitsbereich und speichern Sie.
3. Wechseln Sie zurück zur Agentenkonfiguration von Coze (oder lassen Sie ein Mitglied des Ziel-Arbeitsbereichs die Konfigurationsseite öffnen), öffnen Sie das Modellauswahlfeld und wählen Sie in der Gruppe **„Benutzerdefiniertes Modell“** das soeben angebundene `QCode GPT 6.2 Sol`.
4. Geben Sie im Dialog rechts „Hallo, stell dich bitte in einem Satz vor“ ein und senden Sie die Nachricht; beobachten Sie, ob die Streaming-Antwort normal zeichenweise ausgegeben wird.


Richtig gemacht sehen Sie: Der Verfügbarkeitsschalter des Ziel-Arbeitsbereichs ist eingeschaltet; in der Gruppe „Benutzerdefiniertes Modell“ der Modellliste des Agenten lässt sich das Modell auswählen, und nach dem Senden antwortet es normal im Streaming, ohne Fehler `401`, `404` oder `model not found`.


**Hängt es? Mitglieder sehen das Modell nicht, oder nach dem Senden dreht sich endlos ein Ladekreis**

- **Mitglieder sehen das Modell nicht**: Prüfen Sie unter „Verfügbare Bereiche ändern“, ob genau der Arbeitsbereich ausgewählt ist, in dem die Mitglieder aktuell arbeiten, und lassen Sie die Mitglieder die Konfigurationsseite neu laden.
- **Meldung, das Modell existiere nicht**: Prüfen Sie, ob als „eindeutige Modellkennung“ versehentlich der Anzeigename eingetragen wurde (etwa `QCode GPT 6.2 Sol`); dort muss eine von QCode tatsächlich unterstützte Modell-ID stehen (etwa `gpt-6.2-sol`).
- **Nach dem Senden dreht sich endlos ein Ladekreis**: Native benutzerdefinierte Coze-Modelle fragen den Upstream fest im Streaming-Modus (`stream=true`) ab; prüfen Sie, ob die URL `https://api.qcode.cc/openai/v1` lautet (im Festlandnetz ist auch `https://asia.qcode.cc/openai/v1` möglich) und ob sie von einer Unternehmens-Firewall-Regel blockiert wird.




### Die Anfrageprotokolle auf probe.qcode.cc prüfen

Unabhängig davon, ob Sie Weg A oder Weg B gewählt haben, sollten Sie abschließend einmal die echten Gateway-Protokolle prüfen, um sicherzugehen, dass die Antwort tatsächlich von QCode stammt und nicht von einem eingebauten Coze-Modell:

1. Öffnen Sie im Browser [probe.qcode.cc](https://probe.qcode.cc/).
2. Fügen Sie denselben `cr_`-API-Key ein, den Sie in Coze verwenden, und klicken Sie auf „Abfragen“ (查询).
3. Scrollen Sie zur Anfrageliste und prüfen Sie, ob der Anfragezeitpunkt des neuesten Eintrags mit dem Moment übereinstimmt, in dem Sie gerade in Coze gedebuggt oder gesprochen haben, und ob in der Statuscodespalte `200` steht.


Richtig gemacht sehen Sie: Oben in der Anfrageliste erscheint ein Eintrag, der zeitlich zum eben durchgeführten Test passt, mit Status `200` sowie den zugehörigen Daten zur Zeit bis zum ersten Zeichen und zur Gesamtdauer.




## Erfolg prüfen

Prüfen Sie die folgenden Punkte; stimmen alle überein, ist Coze stabil mit QCode verbunden:

- Die lokalen Testbefehle liefern für `claude-opus-5-5` oder `gpt-6.2-sol` sowohl `200` als auch gültigen Text;
- **Weg A**: Der Probelauf des HTTP-Knotens im Coze-Workflow oder des benutzerdefinierten Plugins liefert `200`, `content[0].text` (Claude) beziehungsweise `choices[0].message.content` (GPT / chinesische Modelle) wurde erfolgreich extrahiert, und im Vorschaubereich des Agenten ist der Werkzeugaufruf als erfolgreich sichtbar;
- **Weg B**: Das „benutzerdefinierte Modell“ der Enterprise-Flaggschiff-Edition ist im Normalzustand, der Schalter des Ziel-Arbeitsbereichs ist aktiviert, und Mitglieder erhalten Streaming-Antworten, nachdem sie in der Gruppe „Benutzerdefiniertes Modell“ des Agenten `gpt-6.2-sol` ausgewählt haben;
- Auf [probe.qcode.cc](https://probe.qcode.cc/) finden Sie mit demselben Key einen Anfrageeintrag mit passendem Zeitpunkt und Statuscode `200`.


### Fertig

Sie haben QCode an Coze angebunden und kennen nun die Grenzen beider Wege genau: benutzerdefiniertes Plugin / HTTP-Anfrage einerseits und natives unternehmenseigenes Modell andererseits. So geht es weiter:

- [Endpunkte und API-Formate](/docs/getting-started/endpoints-and-api-paths)
- [Chinesische Modelle anbinden](/docs/usage/cn-models)
- [Abrechnung](/docs/reference/billing)
- [Fehlerbehebung](/docs/reference/troubleshooting)
- Danach: Vergleichen Sie auf der [Preisseite](https://qcode.cc/de/pricing?utm_source=docs.qcode.cc&utm_medium=tut_done&utm_campaign=knowledge_base&src=docs-ide-coze-done) die einzelnen Tarife
- Kehren Sie zum [Dashboard](https://qcode.cc/de/dashboard) zurück, um Nutzung und Guthaben zu prüfen


## Häufige Fehler

| Fehlermeldung / Originaltext | Ursache | Was tun |
|---|---|---|
| Der Eintrag „Modellanbindung → Benutzerdefiniertes Modell“ fehlt | Native benutzerdefinierte Modelle stehen nur Organisations-Superadministratoren oder Administratoren der Enterprise-Flaggschiff-Edition offen; normale persönliche Konten haben dieses Menü nicht | Prüfen Sie, ob Sie auf das Unternehmenskonto gewechselt haben und die Enterprise-Flaggschiff-Edition gebucht ist; persönliche Konten und normale Team-Konten nutzen direkt **Weg A (benutzerdefiniertes Plugin / HTTP-Anfrage im Workflow)** dieser Anleitung |
| `model_not_available_on_endpoint` | `claude-opus-5-5` wurde in den OpenAI-kompatiblen Endpunkt (`/openai/v1`) oder in ein natives benutzerdefiniertes Coze-Modell eingetragen | Der OpenAI-kompatible Endpunkt von QCode nimmt Claude nicht an. Für `claude-opus-5-5` müssen Sie per HTTP-Anfrage direkt den Anthropic-Endpunkt `https://api.qcode.cc/api/v1/messages` verwenden; in native benutzerdefinierte Coze-Modelle gehört nur `gpt-6.2-sol` oder ein chinesisches Modell |
| `404 Not Found` | Der URL-Pfad passt nicht: Beim nativen benutzerdefinierten Modell wurde `/chat/completions` zusätzlich geschrieben, oder beim HTTP-Plugin fehlt das Pfadsuffix | Bei nativen benutzerdefinierten Modellen reicht die „Modell-API-URL“ bis `https://api.qcode.cc/openai/v1` (Coze hängt `/chat/completions` automatisch an); beim HTTP-Anfrage-Knoten muss die vollständige Adresse stehen (`/api/v1/messages` oder `/openai/v1/chat/completions`) |
| `401 Unauthorized` / Authentifizierung fehlgeschlagen | Der Key ist unvollständig, enthält führende oder abschließende Leerzeichen, oder das Format des Auth-Headers passt nicht zum Schnittstellenprotokoll | Prüfen Sie, dass der Key vollständig mit `cr_` beginnt; für die Anthropic-Schnittstelle `x-api-key: cr_...` + `anthropic-version: 2023-06-01`; für die OpenAI-kompatible HTTP-Schnittstelle `Authorization: Bearer cr_...`; bei nativen benutzerdefinierten Modellen mit `Authorization` und weiterhin `401` versuchen Sie die Authentifizierung `Header` mit manuell geschriebenem `Bearer cr_...` |
| `Model not found` / Modell existiert nicht | Der eigene Anzeigename wurde als Modell-ID eingetragen, oder der Modellname ist falsch geschrieben | Prüfen Sie die „eindeutige Modellkennung“ beziehungsweise das Feld `"model"` im JSON und tragen Sie eine von QCode tatsächlich unterstützte Modell-ID ein (etwa `claude-opus-5-5`, `gpt-6.2-sol`, `glm-5.3`) |
| Der HTTP-Knoten kann JSON nicht parsen, oder der native Dialog dreht sich endlos | Die Streaming-Einstellung ist genau umgekehrt: Der HTTP-Knoten erhält einen SSE-Stream, der sich nicht als normales JSON parsen lässt, oder der native Unternehmensweg wird vom Netzwerk blockiert | Im Anfragekörper von HTTP-Plugin / Workflow muss ausdrücklich `"stream": false` stehen; native unternehmenseigene Modelle verwenden fest `stream=true`, prüfen Sie also, ob das Netzwerk `api.qcode.cc` stabil erreicht, oder testen Sie `asia.qcode.cc` |
| Mitglieder sehen das soeben angebundene benutzerdefinierte Modell nicht in der Modellliste des Agenten | Neu angebundene Modelle im Unternehmens-Backend sind standardmäßig für alle Arbeitsbereiche ausgeschaltet | Der Administrator kehrt zur Liste „Benutzerdefiniertes Modell“ zurück, klickt rechts am Modell auf „… → Verfügbare Bereiche ändern“ und aktiviert den Schalter des Ziel-Arbeitsbereichs manuell |

## Häufige Fragen

### Was ist nach dem Ablauf des Keys zu tun?

Das hängt von der Herkunft des Keys ab:

- Bei einem **persönlichen Tarif** lässt sich der Key nach Ablauf nicht verlängern: Schließen Sie einen neuen Tarif ab und verwenden Sie einen neuen Key;
- Bei einem **Nutzungspaket** wird derselbe Key automatisch wieder aktiv, sobald Sie nach dem Ablauf ein neues Nutzungspaket kaufen; die Konfiguration in Coze müssen Sie dabei nicht ändern.

Wenn Sie einen neuen Key verwenden, aktualisieren Sie bitte auch den Key im Anfrage-Header des benutzerdefinierten Coze-Plugins bzw. des HTTP-Knotens im Workflow (Weg A) oder bearbeiten Sie den Authentifizierungsschlüssel des entsprechenden Modells unter „Coze-Programmierung → Unternehmensorganisation verwalten → Modellanbindung → Benutzerdefiniertes Modell“ (Weg B).

### Warum können normale persönliche Konten das Standardmodell eines Coze-Agenten nicht direkt ersetzen?

Das ist eine Berechtigungs- und Produktgrenze der Coze-Plattform selbst: Der native Eintrag „Benutzerdefiniertes Modell“ steht derzeit nur Superadministratoren und Administratoren von Organisationen mit Enterprise-Flaggschiff-Edition offen; im Backend persönlicher Konten gibt es keine Einstellung für eine Base-URL benutzerdefinierter Modelle. Persönliche Konten können QCode in Coze trotzdem nutzen, indem sie es über ein benutzerdefiniertes Plugin oder einen HTTP-Anfrage-Knoten im Workflow als Werkzeug oder Verarbeitungsknoten einbinden.

### Warum lässt sich `claude-opus-5-5` nicht in „Benutzerdefiniertes Modell“ der Enterprise-Flaggschiff-Edition anbinden?

Das API-Protokoll nativer „benutzerdefinierter Modelle“ in Coze ist fest auf OpenAI Chat/completions gelegt, und die Plattform bietet keine Option für das Anthropic-Messages-Protokoll; der OpenAI-kompatible Endpunkt von QCode bedient außerdem nur GPT- und chinesische Modelle und nimmt keine Claude-Anfragen an. Unternehmensnutzer, die `claude-opus-5-5` in Coze aufrufen möchten, müssen daher ebenfalls über ein benutzerdefiniertes Plugin oder einen HTTP-Anfrage-Knoten im Workflow direkt `https://api.qcode.cc/api/v1/messages` ansprechen.

### Was tun, wenn die HTTP-Anfrage im Workflow gelegentlich in einen Timeout läuft?

Prüfen Sie drei Punkte: 1) Wechseln Sie die Anfrage-Domain vom globalen Knoten `api.qcode.cc` auf den Asien-Knoten `asia.qcode.cc` (kürzere Route, derselbe Key gilt); 2) begrenzen Sie `max_tokens` im Anfragekörper sinnvoll (etwa `1024`–`2048`) und kürzen Sie den Prompt, um die Dauer einer einzelnen Generierung zu verringern; 3) erhöhen Sie die Timeout-Konfiguration des HTTP-Knotens im Workflow, damit lange Antworten nicht vorzeitig vom Coze-Knoten abgeschnitten werden.

### Muss man für Coze die Desktop-Version herunterladen? Gibt es ein Open-Source-Installationspaket?

Nein. Ob Sie benutzerdefinierte Plugins konfigurieren, Workflows bauen oder unter `code.coze.cn` unternehmenseigene Modelle verwalten — alles lässt sich in der Browser-Webversion erledigen. Coze bietet zwar Desktop-Versionen für Windows und macOS an, ist aber keine Open-Source-Software: Es gibt keine GitHub Releases, kein winget und kein Paket im Microsoft Store; die Desktop-Version erhalten Sie nur über „Desktop-Version herunterladen“ auf der offiziellen Seite [www.coze.cn](https://www.coze.cn).

## Anbindung auf einen Blick und verfügbare Modelle

### QCode-Knoten und Protokolladressen

Alle drei Anbindungsdomains bieten dieselben fachlichen Möglichkeiten, und derselbe `cr_`-Key gilt überall; wählen Sie je nach Netzwerkumgebung von Coze einen davon:

| Knoten | Anthropic-Schnittstelle (nur Weg A per HTTP-Anfrage) | OpenAI-kompatible Base-URL (Weg A mit `/chat/completions`; Weg B endet hier) |
|---|---|---|
| Global | `https://api.qcode.cc/api/v1/messages` | `https://api.qcode.cc/openai/v1` |
| Asien (erste Wahl im Festland) | `https://asia.qcode.cc/api/v1/messages` | `https://asia.qcode.cc/openai/v1` |
| Nordamerika / Europa | `https://us.qcode.cc/api/v1/messages` | `https://us.qcode.cc/openai/v1` |

### Empfohlene Modelle und passender Coze-Weg

| Modell | Modell-ID | Geeigneter Weg | Protokoll-Endpunkt |
|---|---|---|---|
| Claude Opus 5.5 | `claude-opus-5-5` | Nur Weg A (benutzerdefiniertes Plugin / Workflow-HTTP) | Anthropic (`/api/v1/messages`) |
| GPT 6.2 Sol | `gpt-6.2-sol` | Weg A und Weg B (natives Unternehmensmodell) gleichermaßen | OpenAI-kompatibel (`/openai/v1`) |
| Chinesische Hauptmodelle | `glm-5.3`, `kimi-k3`, `deepseek-v4-pro`, `qwen3.8-max` u. a. | Weg A und Weg B gleichermaßen | OpenAI-kompatibel (`/openai/v1`) |

> QCode bietet derzeit keine Gemini-Modelle an; wählen Sie in Coze daher Claude, GPT oder ein chinesisches Modell. Die vollständigen IDs der chinesischen Modelle finden Sie unter [Chinesische Modelle anbinden](/docs/usage/cn-models), die aktuell im Verkauf befindlichen Typen gelten laut [qcode.cc/models](https://qcode.cc/de/models).

## Verwandte Dokumentation

- [Endpunkte und API-Formate](/docs/getting-started/endpoints-and-api-paths) — die verbindliche Tabelle Protokoll × Modellfamilie
- [Chinesische Modelle anbinden](/docs/usage/cn-models) — Liste der am OpenAI-kompatiblen Endpunkt verfügbaren chinesischen Modelle
- [Abrechnung](/docs/reference/billing) — Regeln für Tarife und Nutzungspakete
- [Fehlerbehebung](/docs/reference/troubleshooting) — allgemeine Statuscodes und Netzwerkerreichbarkeit
- [Offizielle Coze-Dokumentation zur Anbindung benutzerdefinierter Modelle](https://docs.coze.cn/guides/deploy_custom_model) — offizielle Beschreibung der nativen Anbindung in der Enterprise-Flaggschiff-Edition