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

Zero-dependency smoke test against the chat completions endpoint. Set $INFERWAY_API_KEY to a inferway_live_… key, paste, and run. Tokens print as they arrive.

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

Streamed chunks are OpenAI-compatible: concatenate choices[0].delta.content as chunks arrive; the final chunk carries usage.

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"

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

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.

{
  "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.

Models

Start with the published model below, then use /v1/models when your app needs to display capabilities, context window and pricing metadata dynamically.

Authentication

Authenticate every direct API request with a bearer token issued in the Console. Treat live keys as server-side secrets and rotate them if exposure is suspected.

Authorization: Bearer $INFERWAY_API_KEY

• Live keys. Use inferway_live_… for production server workloads.
• Test keys. Use inferway_test_… while integrating and validating billing flows.
• 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": "..." }}

Rate limits and quotas

Every /v1/* inference response carries X-RateLimit-* headers. When a limit is hit the response is HTTP 429 with Retry-After and a rate_limited error object.

• 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. — being measured; published with its test conditions.
• Data retention. Zero for content; metadata only, for billing and reliability.

OpenAI compatibility

The matrix below reflects how the gateway actually handles each parameter today — not how we wish it handled it.

Source of truth: the /v1/chat/completions handler and /v1/models capability metadata.

Minimal sample app

A single-file interactive chat loop with streaming output. Copy, set INFERWAY_API_KEY, and run. Requires pip install openai.

#!/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