Chat Completions API

Inference Space provides the OpenAI-compatible chat completion endpoint POST /v1/chat/completions across the LLM model families in the catalog, including Claude, GPT, Gemini, DeepSeek, Qwen, and Kimi. Existing OpenAI-compatible clients can connect by changing only the Base, Key, and model; no application-code rewrite is required.

The private deployment API is identical; only the Base domain needs to change → Enterprise private deployment.

Overview

• Endpoint: POST https://ai.inf.space/v1/chat/completions
• Base: https://ai.inf.space/v1 (the browser console shares the ai.inf.space host; use the /v1 path for API requests)
• Protocol: OpenAI Chat Completions compatible, with request and response fields matching OpenAI
• Multiple models: Select an upstream with model + provider using the same Key and endpoint

Authentication

Authenticate with the HTTP header Authorization: Bearer <gk_...>. API Keys start with gk_ and are created in the console. The request body is application/json.

Authorization: Bearer gk_xxxxxxxxxxxxxxxx
Content-Type: application/json

In production, keep the Key on the server and do not expose it to browsers or clients.

Provider is required

Inference Space uses strict routing: every request must explicitly specify an upstream provider, with no implicit fallback. Use one of these three declaration methods, in descending priority:

1. URL query parameter ?provider=X (required for OpenRouter because its body.provider field is preserved as an upstream routing object)
2. Request header X-Provider: X (useful for clients such as sandbox CLIs that cannot append a query string to base_url)
3. Request body field body.provider

If the provider is missing or unknown, the API returns 400 with an OpenAI-style invalid_request_error body:

{
  "error": {
    "message": "'provider' is required: pass it via ?provider=X or body.provider (valid: anthropic, deepseek, ...)",
    "type": "invalid_request_error"
  }
}

Routable LLM providers

The publicly routable providers are:

Available providers and models depend on console settings and organization authorization.

Gemini models

Route Google Gemini with provider=gemini. Model IDs match Google's official IDs; requests and responses pass through the OpenAI-compatible protocol unchanged:

Basic request

curl "https://ai.inf.space/v1/chat/completions?provider=anthropic" \
  -H "Authorization: Bearer $TOS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-x",
    "messages": [
      { "role": "system", "content": "You are a concise assistant." },
      { "role": "user", "content": "Introduce yourself in three sentences." }
    ]
  }'

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://ai.inf.space/v1",
    api_key=os.environ["TOS_API_KEY"],
)

resp = client.chat.completions.create(
    model="claude-sonnet-4-x",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Introduce yourself in three sentences."},
    ],
    extra_query={"provider": "anthropic"},
)
print(resp.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://ai.inf.space/v1",
  apiKey: process.env.TOS_API_KEY,
});

const resp = await client.chat.completions.create(
  {
    model: "claude-sonnet-4-x",
    messages: [
      { role: "system", content: "You are a concise assistant." },
      { role: "user", content: "Introduce yourself in three sentences." },
    ],
  },
  { query: { provider: "anthropic" } },
);
console.log(resp.choices[0].message.content);

Parameters

The standard OpenAI fields are supported:

Streaming

With stream: true, the response is returned as Server-Sent Events (SSE) chunks. Each chunk is the OpenAI-standard chat.completion.chunk; incremental text is in choices[0].delta.content, and the stream ends with data: [DONE].

curl "https://ai.inf.space/v1/chat/completions?provider=anthropic" \
  -H "Authorization: Bearer $TOS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-x",
    "stream": true,
    "messages": [
      { "role": "user", "content": "Write a short poem about clouds." }
    ]
  }'

The final usage chunk looks like this:

{
  "id": "chatcmpl-xxx",
  "object": "chat.completion.chunk",
  "choices": [],
  "usage": {
    "prompt_tokens": 24,
    "completion_tokens": 38,
    "total_tokens": 62
  }
}

Tool calls

Declare callable functions with tools. When needed, the model returns tool_calls. After the application executes a tool, add its result as a role: "tool" message in the next messages turn so the model can produce the final answer.

curl "https://ai.inf.space/v1/chat/completions?provider=anthropic" \
  -H "Authorization: Bearer $TOS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-x",
    "tools": [
      {
        "type": "function",
        "function": {
          "name": "get_weather",
            "description": "Get the weather for a specified city",
          "parameters": {
            "type": "object",
            "properties": {
              "city": { "type": "string", "description": "City name" }
            },
            "required": ["city"]
          }
        }
      }
    ],
    "tool_choice": "auto",
    "messages": [
      { "role": "user", "content": "What is the weather like in Hefei today?" }
    ]
  }'

Responses and usage

The non-streaming response uses the standard OpenAI structure:

{
  "id": "chatcmpl-xxx",
  "object": "chat.completion",
  "model": "claude-sonnet-4-x",
  "choices": [
    {
      "index": 0,
      "message": { "role": "assistant", "content": "Hello, I am a concise assistant." },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 24,
    "completion_tokens": 38,
    "total_tokens": 62
  }
}

Billing is based on input and output tokens in usage, in units of 1M tokens. Exact prices, available models, and discounts depend on console and organization pricing; organization-specific prices and contract discounts take precedence.

Related pages

• Messages API (native Anthropic)
• Responses API (OpenAI-compatible)
• Authentication