Build with Claude
at a predictable cost.

Point any tool that speaks the Anthropic Messages API or the OpenAI Chat Completions API at https://api.alicode.store and use a key that starts with sk-ali-. There is nothing new to learn: the wire format is identical to api.anthropic.com across every endpoint we serve, down to the byte level of SSE events.

AliCode exists to make access to the Claude API economically predictable. The official list price is built for enterprise budgets; we consolidate demand across many teams and developers, contract for capacity at volume, and pass the resulting savings back through a transparent, pay-as-you-go model billed strictly on what you consume.

What you get

• Same wire format as Anthropic. /v1/messages, SSE events, content blocks, tool_use, vision, prompt caching — identical bytes. If your code works against the official API, it works here with one env var change.
• Both APIs in one endpoint. The OpenAI Chat Completions surface is also served, so Cursor / Continue / OpenWebUI / any OpenAI SDK script just needs a base URL swap. No translation glue on your side.
• Files, batches, count_tokens. Full feature parity for SDK helpers — your existing client code doesn't need a single conditional. The Anthropic SDK auto-discovers these and uses them as if it were talking to the official endpoint.
• Pay-as-you-go credits. Top up from 300 ₽. Credits never expire. No subscription, no monthly minimum, no commitment — spend stops the moment you stop calling the API.
• No per-minute rate limits. Access is not gated by tier. The only ceiling is abuse protection at the IP layer (1000 req/min) — orders of magnitude above what any legitimate agent loop requires.
• Same security envelope. All traffic over TLS 1.3, scoped API keys with bcrypt-hashed storage, per-key spend caps and model whitelists, instant revocation, no prompt or response body logged.

Who it's for

AliCode is built for developers who use AI as a daily working tool rather than as a feature inside a SaaS product. If you work continuously in Cline, Cursor, Claude Code, Continue or Aider — or run Python workloads that call the API intensively for embeddings, classification, agent loops and batch summarisation — this is for you. Pricing is structured so that heavy use stays affordable: a Cursor user generating 200K Sonnet tokens a day pays roughly $5 a month instead of $60.

AliCode is not a replacement for enterprise Anthropic contracts. If you require a custom DPA, SOC2 documentation, dedicated capacity, or a formal SLA above 99.5%, please contact Anthropic directly. We provide resale of their capacity at consumer scale.

Available models

Earlier model IDs (claude-3-7-sonnet-latest, claude-3-5-haiku-latest, claude-opus-4-1) are also accepted as aliases.

Quickstart

Five minutes from zero to first request.

1. Register an account (email + password).
2. Open /dashboard/keys → Create new key → copy it. It starts with sk-ali-….
3. Make your first request:

curl https://api.alicode.store/v1/messages \
  -H 'x-api-key: $ALICODE_KEY' \
  -H 'anthropic-version: 2023-06-01' \
  -H 'content-type: application/json' \
  -d '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 256,
    "messages": [{"role":"user","content":"hi"}]
  }'

import os, anthropic

client = anthropic.Anthropic(
    api_key=os.environ["ALICODE_KEY"],
    base_url="https://api.alicode.store",
)

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

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

const client = new Anthropic({
  apiKey: process.env.ALICODE_KEY,
  baseURL: "https://api.alicode.store",
});

const msg = await client.messages.create({
  model: "claude-sonnet-4-5",
  max_tokens: 256,
  messages: [{ role: "user", content: "hi" }],
});
console.log(msg.content[0].text);

That's it. Your existing Anthropic SDK code works unchanged.

Migrate from Anthropic

One environment variable, no code changes. Replace api.anthropic.com with api.alicode.store; replace your sk-ant-… key with sk-ali-…

Bash / Docker

# before
export ANTHROPIC_API_KEY=sk-ant-…
export ANTHROPIC_BASE_URL=https://api.anthropic.com

# after
export ANTHROPIC_API_KEY=sk-ali-…
export ANTHROPIC_BASE_URL=https://api.alicode.store

Python SDK

# only this line changes
client = anthropic.Anthropic(
    api_key=os.environ['ALICODE_KEY'],
    base_url='https://api.alicode.store',
)

Node SDK

const client = new Anthropic({
  apiKey: process.env.ALICODE_KEY,
  baseURL: 'https://api.alicode.store',
});

Feature parity matrix

Cursor

Cursor uses an OpenAI-compatible base URL. Override it to ours.

1. File → Preferences → Cursor Settings → Models
2. Scroll to API Keys → enable OpenAI API Key.
3. Paste your sk-ali-… key.
4. Enable Override OpenAI Base URL and paste https://api.alicode.store/v1
5. Click Verify. Then in Add or search model, add claude-sonnet-4-5 (or claude-haiku-4-5 / claude-opus-4-7).

Cline

Cline is a free agentic VS Code extension. It speaks Anthropic natively.

1. VS Code → Extensions → search Cline → install.
2. Open the Cline panel (left sidebar) → Settings (top-right).
3. API Provider: Anthropic.
4. API Key: sk-ali-…
5. Use custom base URL: ✓ → https://api.alicode.store
6. Model ID: claude-sonnet-4-5

Save and start a new task. Cline will use all its tools (Read, Edit, Bash, etc.) over our gateway, including streamed tool_use and vision blocks.

Recommended model picks

• Default coding: claude-sonnet-4-5 — fastest acceptable quality, what 90% of users settle on.
• Cheap exploratory work: claude-haiku-4-5 — great for "explain this file" / "find the bug" loops; about 4× cheaper than Sonnet.
• Hardest refactors: claude-opus-4-7 — when Sonnet keeps making the same mistake, switch to Opus for one turn and switch back.

Tips

• Vision: drag-and-drop images into Cline's input — they'll be sent as image content blocks. Our gateway routes them to a captioning provider behind the scenes, then hands the caption to Claude for reasoning. You don't see any of that — just the answer.
• Web search: declare nothing extra — we auto-inject the web_search tool when Cline asks for it via execute_command + curl. Saves your local sandbox from being torn down by failed network calls.
• Long sessions: Cline's auto-compaction works perfectly — we honour the context_management.compact_* capabilities on every model.

Claude Code (Anthropic CLI)

Two environment variables, one command.

export ANTHROPIC_BASE_URL=https://api.alicode.store
export ANTHROPIC_API_KEY=sk-ali-…
claude

Add the two exports to your shell rc-file (~/.zshrc / ~/.bashrc) to make them permanent. On Windows: setx ANTHROPIC_BASE_URL ...

Continue.dev

Edit your Continue config (gear icon → Open config.yaml):

name: AliCode
models:
  - name: AliCode Sonnet
    provider: openai
    model: claude-sonnet-4-5
    apiKey: sk-ali-…
    apiBase: https://api.alicode.store/v1
    roles: [chat, edit, apply]

Roo Code

Roo is a Cline fork with multi-mode (Code / Architect / Ask). Same setup as Cline:

• Provider: Anthropic
• Base URL: https://api.alicode.store
• API Key: sk-ali-…
• Model ID: claude-sonnet-4-5

Python & Node SDKs

Python (anthropic)

pip install anthropic

from anthropic import Anthropic
client = Anthropic(api_key='sk-ali-…', base_url='https://api.alicode.store')

# Non-streaming
msg = client.messages.create(
    model='claude-sonnet-4-5',
    max_tokens=512,
    messages=[{'role': 'user', 'content': 'Hello'}],
)
print(msg.content[0].text)

# Streaming
with client.messages.stream(
    model='claude-sonnet-4-5',
    max_tokens=512,
    messages=[{'role': 'user', 'content': 'Tell me a joke'}],
) as stream:
    for text in stream.text_stream:
        print(text, end='', flush=True)

Node (@anthropic-ai/sdk)

npm install @anthropic-ai/sdk

import Anthropic from '@anthropic-ai/sdk';
const client = new Anthropic({ apiKey: 'sk-ali-…', baseURL: 'https://api.alicode.store' });

const stream = await client.messages.stream({
  model: 'claude-sonnet-4-5',
  max_tokens: 512,
  messages: [{ role: 'user', content: 'Hi' }],
});
for await (const ev of stream) {
  if (ev.type === 'content_block_delta' && ev.delta.type === 'text_delta') {
    process.stdout.write(ev.delta.text);
  }
}

OpenAI SDK (for /v1/chat/completions)

from openai import OpenAI
client = OpenAI(api_key='sk-ali-…', base_url='https://api.alicode.store/v1')

resp = client.chat.completions.create(
    model='claude-sonnet-4-5',
    messages=[{'role': 'user', 'content': 'Hi'}],
)
print(resp.choices[0].message.content)

Authentication

All /v1/* endpoints require an API key. We accept it on either header — pick whichever your SDK already uses:

Creating keys

1. Go to /dashboard/keys.
2. Click Create new key, give it a name (e.g. "production").
3. Copy the secret — it's shown once. We store only a hash.

Per-key restrictions

Each key supports optional per-key limits:

• Rate limit (RPM) — requests per minute, defaults to your account's tier.
• Spend cap (cents) — auto-revoke after spending N cents on this key.
• Allowed models — whitelist; requests using other models get 403.

Revoke keys instantly from the dashboard. Revoked keys 401 within seconds across all servers.

Key rotation

Issue a new key, deploy it, then revoke the old one. No downtime — both work in parallel until you revoke. We recommend rotating production keys every 90 days as a baseline.

Security model

We store only a bcrypt hash of your secret — the plaintext is shown once at creation and never again. If you lose it, issue a new key and revoke the old one; we cannot recover the lost secret. Every request is also tied to the IP address that made it (visible in your dashboard), so you can quickly audit unexpected usage.

Where to put keys

• Local development: environment variable in your shell rc-file (~/.zshrc / ~/.bashrc), never committed to git.
• CI/CD: encrypted secret in GitHub Actions / GitLab / Vercel / your platform's secret store.
• Servers: /etc/environment or systemd EnvironmentFile=, root-readable only.
• Never embed in client-side JS, mobile apps, or any place a user can extract bytes from disk.

If a key leaks, revoke it from the dashboard. Within seconds it returns 401 across every server we run.

POST/v1/messages

Anthropic-compatible Messages endpoint. Identical to api.anthropic.com/v1/messages.

Request body

Response shape

{
  "id": "msg_011…",
  "type": "message",
  "role": "assistant",
  "model": "claude-sonnet-4-5",
  "content": [
    { "type": "text", "text": "Closures in PHP capture variables…" }
  ],
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 42,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0,
    "output_tokens": 128
  }
}

stop_reason values

POST/v1/messages/count_tokens

Counts tokens for a planned request without invoking the model. Used by the SDK for cost estimation, context-window planning, and rate-limit pre-checks.

Same request body as /v1/messages. Estimation uses cl100k_base BPE (closest open approximation to Claude's tokenizer) — typical accuracy ±3-5% on prose, ±8-10% on dense code/JSON.

curl https://api.alicode.store/v1/messages/count_tokens \
  -H 'x-api-key: sk-ali-…' \
  -H 'content-type: application/json' \
  -d '{
    "model": "claude-sonnet-4-5",
    "system": "You are Claude.",
    "messages": [{"role":"user","content":"Hello world"}]
  }'

{ "input_tokens": 14 }

POST/v1/chat/completions

OpenAI-compatible. Used by Cursor (via base URL override), Continue, OpenWebUI, your custom scripts written against the OpenAI SDK.

We translate OpenAI-shape requests to Anthropic internally and the response back to OpenAI shape, including streaming chunks, tool_calls, vision image_url blocks, and finish_reason.

curl https://api.alicode.store/v1/chat/completions \
  -H 'Authorization: Bearer sk-ali-…' \
  -H 'content-type: application/json' \
  -d '{
    "model": "claude-sonnet-4-5",
    "messages": [{"role":"user","content":"ping"}]
  }'

finish_reason mapping

GET/v1/models

Returns the list of public model IDs. Two shapes served from the same path depending on the Accept header:

• OpenAI shape — { object: 'list', data: [{ id, object, owned_by, … }] }
• Anthropic shape (GET /v1/models/{id} too) — full capabilities tree with image_input, thinking.adaptive, effort.max, prompt_caching, context_management.

curl https://api.alicode.store/v1/models \
  -H 'Authorization: Bearer sk-ali-…'

# specific model
curl https://api.alicode.store/v1/models/claude-sonnet-4-5 \
  -H 'Authorization: Bearer sk-ali-…'

/v1/files

Persistent upload for images, PDFs, and text dumps. Once uploaded, you reference the file by id in messages content instead of sending base64 every turn — saves token cost and bandwidth across long conversations and batches.

Beta header: anthropic-beta: files-api-2025-04-14 (accepted but not required).

POST/v1/files — upload

curl https://api.alicode.store/v1/files \
  -H 'x-api-key: sk-ali-…' \
  -F 'file=@/path/to/image.png'

{
  "id": "file_011…",
  "type": "file",
  "filename": "image.png",
  "mime_type": "image/png",
  "size_bytes": 184320,
  "created_at": "2026-05-17T15:23:39Z",
  "downloadable": true
}

Use the file in a message

{
  "model": "claude-sonnet-4-5",
  "max_tokens": 512,
  "messages": [{
    "role": "user",
    "content": [
      { "type": "image", "source": { "type": "file", "file_id": "file_011…" } },
      { "type": "text",  "text": "What is in this image?" }
    ]
  }]
}

Other endpoints

Limits

• Max upload: 25 MB per file.
• Accepted mime types: PNG, JPEG, WEBP, GIF, PDF, plain text, markdown, CSV.
• SHA-256 dedup: re-uploading identical bytes returns the existing file id, no new storage.

/v1/messages/batches

Process up to 10,000 messages in one async job at 50% of normal pricing. Submit, poll, fetch results — all asynchronous.

Beta header: anthropic-beta: message-batches-2024-09-24 (accepted but not required).

POST/v1/messages/batches — submit

curl https://api.alicode.store/v1/messages/batches \
  -H 'x-api-key: sk-ali-…' \
  -H 'content-type: application/json' \
  -d '{
    "requests": [
      { "custom_id": "q-1", "params": { "model":"claude-sonnet-4-5", "max_tokens":100, "messages":[{"role":"user","content":"2+2"}] }},
      { "custom_id": "q-2", "params": { "model":"claude-sonnet-4-5", "max_tokens":100, "messages":[{"role":"user","content":"capital of france"}] }}
    ]
  }'

{
  "id": "msgbatch_011…",
  "type": "message_batch",
  "processing_status": "in_progress",
  "request_counts": {"processing":2,"succeeded":0,"errored":0,"canceled":0,"expired":0},
  "created_at": "2026-05-18T15:25:50Z",
  "expires_at": "2026-05-19T15:25:50Z",
  "results_url": null
}

Poll until ended

# Poll every few seconds
curl https://api.alicode.store/v1/messages/batches/msgbatch_011… \
  -H 'x-api-key: sk-ali-…'

# When processing_status == 'ended', fetch JSONL results
curl https://api.alicode.store/v1/messages/batches/msgbatch_011…/results \
  -H 'x-api-key: sk-ali-…'

{"custom_id":"q-1","result":{"type":"succeeded","message":{ … }}}
{"custom_id":"q-2","result":{"type":"succeeded","message":{ … }}}

All endpoints

Validation

• custom_id is required and must be unique within the batch.
• Each params object is a full /v1/messages body (no streaming — batches always return finished messages).
• Batches expire 24h after creation; remaining items become expired.

Streaming SSE

Set stream: true. The server returns Anthropic-format Server-Sent Events. Events arrive in this order:

1. message_start — initial message metadata, empty content.
2. content_block_start — one per block (text / tool_use / thinking).
3. content_block_delta — N deltas with text_delta, input_json_delta, or thinking_delta.
4. content_block_stop — close current block.
5. message_delta — final stop_reason and usage counters.
6. message_stop — end of stream.
7. ping — sent every ~15s to keep the connection alive.

Raw bytes (abbreviated)

event: message_start
data: {"type":"message_start","message":{"id":"msg_…","model":"claude-sonnet-4-5","content":[]}}

event: content_block_start
data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Hello"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":", world"}}

event: content_block_stop
data: {"type":"content_block_stop","index":0}

event: message_delta
data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"output_tokens":9}}

event: message_stop
data: {"type":"message_stop"}

Consuming with the Python SDK

with client.messages.stream(
    model='claude-sonnet-4-5',
    max_tokens=512,
    messages=[{'role':'user','content':'Tell me a joke'}],
) as stream:
    for text in stream.text_stream:
        print(text, end='', flush=True)

Tool use

Pass tools[] with input_schema (JSON Schema). The assistant returns content blocks of type tool_use; your client executes the tool and sends back tool_result in the next user turn.

Round 1 — declare tool, get tool_use

{
  "model": "claude-sonnet-4-5",
  "max_tokens": 1024,
  "tools": [{
    "name": "get_weather",
    "description": "Get current weather for a city",
    "input_schema": {
      "type": "object",
      "properties": { "city": { "type": "string" } },
      "required": ["city"]
    }
  }],
  "messages": [{ "role": "user", "content": "What is the weather in Berlin?" }]
}

Response includes a tool_use block:

{
  "stop_reason": "tool_use",
  "content": [
    { "type": "text",     "text": "Let me check that." },
    { "type": "tool_use", "id": "toolu_01abc", "name": "get_weather", "input": { "city": "Berlin" } }
  ]
}

Round 2 — send tool_result back

{
  "model": "claude-sonnet-4-5",
  "max_tokens": 1024,
  "tools": [/* same tools[] */],
  "messages": [
    { "role": "user",      "content": "What is the weather in Berlin?" },
    { "role": "assistant", "content": [
        { "type": "text",     "text": "Let me check that." },
        { "type": "tool_use", "id": "toolu_01abc", "name": "get_weather", "input": { "city": "Berlin" } }
    ]},
    { "role": "user", "content": [
        { "type": "tool_result", "tool_use_id": "toolu_01abc", "content": "18°C, sunny" }
    ]}
  ]
}

tool_choice

Parallel tool calls: the model may return multiple tool_use blocks in one turn. Run them in parallel and return all tool_result blocks in the next user message.

Web search

Anthropic's server-side web_search_20250305 tool, fully emulated. Declare it in tools[] — the model decides when to search, our gateway runs the query, results land back in the model's context, you get a final answer with cited URLs.

{
  "model": "claude-sonnet-4-5",
  "max_tokens": 512,
  "tools": [{ "type": "web_search_20250305", "name": "web_search", "max_uses": 3 }],
  "messages": [{ "role": "user", "content": "What is the latest stable PHP version?" }]
}

Vision

Send images as Anthropic content blocks of type image. Three source modes:

{
  "model": "claude-sonnet-4-5",
  "max_tokens": 512,
  "messages": [{
    "role": "user",
    "content": [
      { "type": "text", "text": "What is in this image?" },
      { "type": "image", "source": {
          "type": "base64",
          "media_type": "image/jpeg",
          "data": "<base64-bytes>"
      }}
    ]
  }]
}

Persistent vision via files

# upload once
FILE_ID=$(curl -s https://api.alicode.store/v1/files \
  -H 'x-api-key: sk-ali-…' \
  -F 'file=@chart.png' | jq -r .id)

# reference in many turns / batches
curl https://api.alicode.store/v1/messages \
  -H 'x-api-key: sk-ali-…' \
  -H 'content-type: application/json' \
  -d "{
    \"model\":\"claude-sonnet-4-5\",
    \"max_tokens\":512,
    \"messages\":[{ \"role\":\"user\", \"content\":[
      { \"type\":\"image\", \"source\":{ \"type\":\"file\", \"file_id\":\"$FILE_ID\" } },
      { \"type\":\"text\",  \"text\":\"summarise this chart\" }
    ]}]
  }"

Prompt caching

Mark stable prefixes with cache_control: { type: "ephemeral" }. Subsequent requests reusing that prefix pay 10% of input price for the cached portion. Cache TTL: 5 minutes from last hit.

Up to 4 breakpoints per request. We auto-inject one breakpoint at the end of the system block when none is present, so just-passing requests still get caching value.

Where to put breakpoints

• End of system prompt — most common, biggest win.
• After a long, static document in the first user turn.
• After your tools[] declaration if you have many.

Example

{
  "model": "claude-sonnet-4-5",
  "max_tokens": 256,
  "system": [
    { "type": "text", "text": "You are a senior support engineer. Follow company tone.\n\n[…3000 token style guide…]",
      "cache_control": { "type": "ephemeral" } }
  ],
  "messages": [{ "role": "user", "content": "Why is my server slow?" }]
}

Usage counters

"usage": {
  "input_tokens": 12,
  "cache_creation_input_tokens": 3045,
  "cache_read_input_tokens": 0,
  "output_tokens": 80
}

On the next request reusing the same prefix:

"usage": {
  "input_tokens": 14,
  "cache_creation_input_tokens": 0,
  "cache_read_input_tokens": 3045,
  "output_tokens": 80
}

You pay full price only for the input_tokens (new content) and 10% for cache_read_input_tokens.

Extended thinking

Available on Opus and recent Sonnet models. The assistant emits thinking content blocks before the final answer — visible reasoning, like Claude Code's internal monologue.

Enable with the thinking field on the request:

{
  "model": "claude-opus-4-7",
  "max_tokens": 4096,
  "thinking": { "type": "enabled", "budget_tokens": 4096 },
  "messages": [{ "role": "user", "content": "Plan a refactor of this codebase…" }]
}

Response contains both thinking and text blocks:

"content": [
  { "type": "thinking", "thinking": "The user wants a refactor plan. Let me…", "signature": "msg_…" },
  { "type": "text",     "text": "Here is a 5-step plan: …" }
]

Billing & limits

Pricing per 1M tokens (USD)

Discounts

• Batch API — 50% off all input & output tokens.
• Prompt caching — 90% off the cached prefix on read.

Topping up

Top up from $5. Credits never expire. There's nothing to cancel.

Rate limits

No per-minute caps. No daily token quotas. We apply only abuse protection on the IP layer (1000 req/min, 50 concurrent connections) — way above what any legitimate agent needs. Per-key RPM and spend caps can be set in the dashboard.

Error codes

Errors follow Anthropic's shape:

{ "type": "error", "error": { "type": "<error_type>", "message": "<human-readable>" }, "request_id": "req_011…" }

Retry strategy

Treat 429, 502, 503, and idempotent timeouts as retryable. Use exponential backoff starting at 1s, doubling on each attempt, with jitter; cap at 3 retries. The official SDKs do this automatically — if you're using anthropic or @anthropic-ai/sdk you get retry-with-backoff out of the box.

Do not retry 400 / 401 / 402 / 403 / 404 / 413 / 415 — they indicate a problem with the request itself, retrying will just produce the same error. Fix the underlying cause first.

500 is rare and indicates a bug on our side; we surface those in our own monitoring and usually deploy a fix within hours. If you're hitting one persistently, open a ticket with the request-id — that's the fastest way for us to trace it.

Debugging a failing request

1. Check the HTTP status code first — it tells you whose problem it is (4xx = client, 5xx = server).
2. Read the error.message field in the JSON body — it's intentionally human-readable.
3. Grab the request-id header from the response. Even on errors we return it.
4. Reproduce with curl -v from a clean shell to confirm it's not your SDK adding weird headers.
5. If you still can't figure it out, send hello@alicode.store the request id, the time, and the curl command. We'll find your request in our logs.

FAQ & Legal

Most things people ask before signing up — click any question to expand the answer.

Contact & support

Response time on email is typically within 24h on weekdays. For server-side bugs include the request-id header from the failed call — that's how we find your trace in the logs.