Call the API in one minute.

1. 1. Create an account. No credit card, no invite — sign-up is open at inferway.ai.
2. 2. Copy a key. A Default key is created on your first visit to the Console and shown once. Rotate or add keys anytime under API keys.
3. 3. Run the request. Set $INFERWAY_API_KEY and run the streaming command below.
4. 4. Verify it worked. Check status, latency, tokens, and model in Console → Requests.

First request

export INFERWAY_API_KEY="inferway_live_..."

curl 'https://api.inferway.ai/v1/chat/completions' \
  -H "Authorization: Bearer $INFERWAY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "inferway/qwen3.8-27b",
  "stream": true,
  "messages": [
    {
      "role": "user",
      "content": "Say hello in one short sentence."
    }
  ]
}'

curl 'https://api.inferway.ai/v1/chat/completions' \
  -H "Authorization: Bearer $INFERWAY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "inferway/qwen3.8-27b",
  "stream": true,
  "messages": [
    {
      "role": "user",
      "content": "Say hello in one short sentence."
    }
  ]
}'

Response shape

data: {
  "id": "chatcmpl_...",
  "object": "chat.completion.chunk",
  "model": "inferway/qwen3.8-27b",
  "choices": [
    {
      "index": 0,
      "delta": { "role": "assistant", "content": "Hello" },
      "finish_reason": null
    }
  ]
}

data: [DONE]

If the first request does not work

Most first-run issues are configuration issues. Check these before changing application code.

# For OpenAI-compatible clients that read OpenAI env vars
export OPENAI_API_KEY="$INFERWAY_API_KEY"
export OPENAI_BASE_URL='https://api.inferway.ai/v1'
export INFERWAY_MODEL='inferway/qwen3.8-27b'

Thinking (reasoning tokens)

The served model does not emit reasoning (thinking) tokens unless the request opts in.

Reasoning tokens are billed as output tokens at the output price and are visible in usage.completion_tokens_details.reasoning_tokens.

Enable thinking per request with chat_template_kwargs.enable_thinking=true (OpenAI SDKs: pass it via extra_body) or reasoning: {"enabled": true}.

Chat completions — Python

The official OpenAI Python SDK works against any OpenAI-compatible base URL. Swap the base URL, keep your existing key. This non-streaming shape is fine for short completions; anything long must stream.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.inferway.ai/v1",
    api_key=os.environ["INFERWAY_API_KEY"],
)

resp = client.chat.completions.create(
    model="inferway/qwen3.8-27b",
    messages=[{"role": "user", "content": "Say hello in one short sentence."}],
    max_tokens=64,
)

print(resp.choices[0].message.content)

Install the SDK (optional)

The first cURL request needs no dependencies. Install the OpenAI SDK only when you are ready to wire the integration into an application.

# Python
pip install openai

# TypeScript / Node.js
npm install openai

Integration guide by tool

{
  "$schema": "https://opencode.ai/config.json",
  "model": "inferway/inferway/qwen3.8-27b",
  "provider": {
    "inferway": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Inferway",
      "options": {
        "baseURL": "https://api.inferway.ai/v1",
        "apiKey": "{env:INFERWAY_API_KEY}"
      },
      "models": {
        "inferway/qwen3.8-27b": {
          "name": "Inferway",
          "limit": {
            "context": 262144,
            "output": 1024
          }
        }
      }
    }
  }
}

opencode run --pure --format json --title 'Inferway basic check' --model 'inferway/inferway/qwen3.8-27b' --agent build --dir . 'Reply with exactly: connected'

opencode run --pure --format json --title 'Inferway read fixture' --model 'inferway/inferway/qwen3.8-27b' --agent build --dir . 'Read the file read-tool-fixture.txt and reply with exactly the nonce it contains, nothing else.'

printf 'Inferway API key: '
IFS= read -r -s INFERWAY_API_KEY
printf '\n'
export INFERWAY_API_KEY

curl --fail-with-body --silent --show-error --max-time 30 \
  'https://api.inferway.ai/v1/models' \
  -H "Authorization: Bearer $INFERWAY_API_KEY"

# Scratch folder with a small read fixture
mkdir inferway-opencode-verify && cd inferway-opencode-verify && git init -q
printf 'nonce-7f3a9c\n' > read-tool-fixture.txt

The MCP endpoint is live. Point an MCP-capable client at the server URL below and authenticate with the same API key; tools are served over the standard protocol, and the same zero-retention rules apply.

Accounts with no spendable balance are routed to the free lane automatically instead of getting a 402 error — the same free tier as the REST API (60 requests/minute). Registered users are never treated worse than anonymous guests.

{
  "mcpServers": {
    "inferway": {
      "url": "https://api.inferway.ai/v1/mcp/sse",
      "headers": {
        "Authorization": "Bearer $INFERWAY_API_KEY"
      }
    }
  }
}

Production checklist

• Keep keys server-side. Never ship inferway_live_… keys in browsers, mobile apps, or public repos.
• Stream long outputs. Anything that can exceed the CDN first-byte window must set stream=true.
• Budget max tokens. Enforce a per-route max_tokens ceiling so costs and latency stay predictable.
• Monitor metadata. Track status, latency, token counts, and model; never log prompt or completion bodies if you need zero-retention semantics end to end.

Endpoint reference

Inferway keeps the OpenAI-compatible path small and predictable, then exposes account, billing, usage, and agent operations as separate first-party endpoints.

Interactions: one route, four operations

Video generation does not return inline. Every call goes to POST /v1/interactions and names the operation in the body's op field; the job is durable, so a dropped connection never loses work already paid for.

• mode must be "background". Synchronous and streaming modes are rejected with 422; there is no inline variant of this route.
• Idempotency-Key is required on create. The same key with the same request returns the original receipt without charging again; the same key with a different request fails closed with 409.
• model, mode, duration_seconds and prompt are all top-level fields of the request body. duration_seconds is required and accepts only the published whole-second tiers — it is what the job is billed on.
• Poll with the get operation until the state is terminal. Our own console polls every 2 seconds; there is no webhook and no long-poll.

Supported public endpoints are POST /v1/chat/completions, POST /v1/interactions and GET /v1/models. The legacy POST /v1/completions is not served: it answers 501 (not implemented) and names the chat completions route to use instead. POST /v1/messages (Anthropic-format) is served but not yet open to API keys: a configured client is refused with a permission error until we announce it.

Choose a model to see its published capability facts. API examples and tool setup use the same selection.

Authentication

Authorization: Bearer $INFERWAY_API_KEY

• API keys. Every key is prefixed inferway_live_… and is issued for server-side workloads.
• Browser apps. Do not expose direct keys client-side; proxy requests through your backend.

Error codes

Inferway returns OpenAI-compatible error objects: {"error": { "type": "...", "message": "...", "code": "..." }}

Paid requests reserve prompt-estimate × input price + max_tokens × output price up front. Eligible requests can use registered FREE quotas when spendable funds are exhausted; FREE requests do not charge the wallet. A 402 refusal happens before dispatch and charges nothing. An authenticated request refused with 400 before it is dispatched appears in your Console request history with zero tokens and zero cost, so the failure can be diagnosed later. Balances render with 4 decimals; prices come from the live rate card.

Cached input tokens are reported in usage.prompt_tokens_details.cached_tokens and bill at the cache rate. On qwen3.8-27b the cache matches whole 1,600-token blocks and never reuses a prompt's last full block, so a request needs roughly 3,200 input tokens or more before any of it can hit; shorter requests always bill at the input rate.

Live error catalog

The complete set of error codes /v1/chat/completions and /v1/agent/chat can return, read from the gateway's own catalog rather than transcribed. Each row carries the HTTP status, whether a retry is safe, and the exact message the API sends. Checkout, billing and key-management endpoints return their own codes, not listed here.

Rate limits and quotas

Quota denials return HTTP 429. Check the error code, window and dimension, and follow Retry-After when present. Per-request size limits require reducing input or max_tokens; waiting does not change them.

Registered free accounts

Registered free accounts: 8 requests/second burst, 60 requests/minute, 300 requests/hour and 1,000 requests/day, with 2 concurrent requests. No per-request input or output token cap, and no per-minute or daily token quota.

Hourly and daily request counts are rolling windows, not a reset at a fixed time. API keys on the same account share these request counts.

Each request is still bounded by the model's own context length and maximum output. Use streaming for outputs above 4,096 tokens.

• X-RateLimit-Limit. The quota of the current RPM window.
• X-RateLimit-Remaining. Requests remaining in the current window.
• X-RateLimit-Reset. Unix timestamp when the current window resets.
• Retry-After. Seconds to wait before retrying after a 429.

Operational limits

• Concurrency ceiling. Registered FREE accounts allow 2 concurrent requests. Funded accounts follow their account and key policies.
• Data retention. Zero for content; metadata only, for billing and reliability.

OpenAI compatibility for the chat API

The matrix below reflects how the gateway actually handles each parameter, based on real runtime verification.

Thinking is off by default. To turn it on, send "reasoning": {"enabled": true} and budget at least ~16k max_tokens for that request — a smaller budget can be spent entirely on reasoning, leaving no visible answer.

Image input — minimal examples

Two minimal request shapes that each ship an inline image to a model whose catalog declares image_input. The image is inlined as a base64 data URL or base64 source; the gateway enforces the same per-image, per-kind total and request-level 16 MiB envelope as the playground.

Behavior of every snippet below is currently bounded by the same inference-unverified declaration listed in the compatibility matrix above.

OpenAI Chat Completions

image_url.content points at a data URL with the image bytes base64-encoded. The MIME matches what the catalog accepts.

POST https://api.inferway.ai/v1/chat/completions
Authorization: Bearer $INFERWAY_API_KEY
Content-Type: application/json

{
  "model": "inferway/qwen3.8-27b",
  "messages": [
    {
      "role": "user",
      "content": [
        {"type": "text", "text": "What is in this image?"},
        {
          "type": "image_url",
          "image_url": {
            "url": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII="
          }
        }
      ]
    }
  ]
}

Anthropic Messages

Anthropic takes a base64 source object instead of a data URL; the gateway routes Anthropic-format requests to the same image_input envelope. The Messages endpoint is not yet open to API keys — see the endpoint reference above.

POST https://api.inferway.ai/v1/messages
Authorization: Bearer $INFERWAY_API_KEY
Content-Type: application/json

{
  "model": "inferway/qwen3.8-27b",
  "max_tokens": 1024,
  "messages": [
    {
      "role": "user",
      "content": [
        {"type": "text", "text": "What is in this image?"},
        {
          "type": "image",
          "source": {
            "type": "base64",
            "media_type": "image/png",
            "data": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII="
          }
        }
      ]
    }
  ]
}

Minimal sample app

#!/usr/bin/env python3
"""Minimal Inferway chat sample. Requires: pip install openai"""
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.inferway.ai/v1",
    api_key=os.environ["INFERWAY_API_KEY"],
)

messages = [{"role": "system", "content": "You are a helpful assistant."}]

while True:
    user = input("You: ")
    if not user:
        break
    messages.append({"role": "user", "content": user})
    stream = client.chat.completions.create(
        model="inferway/qwen3.8-27b",
        messages=messages,
        stream=True,
    )
    reply = ""
    print("Assistant: ", end="", flush=True)
    for chunk in stream:
        if not chunk.choices:
            continue
        piece = chunk.choices[0].delta.content
        if piece:
            reply += piece
            print(piece, end="", flush=True)
    print("\n")
    messages.append({"role": "assistant", "content": reply})

Next steps