Compatible APIs

Introduction

Besides its native API, Runware accepts requests in three other providers' formats. If your code already uses one of their SDKs, point it at Runware by changing two values: the base URL and the API key. Requests and responses keep the provider's format, so the provider's documentation stays the reference for every parameter.

All three read your Runware API key from the Authorization: Bearer header, and take a Runware AIR ID in model. Each section below lists the models its endpoint serves.

OpenAI Chat Completions

https://api.runware.ai/v1/chat/completions takes the OpenAI Chat Completions format. If you already use the OpenAI SDK or any tool that speaks the OpenAI protocol, it works without Runware-specific parsing.

{
  "model": "minimax:m2.7@0",
  "messages": [
    { "role": "user", "content": "What is the capital of France?" }
  ],
  "max_completion_tokens": 256
}

curl -X POST https://api.runware.ai/v1/chat/completions \
  -H "Authorization: Bearer $RUNWARE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "minimax:m2.7@0",
    "messages": [{"role": "user", "content": "What is the capital of France?"}],
    "max_completion_tokens": 256
  }'

from openai import OpenAI

client = OpenAI(
    api_key="your_runware_api_key",
    base_url="https://api.runware.ai/v1",
)

response = client.chat.completions.create(
    model="minimax:m2.7@0",
    messages=[{"role": "user", "content": "What is the capital of France?"}],
    max_completion_tokens=256,
)

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

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'your_runware_api_key',
  baseURL: 'https://api.runware.ai/v1',
});

const response = await client.chat.completions.create({
  model: 'minimax:m2.7@0',
  messages: [{ role: 'user', content: 'What is the capital of France?' }],
  max_completion_tokens: 256,
});

console.log(response.choices[0].message.content);

{
  "model": "minimax:m2.7@0",
  "stream": true,
  "stream_options": { "include_usage": true },
  "messages": [
    { "role": "user", "content": "Tell me a joke" }
  ],
  "max_completion_tokens": 512
}

from openai import OpenAI

client = OpenAI(
    api_key="your_runware_api_key",
    base_url="https://api.runware.ai/v1",
)

with client.chat.completions.stream(
    model="minimax:m2.7@0",
    messages=[{"role": "user", "content": "Tell me a joke"}],
    max_tokens=512,
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'your_runware_api_key',
  baseURL: 'https://api.runware.ai/v1',
});

const stream = await client.chat.completions.create({
  model: 'minimax:m2.7@0',
  messages: [{ role: 'user', content: 'Tell me a joke' }],
  max_tokens: 512,
  stream: true,
});

for await (const chunk of stream) {
  const content = chunk.choices[0]?.delta?.content;
  if (content) process.stdout.write(content);
}

curl -N -X POST https://api.runware.ai/v1/chat/completions \
  -H "Authorization: Bearer $RUNWARE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "minimax:m2.7@0",
    "stream": true,
    "stream_options": {"include_usage": true},
    "messages": [{"role": "user", "content": "Tell me a joke"}],
    "max_completion_tokens": 512
  }'

// First chunk - role assignment
data: {"id":"chatcmpl-e36b09e6-7a1c-4d8f-b5e2-9c4a3f6d8e1b","object":"chat.completion.chunk","model":"minimax:m2.7@0","choices":[{"index":0,"delta":{"role":"assistant"},"finish_reason":null}]}

// Reasoning chunks - choices[0].delta.reasoning_content
data: {"id":"chatcmpl-e36b09e6-7a1c-4d8f-b5e2-9c4a3f6d8e1b","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"reasoning_content":"The user asks 2+2. Simple arithmetic."},"finish_reason":null}]}

// Actual response - switches to choices[0].delta.content
data: {"id":"chatcmpl-e36b09e6-7a1c-4d8f-b5e2-9c4a3f6d8e1b","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"4"},"finish_reason":null}]}

// Usage chunk (when stream_options.include_usage is set)
data: {"id":"chatcmpl-e36b09e6-7a1c-4d8f-b5e2-9c4a3f6d8e1b","object":"chat.completion.chunk","choices":[],"usage":{"prompt_tokens":51,"completion_tokens":38,"total_tokens":89,"cost":0.000134}}

// Final chunk - finish reason
data: {"id":"chatcmpl-e36b09e6-7a1c-4d8f-b5e2-9c4a3f6d8e1b","object":"chat.completion.chunk","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}

data: [DONE]

Anthropic Messages

https://api.runware.ai/v1/messages takes the Anthropic Messages format. The request body reaches Anthropic unchanged, so every Messages parameter works as documented, including thinking, prompt caching, tool use and vision. With "stream": true, the response streams Anthropic's own server-sent events.

The Anthropic SDKs send the API key in an x-api-key header by default. Runware reads it from Authorization: Bearer, so pass your Runware API key as auth_token in Python or authToken in TypeScript, and set the base URL to https://api.runware.ai.

curl -X POST https://api.runware.ai/v1/messages \
  -H "Authorization: Bearer $RUNWARE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic:claude@opus-5.5",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "What is the capital of France?"}]
  }'

from anthropic import Anthropic

client = Anthropic(
    auth_token="your_runware_api_key",
    base_url="https://api.runware.ai",
)

message = client.messages.create(
    model="anthropic:claude@opus-5.5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "What is the capital of France?"}],
)

print(message.content[0].text)

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  authToken: 'your_runware_api_key',
  baseURL: 'https://api.runware.ai',
});

const message = await client.messages.create({
  model: 'anthropic:claude@opus-5.5',
  max_tokens: 1024,
  messages: [{ role: 'user', content: 'What is the capital of France?' }],
});

console.log(message.content[0].text);

Besides the AIR ID, model accepts the Runware model ID (anthropic-claude-opus-5-5) and Anthropic's own model name (claude-opus-5-5).

Decisions

https://api.runware.ai/v1/decisions takes the TypeSafe decisions format. Instead of generating text, a decision model reads a state and answers a set of typed questions with probabilities and a confidence. The TypeSafe docs describe the question types.

The TypeSafe SDKs work by pointing the base URL at https://api.runware.ai with your Runware API key. Set model on every request, because the SDK's own default is not a Runware model ID.

curl -X POST https://api.runware.ai/v1/decisions \
  -H "Authorization: Bearer $RUNWARE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "typesafe:jev@1",
    "state": "I was charged twice. Please fix this ASAP.",
    "questions": {
      "category": {
        "type": "choice",
        "instructions": "What is this ticket about?",
        "criteria": {"billing": null, "technical": null, "other": null}
      }
    }
  }'

from typesafe_sdk import Choice, TypeSafeClient

client = TypeSafeClient(
    api_key="your_runware_api_key",
    base_url="https://api.runware.ai",
)

response = client.system_one(
    model="typesafe:jev@1",
    state={"document": "I was charged twice. Please fix this ASAP."},
    questions={
        "category": Choice(
            instructions="What is this ticket about?",
            criteria={"billing": None, "technical": None, "other": None},
        ),
    },
)

print(response.answers["category"].choice)

import { choice, TypeSafeClient } from '@typesafe-ai/sdk';

const client = new TypeSafeClient({
  apiKey: 'your_runware_api_key',
  baseURL: 'https://api.runware.ai',
});

const response = await client.systemOne({
  model: 'typesafe:jev@1',
  state: { document: 'I was charged twice. Please fix this ASAP.' },
  questions: {
    category: choice('What is this ticket about?', {
      billing: null,
      technical: null,
      other: null,
    }),
  },
});

console.log(response.answers.category.choice);

Each answer arrives under answers, keyed by the question's name.