Chat Completions

POST https://models.mixlayer.ai/v1/chat/completions

Generate a chat completion from one of the available models. Mixlayer’s API is OpenAI-compatible, so existing OpenAI client libraries work without modification — see Client Libraries for examples in Python, TypeScript, Rust, and curl.

This page is the canonical reference for every supported request parameter.

Authentication

Every request requires a Bearer token in the Authorization header. Create one in the Mixlayer console.

Authorization: Bearer $MIXLAYER_API_KEY

Minimal request

curl https://models.mixlayer.ai/v1/chat/completions \
  -H "Authorization: Bearer $MIXLAYER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen/qwen3.5-4b-free",
    "messages": [
      {"role": "user", "content": "Hello!"}
    ]
  }'

Messages

The messages field is a list of message objects in turn order. Each message has a role and content.

Assistant messages from previous turns may also include reasoning_content from a thinking-mode response — see Reasoning.

Sampling parameters

Sampling parameters control how the model selects each next token.

Sampling defaults vary by model. See the per-model notes for recommended settings — for example, Qwen 3.5 has different recommended values for thinking mode vs. instruct mode.

Penalty parameters

Penalty parameters discourage the model from repeating tokens.

Output control

Response format

Use response_format to constrain the model’s output structure.

{ "response_format": { "type": "text" } }

Example of a constrained JSON schema response:

{
  "response_format": {
    "type": "json_schema",
    "json_schema": {
      "schema": {
        "type": "object",
        "properties": {
          "city": { "type": "string" },
          "country": { "type": "string" }
        },
        "required": ["city", "country"]
      },
      "strict": true
    }
  }
}

Tool calling

Pass an array of tools the model can invoke. See the Tool Calling guide for the full request/response loop.

{
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Get the current weather for a city.",
        "parameters": {
          "type": "object",
          "properties": { "city": { "type": "string" } },
          "required": ["city"]
        }
      }
    }
  ]
}

Reasoning

Pass thinking: true (or reasoning_effort: "low" | "medium" | "high") to enable extended chain-of-thought reasoning on supported models. Reasoning is returned in a separate reasoning_content field on the assistant message — see the Reasoning guide.

Streaming

When stream: true, the response is a stream of chat.completion.chunk events delivered as Server-Sent Events. Each event has the same envelope as a non-streaming response, but choices[].message is replaced with choices[].delta, which contains only the new content for that chunk.

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

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

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

data: [DONE]

The delta object contains whichever fields are new in that chunk:

• role — present only on the first chunk
• content — incremental visible text
• reasoning_content — incremental reasoning text (thinking mode only)
• tool_calls — incremental tool call data (when the model invokes a tool)

finish_reason is null until the final chunk. Possible terminal values:

A streaming example in your language of choice:

curl https://models.mixlayer.ai/v1/chat/completions \
  -H "Authorization: Bearer $MIXLAYER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen/qwen3.5-4b-free",
    "stream": true,
    "messages": [{"role": "user", "content": "Count to five."}]
  }'

import os
from openai import OpenAI
 
client = OpenAI(
    api_key=os.environ["MIXLAYER_API_KEY"],
    base_url="https://models.mixlayer.ai/v1",
)
 
stream = client.chat.completions.create(
    model="qwen/qwen3.5-4b-free",
    messages=[{"role": "user", "content": "Count to five."}],
    stream=True,
)
 
for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

import OpenAI from "openai";
 
const openai = new OpenAI({
  apiKey: process.env["MIXLAYER_API_KEY"]!,
  baseURL: "https://models.mixlayer.ai/v1",
});
 
const stream = await openai.chat.completions.create({
  model: "qwen/qwen3.5-4b-free",
  messages: [{ role: "user", content: "Count to five." }],
  stream: true,
});
 
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0].delta.content ?? "");
}

use async_openai::{config::OpenAIConfig, types::CreateChatCompletionRequestArgs, Client};
use futures::StreamExt;
 
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = OpenAIConfig::new()
        .with_api_key(std::env::var("MIXLAYER_API_KEY")?)
        .with_api_base("https://models.mixlayer.ai/v1");
    let client = Client::with_config(config);
 
    let request = CreateChatCompletionRequestArgs::default()
        .model("qwen/qwen3.5-4b-free")
        .messages([async_openai::types::ChatCompletionRequestMessage::User(
            "Count to five.".into(),
        )])
        .stream(true)
        .build()?;
 
    let mut stream = client.chat().create_stream(request).await?;
    while let Some(result) = stream.next().await {
        if let Some(content) = &result?.choices[0].delta.content {
            print!("{content}");
        }
    }
    Ok(())
}

Response shape

A non-streaming response:

{
  "id": "chatcmpl-abc123...",
  "object": "chat.completion",
  "created": 1735689600,
  "model": "qwen/qwen3.5-4b-free",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Chihuahuas have the largest brain-to-body ratio of any dog breed."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 14,
    "completion_tokens": 17,
    "total_tokens": 31
  }
}

When the model invokes a tool, message.content will be empty and message.tool_calls will contain the call. When thinking mode is enabled, message.reasoning_content will hold the model’s chain of thought.

OpenAI compatibility notes

The following standard OpenAI parameters are not currently supported by Mixlayer. Requests that include them are accepted and silently ignored:

• n — multiple completions per request
• min_p — minimum probability sampling
• tool_choice — forcing a specific tool selection (the model decides automatically based on tools)
• logprobs, top_logprobs
• user
• logit_bias

If your application depends on any of these, open an issue or reach out on Discord.

Errors

Errors follow OpenAI’s error envelope:

{
  "error": {
    "message": "Model not found.",
    "type": "model_not_found",
    "code": "model_not_found"
  }
}