Build on every model through one OpenAI-compatible API.

from openai import OpenAI

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

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Write a one-line haiku about APIs."}],
)

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

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.oneinterface.ai/v1",
  apiKey: process.env.ONEINTERFACE_API_KEY,
});

const response = await client.chat.completions.create({
  model: "claude-sonnet-4-6",
  messages: [{ role: "user", content: "Summarize this pull request." }],
});

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

curl https://api.oneinterface.ai/v1/chat/completions \
  -H "Authorization: Bearer oi_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o",
    "messages": [
      { "role": "user", "content": "Hello from One Interface" }
    ]
  }'

# Cursor Settings → Models → add these fields:
#
#  Override OpenAI Base URL:  https://api.oneinterface.ai/v1
#  OpenAI API Key:            oi_your_api_key
#  Add Model:                 gpt-4o   (or any ID from /v1/models)
#
# ⚠  Only the chat/plan panel (Cmd+L / Ctrl+L) sends requests to this endpoint.
# Composer, inline edits, and autocomplete stay on Cursor's proprietary backend.

# Quickest option — set two env vars and run Codex as normal.
# No flags, no config file changes needed.
export OPENAI_BASE_URL="https://api.oneinterface.ai/v1"
export OPENAI_API_KEY="oi_your_api_key"

codex "refactor this function to use async/await"

# ~/.codex/config.toml  (persistent — applies to every Codex session)
# Define One Interface as a named provider, then set it as default.

[model_providers.oneinterface]
name     = "One Interface"
base_url = "https://api.oneinterface.ai/v1"
env_key  = "OI_API_KEY"   # export OI_API_KEY=oi_your_api_key
wire_api = "chat"         # OpenAI-compatible chat completions

[model]
provider = "oneinterface"
name     = "gpt-4o"       # any model ID from /v1/models

# --bare forces Claude Code to use ANTHROPIC_API_KEY instead of its OAuth session.
# Without --bare the OAuth token is sent to One Interface and rejected (401).
ANTHROPIC_API_KEY=oi_your_api_key \
ANTHROPIC_BASE_URL=https://api.oneinterface.ai \
  claude --bare --model oi/balanced-coder

# Recommended: add an alias to ~/.zshrc so you just type "claude-oi"
alias claude-oi='ANTHROPIC_API_KEY=oi_your_api_key ANTHROPIC_BASE_URL=https://api.oneinterface.ai claude --bare --model oi/balanced-coder'

# Run once in your terminal — registers the server for all your projects
claude mcp add --transport http -s user oneinterface https://api.oneinterface.ai/mcp \
  -H "Authorization: Bearer oi_your_api_key"

# Verify the connection
claude mcp list

// .cursor/mcp.json  (project-level)
// or add to Cursor Settings → MCP → Edit config
{
  "mcpServers": {
    "oneinterface": {
      "url": "https://api.oneinterface.ai/mcp",
      "headers": {
        "Authorization": "Bearer oi_your_api_key"
      }
    }
  }
}

# ~/.codex/config.toml
# Codex picks this up automatically on startup.

[mcp_servers.oneinterface]
type    = "http"
url     = "https://api.oneinterface.ai/mcp"

[mcp_servers.oneinterface.headers]
Authorization = "Bearer oi_your_api_key"

Authorization: Bearer oi_your_api_key
Content-Type: application/json

curl https://api.oneinterface.ai/v1/chat/completions \
  -H "Authorization: Bearer oi_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "oi/chat",
    "messages": [
      { "role": "user", "content": "Summarize this thread in three bullets." }
    ]
  }'

await client.chat.completions.create({
  model: "gpt-4o",
  stream: true,
  messages: [{ role: "user", content: "Think step by step." }],
});

# Option A — bring your own tools.
# Pass tools: [...] directly. No registry needed.
# Works exactly like the OpenAI API — One Interface forwards it unchanged.

from openai import OpenAI
import json

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

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a city",
            "parameters": {
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"],
            },
        },
    }
]

messages = [{"role": "user", "content": "What is the weather in Tokyo?"}]

response = client.chat.completions.create(model="gpt-4o", messages=messages, tools=tools)
choice = response.choices[0]

while choice.finish_reason == "tool_calls":
    messages.append(choice.message)
    for call in choice.message.tool_calls:
        result = my_tools[call.function.name](**json.loads(call.function.arguments))
        messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
    response = client.chat.completions.create(model="gpt-4o", messages=messages, tools=tools)
    choice = response.choices[0]

print(choice.message.content)

# Option B — shared tool registry.
# Register a tool schema once; any agent on the account can use it via custom_tools: true.
# One Interface injects the schemas before forwarding — your agent still executes the tool itself.

from openai import OpenAI
import json

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

messages = [{"role": "user", "content": "Search for the latest AI news"}]

response = client.chat.completions.create(
    model="gpt-4o",
    messages=messages,
    extra_body={"custom_tools": True},   # injects all schemas registered under your account
)
choice = response.choices[0]

while choice.finish_reason == "tool_calls":
    messages.append(choice.message)
    for call in choice.message.tool_calls:
        result = my_tools[call.function.name](**json.loads(call.function.arguments))
        messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
    response = client.chat.completions.create(
        model="gpt-4o", messages=messages, extra_body={"custom_tools": True}
    )
    choice = response.choices[0]

print(choice.message.content)

# Claude-based agents using the Anthropic SDK.
# custom_tools works the same way — One Interface injects registered schemas,
# your agent executes the tool directly when the model requests it.

import anthropic
import json

client = anthropic.Anthropic(
    api_key="oi_your_api_key",
    base_url="https://api.oneinterface.ai",   # note: root URL, not /v1
)

messages = [{"role": "user", "content": "Search for the latest AI news"}]

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=messages,
    extra_headers={"x-custom-tools": "true"},  # or pass via bespoke_parameters
)

# stop_reason == "tool_use" when the model wants to call a tool
while response.stop_reason == "tool_use":
    tool_results = []
    for block in response.content:
        if block.type == "tool_use":
            # Execute the tool yourself — One Interface is not in the execution path
            result = my_tools[block.name](**block.input)
            tool_results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": json.dumps(result),
            })

    messages.append({"role": "assistant", "content": response.content})
    messages.append({"role": "user", "content": tool_results})

    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        messages=messages,
    )

print(response.content[0].text)

// finish_reason tells your agent what to do next:
//   "stop"       → final answer, read choices[0].message.content
//   "tool_calls" → execute the requested tool, append the result, loop

{
  "choices": [{
    "finish_reason": "tool_calls",
    "message": {
      "role": "assistant",
      "tool_calls": [{
        "id": "call_abc123",
        "type": "function",
        "function": {
          "name": "get_weather",
          "arguments": "{\"city\": \"Tokyo\"}"
        }
      }]
    }
  }]
}

{
  "error": {
    "message": "The requested model is not available.",
    "type": "oneinterface_error",
    "code": "model_not_available"
  }
}