Synap by Linkrra

npx add-mcp 'https://pool.linkrra.com/mcp'

Use Linkrra from your tools

One key, two protocols, one line of config. Everything below works today.

One key, two protocols. Get a key on your account page — it looks like sk-pool-… and works everywhere below.

Anything OpenAI-compatible

Change the base URL. Nothing else in your code moves. This covers the OpenAI SDKs, Cline, Continue, Aider, Roo, Cursor and most agent frameworks. Coming from Hyperbolic's retired inference API? There is a short migration guide.

curl

curl https://pool.linkrra.com/v1/chat/completions \
  -H "Authorization: Bearer $LINKRRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen/qwen3-coder",
    "messages": [{"role": "user", "content": "Say hello"}]
  }'

Python

The official OpenAI SDK, pointed at us.

from openai import OpenAI

client = OpenAI(
    base_url="https://pool.linkrra.com/v1",
    api_key="sk-pool-...",
)

resp = client.chat.completions.create(
    model="qwen/qwen3-coder",
    messages=[{"role": "user", "content": "Say hello"}],
)

Node

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://pool.linkrra.com/v1",
  apiKey: process.env.LINKRRA_API_KEY,
});

Codex CLI

Add a provider in ~/.codex/config.toml, then select it.

[model_providers.linkrra]
name = "Linkrra"
base_url = "https://pool.linkrra.com/v1"
env_key = "LINKRRA_API_KEY"

model_provider = "linkrra"
model = "qwen/qwen3-coder"

Cline · Continue · Cursor

Choose the OpenAI-compatible provider and fill two fields.

Base URL:  https://pool.linkrra.com/v1
API key:   sk-pool-...
Model:     qwen/qwen3-coder

Claude Code beta

Claude Code speaks Anthropic's Messages API rather than OpenAI's, so it needs a different endpoint — we serve that too, tool use included. Point it at us with two environment variables.

Beta, honestly: the endpoint is built, tested and deployed, and the auth path is verified against the live service. A full Claude Code session has not yet been run end to end against it. If something misbehaves, write to weare@linkrra.com — that is a bug report we want.

Claude Code

export ANTHROPIC_BASE_URL="https://pool.linkrra.com"
export ANTHROPIC_AUTH_TOKEN="sk-pool-..."

claude

Codex

Same shape as the Codex CLI section above — Codex speaks OpenAI's protocol, so it needs the /v1 base URL, not the Anthropic one.

export OPENAI_BASE_URL="https://pool.linkrra.com/v1"
export OPENAI_API_KEY="sk-pool-..."

Run your own agent from your editor beta

An agent you built in Agent Studio is addressable as a model id. Pass agent:<your-agent-id> wherever a tool asks for a model, and the request runs with that agent's instructions and its knowledge sources instead of a bare model. Nothing else changes: same key, same balance, same per-token rate.

# Claude Code
export ANTHROPIC_BASE_URL="https://pool.linkrra.com"
export ANTHROPIC_AUTH_TOKEN="sk-pool-..."
claude --model "agent:acme-support"

# Codex CLI — ~/.codex/config.toml
model_provider = "linkrra"
model = "agent:acme-support"

# Codex / any OpenAI-speaking tool, by environment
export OPENAI_BASE_URL="https://pool.linkrra.com/v1"
export OPENAI_API_KEY="sk-pool-..."
export OPENAI_MODEL="agent:acme-support"

# Cline · Continue · Cursor — the OpenAI-compatible provider
Base URL:  https://pool.linkrra.com/v1
API key:   sk-pool-...
Model:     agent:acme-support

Two response headers tell you what happened: X-Linkrra-Agent names the agent that answered, and X-Linkrra-Agent-Sources reports how many of your uploaded sources were retrieved into that turn. When it reads 0, the answer was not grounded in your documents — worth knowing before you trust it.

Answers cite your sources inline as [1], [2]. A citation number the retrieval did not actually supply is stripped before you see it, so a footnote in an answer always points at a real chunk of a real document.

An agent you have paused in the studio is refused here too, with a 403. If our agent store cannot be reached you get a 503 and no charge — never a 404, which would read as "your agent was deleted".

Agent Teams private demo

Every tool above authenticates as your account — the same key spends the same credit balance everywhere.

What a key in a dev tool does and does not carry. Running agent:<id> from Claude Code gives you that agent's prompt and its knowledge. It does not put the agent's Agent Teams envelope around your editor: the tools Claude Code runs on your machine are Claude Code's, and our gateway never sees them, so it cannot bound them. The envelope — which tools, which hosts, what spend ceiling, what expiry — is enforced only for actions that pass through our own execution gateway, which is what happens when the agent runs inside Agent Teams. Treat a key pasted into a dev tool as account-scoped, not team-member-scoped, and do not use it as an access control.

Models

Pass any id from the catalogue as model. Ask for a model we do not serve and the request is refused rather than quietly answered by a different one — you always know which model replied.

Confidential mode (GPU TEE)

Add "confidential": true to a chat completion request to require it be answered inside an attested GPU Trusted Execution Environment — the provider cannot read the prompt even with root access to the machine it runs on, which is a stronger guarantee than our default zero-data-retention routing. Only a subset of models can back this claim today; asking for it on any other model returns 400 rather than silently falling back to an unattested one. Current confidential-capable models: moonshotai/kimi-k3, z-ai/glm-5.2, deepseek/deepseek-v4-flash, openai/gpt-oss-120b.

curl https://pool.linkrra.com/v1/chat/completions \
  -H "Authorization: Bearer $LINKRRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"openai/gpt-oss-120b","confidential":true,"messages":[{"role":"user","content":"hi"}]}'

Text-to-speech

Real-time TTS, streamed from the same Gemini Live voice engine that powers our own phone agent — plus a Hebrew path most providers don't have at all: text routed through Dicta 's nikud engine before synthesis, so Hebrew is read with correct vowelization instead of guessed. Detected automatically — send Hebrew text and it's applied; nothing to configure.

REST (your API key)

curl https://pool.linkrra.com/v1/audio/speech \
  -H "Authorization: Bearer $LINKRRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello from Linkrra."}' \
  --output speech.wav

Returns a playable audio/wav file — no separate decoding step. sampleRate (default 24000) and nikud (default true — set false to read Hebrew text without vocalization, at the standard rate instead of the nikud rate) are both optional. 5,000-character limit per call.

x402 — no account, an agent pays per call

Same engine, no API key: an AI agent holding USDC on Base pays per clip in the same round trip, the way /v1/chat/completions already works for inference (see Agents). POST without a payment and you get an HTTP 402 with an exact price quote for that text — no estimate, because a TTS clip's cost is fully determined by its character count. Every x402 paid call carries a $0.01 minimum charge (on TTS and chat/completions alike): below it the quote and the settlement are exactly $0.01; above it you pay the usage-based price. Credit top-ups via /api/billing/x402/topup are $1.00 minimum. Retry with a PAYMENT-SIGNATURE header and the same request returns the WAV clip.

curl https://pool.linkrra.com/api/billing/x402/tts \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello from Linkrra."}'
# -> 402, PAYMENT-REQUIRED header + body with the exact quote for this text

curl https://pool.linkrra.com/api/billing/x402/tts \
  -H "Content-Type: application/json" \
  -H "PAYMENT-SIGNATURE: " \
  -d '{"text": "Hello from Linkrra."}' \
  --output speech.wav

Machine-readable pricing and mechanism: GET /api/billing/x402/tts/info.

Pricing

$0.010 per 1,000 characters standard. $0.15 per 1,000 characters for the Hebrew-nikud path. A request is priced once, from its own text, before anything is generated.

What you are charged

One credit is one token, the same rate on every model we serve, and you are charged on the tokens a request actually consumed — settled after it completes, not on the pre-flight estimate. Your balance and a per-day breakdown are on the account page; prices are on pricing.

Errors worth knowing

401 — the key is missing or malformed; keys start with sk-pool-.
402 — out of credits. Top up or start a plan on your account page.
429 — over your plan's rate limit; it resets shortly.
503 — nothing is serving that model right now. This is ours, not yours.