Documentation

Smart AIPI provides both OpenAI and Anthropic-compatible APIs. Use our service with any existing OpenAI or Anthropic SDK, tool, or app by simply changing the base URL. Zero code changes required.

CLI & MCP Tools

Smart AIPI provides two npm packages to help developers work with their accounts:

Install Both

Install Individually

Authentication

All API requests require an API key. The same key works with both authentication methods:

Migration Guide

Migrating takes less than a minute. Our API is 100% compatible with both OpenAI and Anthropic endpoints.

From OpenAI

From Anthropic

Chat Completions

Create a chat completion for the provided messages and model. This is the main endpoint for interacting with language models.

Request Body Parameters

Message Roles

Code Examples

from openai import OpenAI

client = OpenAI(
    base_url="https://api.smartaipi.com/v1",
    api_key="your-api-key"
)

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello!"}
    ],
    temperature=0.7,
    max_tokens=1000
)

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

import OpenAI from 'openai';

const openai = new OpenAI({
    baseURL: 'https://api.smartaipi.com/v1',
    apiKey: 'your-api-key'
});

const response = await openai.chat.completions.create({
    model: 'gpt-5.4',
    messages: [
        { role: 'system', content: 'You are a helpful assistant.' },
        { role: 'user', content: 'Hello!' }
    ],
    temperature: 0.7,
    max_tokens: 1000
});

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

curl https://api.smartaipi.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "gpt-5.4",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "Hello!"}
    ],
    "temperature": 0.7,
    "max_tokens": 1000
  }'

package main

import (
    "context"
    "fmt"
    openai "github.com/sashabaranov/go-openai"
)

func main() {
    config := openai.DefaultConfig("your-api-key")
    config.BaseURL = "https://api.smartaipi.com/v1"
    client := openai.NewClientWithConfig(config)

    resp, _ := client.CreateChatCompletion(
        context.Background(),
        openai.ChatCompletionRequest{
            Model: "gpt-5.4",
            Messages: []openai.ChatCompletionMessage{
                {Role: "system", Content: "You are a helpful assistant."},
                {Role: "user", Content: "Hello!"},
            },
            Temperature: 0.7,
            MaxTokens:   1000,
        },
    )
    fmt.Println(resp.Choices[0].Message.Content)
}

use async_openai::{Client, config::OpenAIConfig};
use async_openai::types::{
    CreateChatCompletionRequestArgs, ChatCompletionRequestMessage,
    ChatCompletionRequestSystemMessageArgs, ChatCompletionRequestUserMessageArgs,
};

let config = OpenAIConfig::new()
    .with_api_key("your-api-key")
    .with_api_base("https://api.smartaipi.com/v1");

let client = Client::with_config(config);

let request = CreateChatCompletionRequestArgs::default()
    .model("gpt-5.4")
    .messages([
        ChatCompletionRequestSystemMessageArgs::default()
            .content("You are a helpful assistant.")
            .build()?.into(),
        ChatCompletionRequestUserMessageArgs::default()
            .content("Hello!")
            .build()?.into(),
    ])
    .build()?;

let response = client.chat().create(request).await?;
println!("{}", response.choices[0].message.content);

Streaming

Enable streaming to receive tokens as they're generated via Server-Sent Events (SSE). This provides a better user experience for long responses.

Streaming Example

from openai import OpenAI

client = OpenAI(
    base_url="https://api.smartaipi.com/v1",
    api_key="your-api-key"
)

# Enable streaming
stream = client.chat.completions.create(
    model="gpt-5.4",
    messages=[{"role": "user", "content": "Write a poem"}],
    stream=True
)

# Process chunks as they arrive
for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

const stream = await openai.chat.completions.create({
    model: 'gpt-5.4',
    messages: [{ role: 'user', content: 'Write a poem' }],
    stream: true,
});

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

Reasoning Effort

Control the depth of reasoning with the reasoning_effort parameter for GPT-5 models.

Supported Models

Reasoning Effort Levels

Fast Mode (Priority Processing)

Use service_tier: "priority" for priority processing with lower latency. This is what the /fast command in Codex CLI uses. It does not change reasoning depth - you get the same quality, faster.

response = client.responses.create(
    model="gpt-5.4",
    input="Refactor this function",
    service_tier="priority"              # priority processing, lower latency
)

Chat Completions API

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[{"role": "user", "content": "Analyze this code for bugs..."}],
    reasoning_effort="high"  # or "xhigh" for maximum depth
)

Responses API

# Reasoning is set via the "reasoning" object
response = client.responses.create(
    model="gpt-5.4",
    input=[{"role": "user", "content": "Refactor this function..."}],
    reasoning={"effort": "high"}  # defaults to "high" on Smart AIPI
)

Image Generation

Generate images from text prompts using our image generation endpoint.

Request Body Parameters

Available Models

Example

response = client.images.generate(
    model="gpt-image-1.5",
    prompt="A futuristic city at sunset, cyberpunk style",
    size="1024x1024",
    n=1
)

# Response contains base64-encoded image
image_b64 = response.data[0].b64_json

# Save to file
import base64
with open("output.png", "wb") as f:
    f.write(base64.b64decode(image_b64))

curl https://api.smartaipi.com/v1/images/generations \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "gpt-image-1.5",
    "prompt": "A futuristic city at sunset",
    "n": 1,
    "size": "1024x1024"
  }'

Image Edits

Edit existing images using a text prompt. Accepts both JSON (base64 string) and multipart/form-data (file upload), so OpenAI SDKs work out of the box.

Request Body Parameters

Example

import base64

response = client.images.edit(
    model="gpt-image-1.5",
    image=open("input.png", "rb"),
    prompt="Change the background to a sunset beach",
    size="1024x1024",
    n=1
)

# Save the edited image
edited_b64 = response.data[0].b64_json
with open("edited.png", "wb") as f:
    f.write(base64.b64decode(edited_b64))

curl https://api.smartaipi.com/v1/images/edits \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "model=gpt-image-1.5" \
  -F "prompt=Change the background to a sunset beach" \
  -F "image=@input.png" \
  -F "size=1024x1024" \
  -F "n=1"

Realtime API with WebSocket

WebSockets are a broadly supported API for realtime data transfer, and a great choice for connecting to the Smart AIPI Realtime API in server-to-server applications.

In a server-to-server integration, your backend system connects via WebSocket directly to the Realtime API. Use a standard API key to authenticate the connection, since the token is only available on your secure backend server.

Connect via WebSocket

Below are several examples of connecting via WebSocket. In addition to using the WebSocket URL, you will need to pass an authentication header using your API key.

import WebSocket from "ws";

const url = "wss://api.smartaipi.com/v1/responses";
const ws = new WebSocket(url, {
  headers: {
    Authorization: "Bearer " + process.env.SMARTAIPI_API_KEY,
  },
});

ws.on("open", function open() {
  console.log("Connected to server.");

  // Send a response.create event
  ws.send(JSON.stringify({
    type: "response.create",
    response: {

      model: "gpt-5.4",
      store: false,
      input: [{ role: "user", content: "Hello!" }],
      stream: true,
    },
  }));
});

ws.on("message", function incoming(message) {
  const event = JSON.parse(message.toString());
  console.log(event.type, event);
});

import os, json, websocket

url = "wss://api.smartaipi.com/v1/responses"
headers = ["Authorization: Bearer " + os.environ["SMARTAIPI_API_KEY"]]

def on_open(ws):
    print("Connected to server.")
    ws.send(json.dumps({
        "type": "response.create",
        "response": {
            "model": "gpt-5.4",
            "store": False,
            "input": [{"role": "user", "content": "Hello!"}],
            "stream": True,
        }
    }))

def on_message(ws, message):
    data = json.loads(message)
    print("Event:", data["type"])

ws = websocket.WebSocketApp(url, header=headers,
    on_open=on_open, on_message=on_message)
ws.run_forever()

# Verify WebSocket handshake (requires curl with --http1.1)
curl --max-time 5 --http1.1 -i -N \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Connection: Upgrade" \
  -H "Upgrade: websocket" \
  -H "Sec-WebSocket-Version: 13" \
  -H "Sec-WebSocket-Key: $(openssl rand -base64 16)" \
  "https://api.smartaipi.com/v1/responses"

# A successful handshake returns:
# HTTP/1.1 101 Switching Protocols
# upgrade: websocket
# sec-websocket-accept: ...

Sending and Receiving Events

Sessions are managed using client-sent and server-sent JSON events over the WebSocket connection. Wrap your request in a response.create envelope:

List Models

Retrieve a list of all available models. Use this endpoint to dynamically discover which models are available for your account.

Response Format

{
    "object": "list",
    "data": [
        {
            "id": "gpt-5.4",
            "object": "model",
            "created": 1700000000,
            "owned_by": "smart-aipi"
        },
        {
            "id": "gpt-5.3-codex",
            "object": "model",
            "created": 1700000000,
            "owned_by": "smart-aipi"
        },
        // ... more models
    ]
}

Example

from openai import OpenAI

client = OpenAI(
    base_url="https://api.smartaipi.com/v1",
    api_key="your-api-key"
)

# List all available models
models = client.models.list()

for model in models.data:
    print(model.id)

curl https://api.smartaipi.com/v1/models \
  -H "Authorization: Bearer YOUR_API_KEY"

Available Models

Anthropic Messages API

Full Anthropic Messages API compatibility. Use any Anthropic SDK, Claude Code, or app that speaks the Anthropic protocol - just change the base URL.

Supported Features

Code Examples

from anthropic import Anthropic

client = Anthropic(
    base_url="https://api.smartaipi.com",
    api_key="your-api-key"
)

response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello!"}
    ]
)

print(response.content[0].text)

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

const client = new Anthropic({
    baseURL: 'https://api.smartaipi.com',
    apiKey: 'your-api-key'
});

const response = await client.messages.create({
    model: 'claude-sonnet-4-5-20250929',
    max_tokens: 1024,
    messages: [
        { role: 'user', content: 'Hello!' }
    ]
});

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

curl https://api.smartaipi.com/v1/messages \
  -H "x-api-key: your-api-key" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5-20250929",
    "max_tokens": 1024,
    "messages": [
        {"role": "user", "content": "Hello!"}
    ]
  }'

Model Mapping

Claude model names are accepted and automatically routed to GPT-5.4 with tiered reasoning effort. Every response includes an x-actual-model header showing the real backend model.

Claude Code

Use Claude Code with Smart AIPI as the backend. Full tool use, streaming, and agentic capabilities supported.

Automatic Setup

npx smart-aipi claude

This configures ~/.claude/settings.json and ~/.claude.json automatically. If you already have Claude Code set up with an Anthropic account, it will show you the manual config instead of overwriting.

Manual Setup

Add to ~/.claude/settings.json:

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.smartaipi.com",
    "ANTHROPIC_API_KEY": "sk-your-key",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "claude-haiku-4-5-20251001"
  },
  "model": "opus"
}

Then add "hasCompletedOnboarding": true to ~/.claude.json to skip the setup wizard.

What Each Setting Does

OpenCode

Use Smart AIPI as your OpenCode backend via the OpenAI-compatible SDK.

Config Setup

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "smart-aipi": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Smart AIPI",
      "options": {
        "baseURL": "https://api.smartaipi.com/v1",
        "apiKey": "YOUR_API_KEY"
      },
      "models": {
        "gpt-5.4": {
          "name": "GPT-5.4",
          "reasoning": true,
          "limit": { "context": 400000, "output": 128000 }
        },
        "gpt-5.3-codex": {
          "name": "GPT-5.3 Codex",
          "reasoning": true,
          "limit": { "context": 400000, "output": 128000 }
        },
        "gpt-5.2-codex": {
          "name": "GPT-5.2 Codex",
          "reasoning": true,
          "limit": { "context": 400000, "output": 128000 }
        },
        "gpt-5-codex": {
          "name": "GPT-5 Codex",
          "reasoning": true,
          "limit": { "context": 400000, "output": 128000 }
        }
      }
    }
  },
  "model": "smart-aipi/gpt-5.4"
}

Codex CLI

Use Smart AIPI with OpenAI's Codex CLI tool. Three files need to be configured.

Automatic Setup

npx smart-aipi codex

This configures all three files below automatically. After running, add model_reasoning_effort to your config (see step 2).

Manual Setup

Configure these three files:

1. API Key — ~/.codex/auth.json

{
  "auth_mode": "apikey",
  "OPENAI_API_KEY": "sk-your-key"
}

2. Model & Reasoning — ~/.codex/config.toml

model = "gpt-5.4"
model_reasoning_effort = "high"

Valid reasoning levels: low, medium, high (recommended), xhigh.

3. Environment Variables — ~/.zshrc

# Smart AIPI
export OPENAI_API_KEY="sk-your-key"
export OPENAI_BASE_URL="https://api.smartaipi.com/v1"

Then use Codex normally:

codex "fix this bug"

Codex WebSocket Speed Guide

WebSocket mode is usually faster for agentic coding flows with lots of tool calls. Instead of repeatedly reconnecting over HTTP and re-sending full request envelopes, Codex keeps one live connection and sends incremental turns, which reduces continuation overhead.

Enable WebSockets in Codex

Use the WebSocket v2 feature flag in ~/.codex/config.toml: ~/.codex/config.toml:

model = "gpt-5.4"
model_reasoning_effort = "high"

[features]
responses_websockets_v2 = true

CLI equivalent:

codex --enable responses_websockets_v2

Older builds may use the legacy flag:

[features]
responses_websockets = true

Known Homebrew Behavior

On some Homebrew-distributed builds, WebSocket turns can stall during long-running tasks and then silently fall back to HTTP. We saw this especially in complex tool-call loops. Rebuilding from the open-source code with the fixes below improved both stability and speed.

Post-Merge: Fix the Open-Source WebSocket Bug

After merging your branch, use this checklist to ensure the fix is in your local binary:

# 1) Pull merged main
git checkout main
git pull --ff-only

# 2) Confirm websocket flags exist
codex features list | rg responses_websockets

# 3) Build and install
cd codex-rs
cargo build --release
install -m 0755 target/release/codex ~/.local/bin/codex-beta

# 4) Run with websocket enabled
CODEX_RS_RESPONSES_WS=true \
OPENAI_BASE_URL=https://api.smartaipi.com/v1 \
~/.local/bin/codex-beta --enable responses_websockets_v2

If you need to patch manually, verify these code-level fixes are present:

# A) Build websocket request with IntoClientRequest so required headers are set
let mut request = url.as_str().into_client_request()?;
request.headers_mut().extend(headers);

# B) Ensure TLS roots are enabled for tokio-tungstenite in Cargo.toml
tokio-tungstenite = { version = "...", features = ["rustls-tls-native-roots"] }

Cursor & Cline

Use Smart AIPI with Cursor IDE or Cline VS Code extension.

Chat

Use Smart AIPI Chat at chat.smartaipi.com. for text, image, video, code, search, and voice workflows.

Features

• ✓ Chat — General-purpose text conversations with Smart AIPI models.
• ✓ Images — Generate and edit images from prompts.
• ✓ Video — Generate videos from text or image inputs.
• ✓ Code — Code assistance and editing in the browser.
• ✓ Search — Use web search for grounded answers.
• ✓ Voice — Talk to the model with voice input and responses.

Getting Started

Billing: Usage is billed against your Smart AIPI credits.

API Tester

Test the API directly from your browser: