OpenAI protocol: Chat Completions

Use OpenAI Chat Completions as one interface for text models from OpenAI, Google Gemini, DeepSeek, Qwen, and other vendors. Send messages and read the reply from choices[0].message.content.

Item	Details
Endpoint	`POST https://api.laozhang.ai/v1/chat/completions`
Models	Those the model catalog marks as OpenAI-compatible under Endpoints; select one with `model`
Streaming	Set `"stream": true` to receive the reply as it is generated
Example model	`gpt-5.4-mini`

Optional parameters and tool support vary by model. If your application is built on Anthropic Messages or Gemini generateContent request structures, use the Claude protocol or Gemini protocol page instead. The Text generation API guide compares the three formats.

POST https://api.laozhang.ai/v1/chat/completions

Make a request

Create an API key in Token management in the default group, with its billing mode set to Usage first (按量优先, recommended) or Usage-based (按量计费), and export it in your terminal:

export LAOZHANG_API_KEY="YOUR_LAOZHANG_API_KEY"

Requests use Authorization: Bearer authentication and a JSON body containing model and messages. The examples use gpt-5.4-mini.

cURL
Python

curl --fail-with-body --max-time 120 \
  "https://api.laozhang.ai/v1/chat/completions" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.4-mini",
    "messages": [
      {"role": "user", "content": "Reply only with: connected"}
    ]
  }'

Install the SDK with python -m pip install openai.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["LAOZHANG_API_KEY"],
    base_url="https://api.laozhang.ai/v1",
    timeout=120.0,
    max_retries=0,
)
response = client.chat.completions.create(
    model="gpt-5.4-mini",
    messages=[{"role": "user", "content": "Reply only with: connected"}],
)
print(response.choices[0].message.content)

The reply to this prompt should be connected. Replace the prompt with your application’s message once the client is configured.

Choose a model

Pick the model in the model catalog. Before you change the model value, check three things in the model’s row:

Endpoints includes OpenAI-compatible. A model that lists only Responses, such as the o3-pro series, needs /v1/responses instead; see the Responses API examples.
Token groups includes the group of your API key. Use a default-group key for this endpoint: Claude Code-group keys are for the Claude protocol only, and features such as tool calls are not guaranteed to work when they send Chat Completions requests.
Input, Output, and Cache read prices per 1M tokens fit your workload.

Common text models in the catalog include:

gpt-5.4-mini and gpt-5.4
gemini-3.8-flash, gemini-3.6-flash, and gemini-3.5-flash-lite

Copy the exact ID from the catalog or console rather than building it from a product name. The Text generation API guide lists the formats and prices of these models, and OpenAI models shows how to call the Responses-only o3-pro. A general ranking will not tell you which model suits your application. Run a sample of your own prompts through two or three candidates and compare answer quality, instruction following, structured output, tool-call success if you use tools, latency, and the token usage recorded for each request. Pin the chosen model ID in your configuration so that a model change is a deliberate update.

Request fields

Field	Description
`model`	Required. Exact model ID available to your token group.
`messages`	Required. Messages in conversation order.
`stream`	Optional. `true` returns the reply as server-sent events; see Stream a response.
`temperature`, `top_p`	Optional sampling controls, where supported by the model.
`max_completion_tokens`	Output limit for models that accept this field.
`max_tokens`	Output limit used by some models; do not send both limit fields. Claude models read only this field and stop at 4,096 tokens when it is missing.
`response_format`	Output-format settings for models with JSON or structured-output support.
`tools`, `tool_choice`	Tool definitions and selection settings for models with tool-calling support.

Start with model and messages. Optional fields and accepted values depend on the model; a request rejected for an unsupported parameter needs a field change before you retry it. See the official Chat Completions reference for upstream field definitions.

Messages and conversation history

Each message has a role and content. Use user for user input and assistant for previous model replies. Send the history your application needs with each request:

[
  {"role": "user", "content": "My project is called Cedar."},
  {"role": "assistant", "content": "How can I help with Cedar?"},
  {"role": "user", "content": "Suggest a short tagline for it."}
]

Instruction roles such as system or developer, tool messages, and multimodal content depend on the selected model. To send images to a vision model, see the Image understanding API.

Read the response

A text response contains a choices array. This shortened example shows the fields to read:

{
  "choices": [
    {
      "index": 0,
      "message": {"role": "assistant", "content": "connected"},
      "finish_reason": "stop"
    }
  ]
}

Read message.content for the answer and finish_reason to see why generation ended. A length finish reason means the reply reached an output or context limit; shorten the input or adjust the model’s supported output limit if you need a complete answer. For a model that supports tool calls, the reply may contain message.tool_calls instead of ordinary text. Preserve those calls and their matching results when continuing the conversation. Token counts may appear in usage; use call logs to review account charges.

Stream a response

Add "stream": true to receive the reply in pieces as the model writes it. The response is a stream of server-sent events:

Each data: line carries a chat.completion.chunk object.
The new text is in choices[0].delta.content.
The stream ends with a data: [DONE] line.

cURL
Python

-N turns off cURL’s output buffering so that each chunk prints as soon as it arrives.

curl --fail-with-body -N --max-time 300 \
  "https://api.laozhang.ai/v1/chat/completions" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.4-mini",
    "stream": true,
    "messages": [
      {"role": "user", "content": "Give three short tips for naming variables."}
    ]
  }'

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["LAOZHANG_API_KEY"],
    base_url="https://api.laozhang.ai/v1",
    timeout=300.0,
    max_retries=0,
)
stream = client.chat.completions.create(
    model="gpt-5.4-mini",
    messages=[{"role": "user", "content": "Give three short tips for naming variables."}],
    stream=True,
)
for chunk in stream:
    if not chunk.choices:
        continue
    text = chunk.choices[0].delta.content
    if text:
        print(text, end="", flush=True)
print()

The raw stream looks like this, shortened to the fields you need; real chunks also carry fields such as id and model:

data: {"object":"chat.completion.chunk","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}

data: {"object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"1. Name variables"},"finish_reason":null}]}

data: {"object":"chat.completion.chunk","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}

data: [DONE]

When you read the stream:

Append each delta.content in order to rebuild the full reply.
The first chunk may carry only the role, and some chunks, such as a final usage chunk, can have an empty choices array, so check before you read.
The last content chunk sets finish_reason; data: [DONE] then closes the stream, and the Python SDK ends the loop at that point.
If the connection drops before [DONE], treat the reply as incomplete.

Handle errors

Status	Action
400	Correct invalid fields, field types, or an input that exceeds the model’s limit.
401	Check the Bearer header and API key.
403	Check token-group permissions and account restrictions.
404	Check the endpoint and exact model ID.
429	Read the error body for rate, concurrency, capacity, or balance limits.
5xx	Check call logs and retry temporary failures with bounded backoff.

For a client timeout, check whether the request appears in call logs before sending it again. The Python examples disable automatic retries; add retry handling deliberately in your application. When contacting support, include the request time, endpoint, model, token group, and error message with credentials removed. Never send your API key.

Get started

Image Generation & Editing APIs

Video Generation APIs

Text APIs

Multimodal & Audio APIs

OpenAI protocol: Chat Completions

Make a request

Choose a model

Request fields

Messages and conversation history

Read the response

Stream a response

Handle errors

​Make a request

​Choose a model

​Request fields

​Messages and conversation history

​Read the response

​Stream a response

​Handle errors

​Related documentation

Make a request

Choose a model

Request fields

Messages and conversation history

Read the response

Stream a response

Handle errors

Related documentation