OpenAI-Compatible API Documentation

First free call

Register and verify your email, or sign in with Google. No card or recharge is required.
Open API Keys, create a key that allows qwen/qwen3.8-27b and save the secret shown once.
Run this in Bash (macOS, Linux or WSL) with cURL and Python 3. Replace your-api-key with your key. Keep response.json local.

Bash · Qwen3.8-27B · $0

export ITERACOMPUTE_API_KEY="your-api-key"

curl --fail-with-body --max-time 180 https://api.iteracompute.com/v1/chat/completions \
  -H "Authorization: Bearer $ITERACOMPUTE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"qwen/qwen3.8-27b","messages":[{"role":"user","content":"Reply with exactly: Hello!"}],"max_tokens":512,"chat_template_kwargs":{"enable_thinking":false}}' \
  -o response.json && python3 -c 'import json; r=json.load(open("response.json")); text=r["choices"][0]["message"]["content"]; assert text and text.strip(), "Empty model reply: activation is incomplete"; print(text)'

Success means a non-empty choices[0].message.content. This command prints it and fails on an empty reply; registration or HTTP 200 alone does not complete activation. Expected output: Hello! (wording may vary).

This Qwen example disables thinking for a short visible reply. 401/403: check the key and model permission. 429: check monthly usage and TPM in the Console, then honor Retry-After. Free capacity may queue; do not fire repeated parallel retries.

API quickstart → · Free allowance and limits →

Model support and costs

The advanced examples below use paid DeepSeek V4.1 Flash and deduct usage from your API balance. Check current input, cached-input and output prices on the Models page. Free Qwen3.8-27B supports Chat Completions, streaming and tool calling; this guide does not establish Qwen Responses API support. Model IDs and reasoning parameters are not interchangeable. Confirm the selected model supports each endpoint and option before adapting an example.

DeepSeek V4.1 Flash pricing →

1. Overview

The IteraCompute API is OpenAI-compatible: if your application already talks to the OpenAI API, migrating is a change of base_url and API key. Chat completions, Responses, streaming and tool calling follow compatible formats where the selected model supports them.

2. Base URL & Authentication

API requests go to https://api.iteracompute.com/v1. Chat Completions and Responses requests authenticate with your API key in the Authorization header.

export ITERACOMPUTE_API_KEY="your-api-key"

curl --fail-with-body https://api.iteracompute.com/v1/chat/completions \
  -H "Authorization: Bearer $ITERACOMPUTE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"deepseek/deepseek-v4.1-flash","messages":[{"role":"user","content":"Reply with exactly: Hello!"}],"temperature":0,"max_tokens":128}'

3. Model IDs

Use the exact provider/model ID returned by the Models endpoint; do not add an iteracompute/ prefix. List the models currently published by the gateway:

curl --fail-with-body https://api.iteracompute.com/v1/models

The Models endpoint is public and returns the current gateway catalog. Use its id values exactly as returned. Commercial access to a model is still controlled by your API key and agreement.

4. Chat Completions

POST /v1/chat/completions follows the OpenAI request and response format:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.iteracompute.com/v1",
    api_key=os.environ["ITERACOMPUTE_API_KEY"],
)

resp = client.chat.completions.create(
    model="deepseek/deepseek-v4.1-flash",
    messages=[{"role": "user", "content": "Reply with exactly: Hello!"}],
    temperature=0,
    max_tokens=128,
)

print(resp.choices[0].message.content)
print(resp.usage)  # prompt_tokens / completion_tokens / total_tokens

5. Responses API

POST /v1/responses supports the OpenAI Responses API used by clients such as Codex:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.iteracompute.com/v1",
    api_key=os.environ["ITERACOMPUTE_API_KEY"],
)

response = client.responses.create(
    model="deepseek/deepseek-v4.1-flash",
    input="Reply with exactly: Hello!",
    max_output_tokens=128,
)
print(response.output_text)

6. Streaming (SSE)

Set "stream": true to receive server-sent events. Chunks arrive as generated; token usage is included in the final chunk that carries usage, before the terminal [DONE] event. Treat the stream as one logical request: once tokens have been emitted, the request is not retried transparently.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.iteracompute.com/v1",
    api_key=os.environ["ITERACOMPUTE_API_KEY"],
)

stream = client.chat.completions.create(
    model="deepseek/deepseek-v4.1-flash",
    messages=[{"role": "user", "content": "Reply with exactly: Hello!"}],
    stream=True,
    stream_options={"include_usage": True},
    temperature=0,
    max_tokens=128,
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")
    if chunk.usage:  # final chunk: token usage
        print("\n", chunk.usage)

7. Tool Calling

Tools are declared in the tools parameter, following the OpenAI function-calling format. When the model decides to call a tool, the response contains tool_calls; send tool results back with role "tool" to continue the conversation.

import json
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.iteracompute.com/v1",
    api_key=os.environ["ITERACOMPUTE_API_KEY"],
)

messages = [{"role": "user", "content": "What is the weather in Singapore?"}]
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]

resp = client.chat.completions.create(
    model="deepseek/deepseek-v4.1-flash",
    messages=messages,
    tools=tools,
    tool_choice={"type": "function", "function": {"name": "get_weather"}},
    max_tokens=512,
)

assistant_message = resp.choices[0].message
messages.append(assistant_message)

for call in assistant_message.tool_calls or []:
    arguments = json.loads(call.function.arguments)
    result = {"city": arguments["city"], "temperature_c": 29}
    messages.append({
        "role": "tool",
        "tool_call_id": call.id,
        "content": json.dumps(result),
    })

final = client.chat.completions.create(
    model="deepseek/deepseek-v4.1-flash",
    messages=messages,
    tools=tools,
    max_tokens=512,
)
print(final.choices[0].message.content)

8. Error Codes

Errors use the OpenAI error format with a JSON body of {"error": {"message", "type", "code"}}:

Status	Meaning
400	Invalid request - malformed JSON or missing required parameters
401	Authentication failed - missing or invalid API key
403	Key not permitted for this model or action
404	Unknown model or endpoint
429	Rate limit exceeded - slow down and honor Retry-After
500	Internal error - safe to retry the request
503	Model temporarily unavailable - retry with backoff

9. Rate Limits

Qwen3.8-27B uses account-wide monthly allowances and TPM. Free / Starter / Pro provide 30M / 100M / 300M tokens per UTC calendar month, 160K / 300K / 600K TPM and 128K / 128K / 256K context. Net completed recharge of $10 or $50 unlocks Starter or Pro. Free accounts may queue when GPU capacity is busy, with up to 32 waiting requests per GPU and 120 seconds of waiting. Other models use their key limits. Exhausted allowances, full queues and timeouts return 429; honor Retry-After before retrying.

10. Support

Integration questions: support@iteracompute.com