# Coze with QCode tutorial

Follow the 7 steps below to pick the right path for your Coze account edition, connect QCode's Claude, GPT and Chinese models to a Coze agent or workflow, and check the request log in the console.


**Short answer**: Coze has no "global custom model Base URL" switch for personal accounts. **Personal and team accounts** should connect straight to the QCode API through a **custom plugin** or a **workflow HTTP request node**, which can call both `claude-opus-5-5` (Anthropic API) and `gpt-6.2-sol` (OpenAI-compatible API); **enterprise flagship administrators** can connect `gpt-6.2-sol` and Chinese models natively in "Coze Coding (`code.coze.cn`) → Enterprise organization management → Model access → Custom model", but that entry is fixed to the OpenAI Chat Completions protocol and **does not support Claude**.

| Access path | Applies to | QCode models available | Endpoint address | Authentication |
|---|---|---|---|---|
| Custom plugin / workflow HTTP (Claude) | All Coze accounts | `claude-opus-5-5` and other Claude models | `https://api.qcode.cc/api/v1/messages` | Headers `x-api-key: cr_xxxxxxxx` and `anthropic-version: 2023-06-01` |
| Custom plugin / workflow HTTP (GPT / Chinese models) | All Coze accounts | `gpt-6.2-sol`, Chinese models | `https://api.qcode.cc/openai/v1/chat/completions` | Header `Authorization: Bearer cr_xxxxxxxx` |
| Native custom model (Coze Coding back office) | Enterprise flagship organization administrators only | `gpt-6.2-sol`, Chinese models (**no Claude support**) | `https://api.qcode.cc/openai/v1` (`/chat/completions` appended automatically) | Choose `Authorization` and fill in `cr_xxxxxxxx` (`Header` as the alternative) |

Checked on 2026-11-22 · Coze (coze.cn) and Coze Coding (code.coze.cn) · text-only structured guide


[Coze](https://www.coze.cn) is a cloud platform for building agents and workflows, with two interfaces: the main product "Coze" (`www.coze.cn`) and "Coze Coding" (`code.coze.cn`) for enterprises and low-code management. Before you start, know the four real product limits so you do not keep hunting for options that do not exist in the UI:

> **Real support and limit boundaries**:
> 1. **A Coze account is mandatory**: whether you use the web or the desktop app, you must sign in to a Coze platform account by phone number, email or QR code; there is no way to skip the platform account and work offline.
> 2. **The native "Model access" entry is for enterprise flagship administrators only**: according to Coze's official documentation, the native "Model access → Custom model" entry **is open only to Enterprise Flagship, and only the organization super administrator or an administrator can see and configure it**; ordinary personal accounts and ordinary workspaces do not see that entry.
> 3. **Native custom models do not support Claude**: the API protocol of a Coze native custom model is fixed to OpenAI Chat/completions and always requires the upstream to support streaming responses (`stream=true`); there is no Anthropic Messages protocol option. QCode's OpenAI-compatible endpoint does not accept Claude models, so `claude-opus-5-5` **can only be called through a custom plugin or a workflow HTTP request**.
> 4. **What the HTTP plugin / workflow approach can and cannot do**: when personal and team accounts call QCode over HTTP, QCode runs as an external tool of the agent or a workflow processing node; it cannot replace the agent's default main orchestration model, and the result only appears after the complete JSON response arrives (not native token-by-token streaming).


- **Applies to**: browser web app (`www.coze.cn` / `code.coze.cn`); optional Windows / macOS desktop app
- **Access path**: custom plugin / workflow HTTP request (all accounts); native custom model (enterprise flagship administrators only)
- **Content checked on**: 2026-11-22
- **Time needed**: 10–15 minutes
- **You will need**: a signed-in Coze account; a QCode API key starting with `cr_`



- You have registered for Coze and can sign in normally ([www.coze.cn](https://www.coze.cn)); if you plan to use native custom models, confirm that your organization is on **Enterprise Flagship**, that the current account is the **organization super administrator or an administrator**, and that Coze Coding ([code.coze.cn](https://code.coze.cn)) is accessible
- You have registered for QCode.cc and copied an API key starting with `cr_` from the [Dashboard](https://qcode.cc/en/dashboard). No account yet? [Sign up for QCode](https://qcode.cc/en/auth/sign-up?utm_source=docs.qcode.cc&utm_medium=tut_before&utm_campaign=knowledge_base&src=docs-ide-coze-before) first, pick a plan on the [pricing page](https://qcode.cc/en/pricing?utm_source=docs.qcode.cc&utm_medium=tut_before&utm_campaign=knowledge_base&src=docs-ide-coze-before), then create the key in the [Dashboard](https://qcode.cc/en/dashboard)
- You know which model you want to call: for `claude-opus-5-5` use **Path A (HTTP plugin / workflow)**; for `gpt-6.2-sol` or Chinese models, personal accounts use **Path A**, while enterprise flagship administrators can use **Path B (native custom model)**
- Your current network can reach `www.coze.cn`, `code.coze.cn`, `api.qcode.cc` and `probe.qcode.cc`


**Need an API key?**

If you do not have a QCode account yet, [Sign up for QCode](https://qcode.cc/en/auth/sign-up?utm_source=docs.qcode.cc&utm_medium=tut_key_step&utm_campaign=knowledge_base&src=docs-ide-coze-key) first. If you prefer to pay by usage, buy a [Pay-as-you-go Pack](https://qcode.cc/en/pay-as-you-go?utm_source=docs.qcode.cc&utm_medium=tut_key_step&utm_campaign=knowledge_base&src=docs-ide-coze-key) first, then create and copy the complete API key starting with `cr_` in the [Dashboard](https://qcode.cc/en/dashboard). You can pay by credit/debit card (Visa / Mastercard), Apple Pay / Google Pay, or cryptocurrency — see [Payment methods](/docs/reference/payment-methods).


## Prepare: confirm the entry point and choose an access path

Everything in Coze can be configured directly in the browser, with no dedicated desktop client to install. If you prefer the desktop app, you can only download the Windows or macOS installer by hovering over "Download desktop app" on the [Coze website](https://www.coze.cn) home page (Coze is not open-source desktop software, so there are no GitHub Releases, winget or Microsoft Store packages; after installation it opens in the Coze agent workspace, and configuring enterprise custom models still requires opening `code.coze.cn` in a browser).

Pick the path that matches your account edition and target model:

**Path A: personal / team accounts (custom plugin / HTTP request)**

- **Who it is for**: all Coze accounts (ordinary personal accounts, team workspaces, and enterprise users who need to call `claude-opus-5-5`).
- **Supported models**: both `claude-opus-5-5` (through the Anthropic endpoint `https://api.qcode.cc/api/v1/messages`) and `gpt-6.2-sol` plus Chinese models (through the OpenAI-compatible endpoint `https://api.qcode.cc/openai/v1/chat/completions`).
- **Steps**: complete **step 1 → step 2 → step 3 → step 4 → step 7** below (skip steps 5 and 6, which are for enterprise administrators only).


**Path B: enterprise flagship administrators (native custom model)**

- **Who it is for**: users whose organization is on Coze **Enterprise Flagship** and whose current account is the **organization super administrator or an administrator**.
- **Supported models**: `gpt-6.2-sol` and Chinese models (through `https://api.qcode.cc/openai/v1`); **Claude models are not supported** (the native Coze entry offers no Anthropic protocol).
- **Main advantage**: after you connect the model and authorize workspaces, members can switch to it in the model selector of the agent orchestration page just like a built-in model, with native streaming support.
- **Steps**: complete **step 1 → step 5 → step 6 → step 7** below (no need to configure the HTTP plugin from steps 2–4).


## Step-by-step setup



### Verify the QCode key and endpoint locally first

Before you open the Coze back office, send one minimal test request from a local terminal (Windows PowerShell, macOS Terminal or a Linux shell) to confirm that your `cr_` key and the target model work. That way, if Coze reports an error later, you can tell at once whether the problem is the Coze form configuration or the key itself.

Switch to the tab for the model family you plan to call, replace `cr_xxxxxxxx` with your real key and run:

**Verify Claude (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": "Hello, introduce yourself in one sentence"}
    ]
  }'
```


**Verify GPT (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": "Hello, introduce yourself in one sentence"}
    ]
  }'
```



Done right you will see: the terminal returns a complete piece of JSON; the `content[0].text` field of the Claude response, or the `choices[0].message.content` field of the GPT response, contains a self-introduction, and there is no `error` object.


**Stuck? The local test returns 401 or model_not_available_on_endpoint**

Check three things in order: 1) the key must start with `cr_` in full, with no extra newline or space after the quotes and colons; 2) `claude-opus-5-5` must request `https://api.qcode.cc/api/v1/messages` with the `x-api-key` header, and must not be sent to `/openai/v1`; 3) `gpt-6.2-sol` must request `https://api.qcode.cc/openai/v1/chat/completions` with `Authorization: Bearer cr_xxxxxxxx`. In Windows PowerShell, if single-quote escaping gets in the way, use `curl.exe` instead, or verify directly with the test feature of the Coze workflow HTTP node.




### Path A: put the QCode endpoint into a workflow HTTP node or a custom plugin

Sign in to the [Coze main site](https://www.coze.cn), enter the target workspace, and pick one of the two options that matches how you work:

- **Workflow HTTP request node (fastest to start)**: create or open a workflow, add an "HTTP request" node to the canvas, and set the request method to `POST`.
- **Custom plugin (easier to reuse across agents)**: go to the workspace's plugin / resource library page, create a custom plugin based on an existing HTTP service, then add a tool with the `POST` method.

Fill in the URL, the request headers (Headers) and the JSON request body (Body) in the matching tab below according to the model family you need. Here `{{user_prompt}}` stands for the text variable you defined in the Coze workflow input node or in the plugin's input parameters; when configuring for real, insert it with the variable picker that the Coze UI provides:

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

| Field | Value |
|---|---|
| Request method | `POST` |
| Full request URL | `https://api.qcode.cc/api/v1/messages` (if the plugin fills in base URL and path separately: base URL `https://api.qcode.cc/api`, path `/v1/messages`) |
| Header 1 | `Content-Type`: `application/json` |
| Header 2 | `x-api-key`: `cr_xxxxxxxx` (replace with your key, **without** the `Bearer ` prefix) |
| Header 3 | `anthropic-version`: `2023-06-01` |

Set the Body type to `JSON` and fill in:

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


**GPT / Chinese models (OpenAI-compatible · gpt-6.2-sol)**

| Field | Value |
|---|---|
| Request method | `POST` |
| Full request URL | `https://api.qcode.cc/openai/v1/chat/completions` (if the plugin fills in base URL and path separately: base URL `https://api.qcode.cc/openai/v1`, path `/chat/completions`) |
| Header 1 | `Content-Type`: `application/json` |
| Header 2 | `Authorization`: `Bearer cr_xxxxxxxx` (keep exactly one ASCII space between `Bearer` and the key) |

Set the Body type to `JSON` and fill in:

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

To switch to a Chinese model, just change `"model"` to a model ID that the OpenAI-compatible endpoint supports, such as `glm-5.3`, `kimi-k3`, `deepseek-v4-pro` or `qwen3.8-max`.



Done right you will see: the request method is `POST`, the URL matches the model family's protocol exactly, the key and version headers are all present, and the JSON editor shows no red syntax warning.


**Stuck? The JSON is flagged as malformed, or you do not know how to pass multi-turn history**

First make sure every quote is a straight ASCII double quote `"`, that there is no trailing comma after the last field, and that `"stream"` stays `false` (workflow HTTP nodes and plugins parse a single JSON response by default; turning streaming on makes the response body a series of `data:` lines that cannot be parsed). If the user input may contain double quotes or line breaks, pass it through the "JSON parameter binding / structured input parameters" of the Coze workflow or plugin instead of splicing unescaped long text straight into the JSON string.




### Path A: configure response field extraction and run a test

Once the HTTP request works, you need to extract the text from the returned JSON so that the downstream workflow output node or the agent can read it. The two protocols return different paths, so map the output parameters as shown for the endpoint you configured:

**Extract the Claude response (Anthropic format)**

Typical response structure:

```json
{
  "id": "msg_01...",
  "type": "message",
  "role": "assistant",
  "model": "claude-opus-5-5",
  "content": [
    {
      "type": "text",
      "text": "Hello, I am Claude. I can help you with reasoning, writing and programming tasks."
    }
  ],
  "usage": {
    "input_tokens": 18,
    "output_tokens": 32
  }
}
```

- **Text extraction path**: `content[0].text` (in a workflow, read `body.content[0].text` directly through a code node or the output parameter configuration).


**Extract the GPT / Chinese model response (OpenAI-compatible format)**

Typical response structure:

```json
{
  "id": "chatcmpl-...",
  "object": "chat.completion",
  "model": "gpt-6.2-sol",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hello, I can help you with Q&A, analysis and writing code."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 18,
    "completion_tokens": 24,
    "total_tokens": 42
  }
}
```

- **Text extraction path**: `choices[0].message.content` (read `body.choices[0].message.content` to get the plain-text answer).


Once the output parameters are configured, click "Test run / Debug" on the workflow or plugin tool, pass `Hello, introduce yourself in one sentence` as `user_prompt`, and watch the returned status code and the extracted text.


Done right you will see: the debug run returns HTTP status code `200`, and the output panel successfully extracts a plain-text reply without the outer JSON structure.


**Stuck? The test run times out, or the extracted output field is empty**

1) If the request times out, lower `max_tokens` (for example to `1024`) to test a short reply, and switch the URL domain from `api.qcode.cc` to the Asian node `asia.qcode.cc` (for example `https://asia.qcode.cc/api/v1/messages` or `https://asia.qcode.cc/openai/v1/chat/completions`); 2) if the status code is `200` but the extracted field is empty, expand the raw response body `body` and check whether you swapped `content[0].text` with `choices[0].message.content`, or forgot to parse the response body string into a JSON object first.




### Path A: publish it and bind it to a Coze agent

Once debugging passes, publish your custom plugin or workflow to the current workspace, then open the orchestration page of the target agent:

1. In the "Skills" area of the orchestration page, add the plugin or workflow you just published to the agent.
2. Write the trigger rules explicitly in "Persona and reply logic (system prompt)" so the Coze default model does not skip the plugin and answer on its own. For example:

```text
When the user asks for complex code, deep analysis, or explicitly asks for an answer from a QCode model, you must call the bound QCode plugin/workflow, pass the user's complete question into the `user_prompt` parameter, and present the tool's text result to the user accurately; do not make up an answer of your own.
```

After saving, send a message in the "Preview and debug" panel on the right that should trigger the rule (for example "Please call the QCode tool and introduce yourself in one sentence") and watch whether the debug trace actually triggers a plugin or workflow call.


Done right you will see: the call trace in the preview area shows an execution record for the plugin or workflow you bound, with a success status, and the chat bubble contains the reply returned by QCode.


**Stuck? The agent does not call the plugin and answers by itself**

Check three things first: 1) the plugin or workflow must have been published with "Publish" — a saved draft alone cannot be called reliably by the agent; 2) the English/Chinese description of the plugin tool and the description of the `user_prompt` parameter must state their purpose clearly so the orchestration model can recognize them; 3) if you want **every user turn to go through QCode instead of letting the default model decide**, switch the agent to workflow-driven mode so user input goes straight into a workflow that contains the QCode HTTP node.




### Path B (enterprise flagship administrators only): connect a native custom model in the Coze Coding back office

> This step and step 6 **apply only to the organization super administrator or an administrator of a Coze Enterprise Flagship organization**. If you are on an ordinary personal account, skip straight to step 7 to check the request log.

1. Open Coze Coding [code.coze.cn](https://code.coze.cn) in a browser and sign in with your enterprise administrator account.
2. Click the profile avatar at the bottom left of the page, select the **enterprise account** it belongs to, then click the "Settings" icon of that organization to open "Enterprise organization management".
3. In "Enterprise organization management" go to **"Model access → Custom model"** and click **"Connect model"**.
4. In the dialog, fill in the parameters as in the table below, then tick the model capabilities you need (such as tool calling, deep thinking) and the context length, and save:

| Form field | Value | Notes |
|---|---|---|
| Model display name | `QCode GPT 6.2 Sol` (you can change it) | Only affects the name members see in the UI |
| Model ID | `gpt-6.2-sol` | Written directly into the `model` field of the request; you can also use a Chinese model ID such as `glm-5.3`, **but never a Claude model** |
| Model API URL | `https://api.qcode.cc/openai/v1` | Coze appends `/chat/completions` automatically, so **do not** write `/chat/completions` yourself |
| API protocol | `OpenAI Chat/completions` | Fixed platform option, cannot be changed |
| Authentication | `Authorization` | The `Header` method is the alternative (see the collapsible hint below) |
| Auth key | `cr_xxxxxxxx` | Your QCode key; plaintext storage is fine, no need to hook up Volcengine KMS |


Done right you will see: after saving, you return to the "Custom model" list and the `QCode GPT 6.2 Sol` you just connected appears in it normally, with no suspended or error notice.


**Stuck? You cannot find "Model access", or the connection test reports 401 / 404**

- **"Model access" is completely missing**: confirm that the selected account is the enterprise account rather than a personal one, that the organization is on **Enterprise Flagship**, and that your role is organization super administrator or administrator. When those conditions are not met the entry is not shown, so use Path A instead.
- **It reports <code>404</code>**: check that "Model API URL" stops at `/openai/v1` and does not have an extra `/chat/completions` or trailing slash.
- **It reports <code>401</code> / authentication failure**: first confirm the key starts with `cr_` and has no extra spaces; if `Authorization` still returns `401`, choose the `Header` authentication method instead, put `Authorization` in Header Key and `Bearer cr_xxxxxxxx` in Header Value, then save and test again.




### Path B (enterprise flagship administrators only): authorize workspaces and select the model in an agent

After Coze connects a custom model, it is **unavailable to every workspace by default**; an administrator must turn the authorization on before members can see it:

1. Stay in the "Enterprise organization management → Model access → Custom model" list, find the model you just connected and click **"… → Edit available spaces"** on the right of that row.
2. In the dialog, switch on the target workspace and save.
3. Go back to the Coze agent orchestration page (or have a member of the target workspace open it), open the model selector and pick the `QCode GPT 6.2 Sol` you just connected from the **"Custom model"** group.
4. Type `Hello, introduce yourself in one sentence` into the panel on the right and send it, and watch whether the streamed reply arrives token by token.


Done right you will see: the availability switch for the target workspace is on; the model can be selected in the "Custom model" group of the agent's model list, and after sending a message it replies with normal streaming and no `401`, `404` or `model not found` error.


**Stuck? Members cannot see the model, or a message spins forever with no reply**

- **Members cannot see the model**: go back to "Edit available spaces" and confirm you selected the workspace the member is actually in, then have the member reload the orchestration page.
- **It says the model does not exist**: check whether "Model ID" was filled in with the display name by mistake (for example `QCode GPT 6.2 Sol`); it must be a model ID that QCode actually supports (such as `gpt-6.2-sol`).
- **Sending a message spins forever**: Coze native custom models always call the upstream in streaming mode (`stream=true`); confirm the URL is `https://api.qcode.cc/openai/v1` (in mainland China you can also use `https://asia.qcode.cc/openai/v1`) and that enterprise egress policies are not blocking it.




### Check the request log at probe.qcode.cc

Whichever path you took, A or B, finish by checking the real gateway log once to confirm the reply really came from QCode and was not answered by a built-in Coze model:

1. Open [probe.qcode.cc](https://probe.qcode.cc/) in a browser.
2. Paste the same `cr_` API key you used in Coze and click "Query".
3. Scroll down to the request list and check that the request time of the newest record matches the moment you just debugged or chatted in Coze, and that the status code column shows `200`.


Done right you will see: a record at the top of the request list whose time matches your test, with status `200` and the corresponding time-to-first-token and total time figures.




## Verify success

Check the items below; if they all match, Coze is reliably connected to QCode:

- The local test command returns `200` and valid text for both `claude-opus-5-5` and `gpt-6.2-sol`;
- **Path A**: the Coze workflow HTTP node or custom plugin test run returns `200`, `content[0].text` (Claude) or `choices[0].message.content` (GPT / Chinese models) is extracted successfully, and the agent preview area shows a successful tool call;
- **Path B**: the Enterprise Flagship "Custom model" is in a normal state, the target workspace switch is on, and members receive a streaming reply after selecting `gpt-6.2-sol` in the "Custom model" group of the agent;
- At [probe.qcode.cc](https://probe.qcode.cc/) the same key shows a request record at the matching time with status code `200`.


### All done

You have connected QCode to Coze and you now know exactly where the custom plugin / HTTP request path ends and the enterprise native custom model path begins. From here you can:

- [Endpoints and API formats](/docs/getting-started/endpoints-and-api-paths)
- [Chinese model access](/docs/usage/cn-models)
- [Billing](/docs/reference/billing)
- [Troubleshooting](/docs/reference/troubleshooting)
- Next: compare the plans on the [pricing page](https://qcode.cc/en/pricing?utm_source=docs.qcode.cc&utm_medium=tut_done&utm_campaign=knowledge_base&src=docs-ide-coze-done)
- Go back to your [Dashboard](https://qcode.cc/en/dashboard) to check usage and balance


## Common errors

| Error / what you see | Why | What to do |
|---|---|---|
| The "Model access → Custom model" entry is missing | Native custom models are open only to the organization super administrator or an administrator of an Enterprise Flagship organization; ordinary personal accounts have no such menu | Confirm you switched to the enterprise account and that Enterprise Flagship is active; for personal or ordinary team accounts use **Path A (custom plugin / workflow HTTP request)** from this tutorial |
| `model_not_available_on_endpoint` | `claude-opus-5-5` was put into the OpenAI-compatible endpoint (`/openai/v1`) or into a Coze native custom model | QCode's OpenAI-compatible endpoint does not accept Claude. To call `claude-opus-5-5` you must go over HTTP straight to the Anthropic endpoint `https://api.qcode.cc/api/v1/messages`; a Coze native custom model can only hold `gpt-6.2-sol` or a Chinese model |
| `404 Not Found` | The URL path does not match: a native custom model has an extra `/chat/completions`, or an HTTP plugin is missing the path suffix | For a native custom model, "Model API URL" stops at `https://api.qcode.cc/openai/v1` (Coze appends `/chat/completions` itself); for an HTTP request node you must enter the full address (`/api/v1/messages` or `/openai/v1/chat/completions`) |
| `401 Unauthorized` / authentication failure | The key is incomplete, has leading or trailing spaces, or the auth header format does not match the API protocol | Check that the key starts with `cr_` in full; the Anthropic API uses `x-api-key: cr_...` plus `anthropic-version: 2023-06-01`; the OpenAI-compatible HTTP API uses `Authorization: Bearer cr_...`; if a native custom model still returns 401 with `Authorization`, try `Header` authentication with `Bearer cr_...` written by hand |
| `Model not found` / model does not exist | A custom display name was put into the model ID, or the model name is misspelled | Check "Model ID" or the `"model"` field in the JSON and use a model ID QCode actually supports (such as `claude-opus-5-5`, `gpt-6.2-sol`, `glm-5.3`) |
| The HTTP node fails to parse JSON, or a native conversation spins forever | The streaming setting is the opposite of what the scenario needs: an HTTP node receives an SSE stream it cannot parse as ordinary JSON, or the enterprise native path is blocked by the network | The HTTP plugin / workflow request body must explicitly set `"stream": false`; enterprise native custom models always use `stream=true`, so confirm the network reaches `api.qcode.cc` reliably or try `asia.qcode.cc` |
| Members cannot see the newly connected custom model in the agent model list | A newly connected model in the enterprise back office is off for all workspaces by default | An administrator goes back to the "Custom model" list, clicks "… → Edit available spaces" on the right of that model, and manually turns on the target workspace switch |

## FAQ

### What happens when my key expires?

There are two cases:

- A **personal plan** key cannot be renewed when it expires; you can only reopen a plan and use a new key;
- For a **pay-as-you-go pack**, buy a new pack after the key expires and the same key starts working again, with no change to any Coze configuration.

If you switch to a new key, update the key in the request headers of the Coze custom plugin / workflow HTTP node (Path A), or edit the auth key of the corresponding model in "Coze Coding → Enterprise organization management → Model access → Custom model" (Path B).

### Why can an ordinary personal account not simply replace the Coze agent's default model?

That is a permission and product-design limit of the Coze platform itself: the native "Custom model" entry is currently open only to the super administrator and administrators of Enterprise Flagship organizations, and a personal account back office has no custom model Base URL setting. A personal account that wants to use QCode in Coze can connect it as a tool or processing node through a custom plugin or a workflow HTTP request node.

### Why can `claude-opus-5-5` not be connected in the Enterprise Flagship "Custom model"?

The API protocol of the Coze native "Custom model" is fixed to OpenAI Chat/completions, and the platform offers no Anthropic Messages protocol option; QCode's OpenAI-compatible endpoint serves only GPT and Chinese models and does not accept Claude requests. So enterprise users who need `claude-opus-5-5` in Coze also have to go through a custom plugin or a workflow HTTP request node straight to `https://api.qcode.cc/api/v1/messages`.

### What should I do when a workflow HTTP request occasionally times out?

Check three things: 1) switch the request domain from the global node `api.qcode.cc` to the Asian node `asia.qcode.cc` (a closer route, and the same key works); 2) keep `max_tokens` reasonable in the request body (for example `1024`–`2048`) and shorten the prompt to cut per-request generation time; 3) raise the timeout setting of the workflow HTTP node so long replies are not truncated early by the Coze node.

### Does Coze require downloading a desktop app? Is there an open-source installer?

No. Whether you are configuring a custom plugin, building a workflow, or managing enterprise custom models on `code.coze.cn`, the browser web app is all you need. Coze does offer Windows and macOS desktop apps, but they are not open source: there are no GitHub Releases, winget or Microsoft Store packages — you can only get them from "Download desktop app" on the [www.coze.cn](https://www.coze.cn) website.

## Access overview and available models

### QCode nodes and protocol addresses

The three access domains have identical capabilities and share the same `cr_` key, so pick whichever suits the network Coze runs in:

| Node | Anthropic API (Path A HTTP requests only) | OpenAI-compatible Base URL (Path A adds `/chat/completions`; Path B stops here) |
|---|---|---|
| Global | `https://api.qcode.cc/api/v1/messages` | `https://api.qcode.cc/openai/v1` |
| Asia (first choice in mainland China) | `https://asia.qcode.cc/api/v1/messages` | `https://asia.qcode.cc/openai/v1` |
| North America / Europe | `https://us.qcode.cc/api/v1/messages` | `https://us.qcode.cc/openai/v1` |

### Recommended models and the matching Coze path

| Model | Model ID | Applicable path | Protocol endpoint |
|---|---|---|---|
| Claude Opus 5.5 | `claude-opus-5-5` | Path A only (custom plugin / workflow HTTP) | Anthropic (`/api/v1/messages`) |
| GPT 6.2 Sol | `gpt-6.2-sol` | Both Path A and Path B (enterprise native custom model) | OpenAI-compatible (`/openai/v1`) |
| Main Chinese models | `glm-5.3`, `kimi-k3`, `deepseek-v4-pro`, `qwen3.8-max` and others | Both Path A and Path B | OpenAI-compatible (`/openai/v1`) |

> QCode does not currently offer Gemini models, so choose Claude, GPT or a Chinese model in Coze. See [Chinese model access](/docs/usage/cn-models) for the full list of Chinese model IDs, and [qcode.cc/models](https://qcode.cc/en/models) for the models on sale at any moment.

## Related docs

- [Endpoints and API formats](/docs/getting-started/endpoints-and-api-paths) — the source-of-truth table of protocol × model family
- [Chinese model access](/docs/usage/cn-models) — the list of Chinese models available on the OpenAI-compatible endpoint
- [Billing](/docs/reference/billing) — plan and pay-as-you-go pack billing rules
- [Troubleshooting](/docs/reference/troubleshooting) — common status codes and network connectivity checks
- [Coze official custom model documentation](https://docs.coze.cn/guides/deploy_custom_model) — the official description of native access for Enterprise Flagship