API reference

Introduction

The base URL for all API requests is https://api.kurolproxy.com/v1. Both the OpenAI-style /chat/completions and the Anthropic-style /messages endpoints are supported, and every registered model works through either one — we translate between formats automatically.

https://api.kurolproxy.com/v1

Authentication

Authenticate with your Kurol API key in the Authorization header as a Bearer token. Create and manage keys on your dashboard.

Authorization: Bearer sk-kurol-...

Missing or invalid keys return 401.

Models

Pass a model id as the model field. See the full list of models available to you on your dashboard, or fetch them programmatically with your key:

curl https://api.kurolproxy.com/v1/models -H "Authorization: Bearer sk-kurol-..."

Any model can be called from either endpoint. If your plan is restricted to a subset of models, calling a model outside it returns 403.

Chat Completions

POST https://api.kurolproxy.com/v1/chat/completions — OpenAI-compatible. Works with the official OpenAI SDKs by just changing base_url.

from openai import OpenAI

client = OpenAI(
    api_key="sk-kurol-...",
    base_url="https://api.kurolproxy.com/v1",
)

resp = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello, Kurol"}],
)
print(resp.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.KUROL_API_KEY,
  baseURL: "https://api.kurolproxy.com/v1",
});

const res = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Hello, Kurol" }],
});
console.log(res.choices[0].message.content);

curl https://api.kurolproxy.com/v1/chat/completions \
  -H "Authorization: Bearer sk-kurol-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o",
    "messages": [{"role": "user", "content": "Hello, Kurol"}]
  }'

Messages (Anthropic)

POST https://api.kurolproxy.com/v1/messages — Anthropic-compatible. max_tokens is required, like the native Anthropic API.

from anthropic import Anthropic

client = Anthropic(
    api_key="sk-kurol-...",
    base_url="https://api.kurolproxy.com",   # note: no /v1 — the SDK adds /v1/messages
)

msg = client.messages.create(
    model="claude-sonnet-4",
    max_tokens=256,
    messages=[{"role": "user", "content": "Hello, Kurol"}],
)
print(msg.content[0].text)

curl https://api.kurolproxy.com/v1/messages \
  -H "Authorization: Bearer sk-kurol-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello, Kurol"}]
  }'

Streaming

Set "stream": true to receive server-sent events. The OpenAI endpoint streams chat.completion.chunk frames terminated by data: [DONE]; the Anthropic endpoint streams the standard message_start / content_block_delta / message_stop event sequence.

curl -N https://api.kurolproxy.com/v1/chat/completions \
  -H "Authorization: Bearer sk-kurol-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o",
    "messages": [{"role": "user", "content": "Count to 5"}],
    "stream": true
  }'

Errors

Errors are returned in the wire format of the endpoint you called. Common statuses:

• 401 — missing or invalid API key.
• 403 — the model isn't available on your plan.
• 404 — unknown or inactive model.
• 429 — rate limit (requests/minute) or daily token quota exceeded.
• 502 — upstream provider error.

Rate limits & quotas

Each plan has a daily token allowance (prompt + completion tokens) that resets at 00:00 UTC, and a requests-per-minute limit. Exceeding either returns 429. You can watch your usage in real time on your dashboard.

Connect your tools

Kurol works with popular AI coding tools. They all authenticate with your Kurol key and call models by the id shown on your dashboard.

Cline / Roo Code

Add an OpenAI Compatible provider: set the Base URL to https://api.kurolproxy.com/v1, the API key to your sk-kurol-… key, and the model id to one from your catalog.

Base URL:  https://api.kurolproxy.com/v1
API key:   sk-kurol-...
Model id:  <model-id>

Kilo

Define a custom provider using @ai-sdk/openai-compatible. This is the recommended setup — it uses the chat-completions endpoint, which fully supports tool calling.

// kilo.jsonc
{
  "model": "kurol/<model-id>",
  "provider": {
    "kurol": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Kurol Proxy",
      "options": {
        "apiKey": "sk-kurol-...",
        "baseURL": "https://api.kurolproxy.com/v1"
      },
      "models": {
        "<model-id>": { "name": "<model-id>" }
      }
    }
  }
}

Kilo's built-in openai provider also works now — it uses the Responses API (/v1/responses), which Kurol supports — but the compatible provider above is simpler and avoids reasoning-specific quirks.

Claude Code

Set the Anthropic environment variables to point at Kurol, then launch claude. Auth works via the x-api-key header automatically.

# Point Claude Code at Kurol (PowerShell)
$env:ANTHROPIC_BASE_URL = "https://api.kurolproxy.com"
$env:ANTHROPIC_API_KEY  = "sk-kurol-..."
$env:ANTHROPIC_MODEL    = "<model-id>"
claude

# macOS / Linux
export ANTHROPIC_BASE_URL="https://api.kurolproxy.com"
export ANTHROPIC_API_KEY="sk-kurol-..."
export ANTHROPIC_MODEL="<model-id>"
claude

Codex Experimental

Kurol now exposes the OpenAI Responses API (/v1/responses), so Codex can be pointed at it via ~/.codex/config.toml. It's stateless (no server-side conversation state), so some reasoning-continuity flows may differ from OpenAI direct — treat it as experimental.

# ~/.codex/config.toml
model = "<model-id>"
model_provider = "kurol"

[model_providers.kurol]
name = "Kurol Proxy"
base_url = "https://api.kurolproxy.com/v1"
env_key = "KUROL_API_KEY"
wire_api = "responses"

# then set the key in your environment:
#   PowerShell:  $env:KUROL_API_KEY = "sk-kurol-..."
#   bash/zsh:    export KUROL_API_KEY="sk-kurol-..."