Using your key

A Relaybee key is a bearer token for an OpenAI-shaped API. There is nothing to install and no account. Every example on this page is filled in with your own key, so you can copy one and run it.

1. The call that needs no provider key

Two model strings, and the difference is whose machine answers. claude-code goes to a supporter node running under this same key, so the job is only ever offered to your own machines. claude-code/public offers it to anyone who has opted a node into the shared pool, which is how you get an answer without running anything yourself, and it means a stranger reads your prompt and writes what comes back. Your key is the only credential either way.

The examples below send claude-code/public, because that is the one somebody else can answer. Drop the /public once you are running a node of your own.

Send "stream": true for either of them. Not for the typing effect: a node takes 20 to 30 seconds on a real question, and a buffered response has to give up before then because the platform requires one to start within 25 seconds. A streaming response starts immediately and then holds for up to about 110 seconds, which is the only window long enough to actually receive an answer.

curl -N __ORIGIN__/api/v1/chat/completions \
  -H "Authorization: Bearer __KEY__" \
  -H "Content-Type: application/json" \
  -d '{"model":"claude-code/public",
       "stream":true,
       "messages":[{"role":"user","content":"Say hello in one sentence."}]}'

$body = @{
  model    = 'claude-code/public'
  stream   = $true
  messages = @(@{ role = 'user'; content = 'Say hello in one sentence.' })
} | ConvertTo-Json -Depth 5

curl.exe -N __ORIGIN__/api/v1/chat/completions `
  -H "Authorization: Bearer __KEY__" `
  -H "Content-Type: application/json" `
  -d $body

2. Or run it right here

Same request, same key, sent from this page. If it answers, your key works. It sends claude-code/public unless a node of your own is online, in which case it sends claude-code and the prompt stays on your machine. The public pool means a stranger's machine answers it and reads what you type here, so treat this box as public.

3. The same call from code

Relaybee speaks OpenAI's wire format, so any OpenAI client works. Point baseURL at Relaybee and pass your key where the OpenAI key would go.

import OpenAI from 'openai'

const relaybee = new OpenAI({
  baseURL: '__ORIGIN__/api/v1',
  apiKey: '__KEY__',
})

const stream = await relaybee.chat.completions.create({
  model: 'claude-code/public',
  messages: [{ role: 'user', content: 'Say hello in one sentence.' }],
  stream: true,
})

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

from openai import OpenAI

relaybee = OpenAI(base_url="__ORIGIN__/api/v1", api_key="__KEY__")

stream = relaybee.chat.completions.create(
    model="claude-code/public",
    messages=[{"role": "user", "content": "Say hello in one sentence."}],
    stream=True,
)

for part in stream:
    print(part.choices[0].delta.content or "", end="", flush=True)

OPENAI_BASE_URL=__ORIGIN__/api/v1
OPENAI_API_KEY=__KEY__

These send claude-code/public, the shared pool. Use plain claude-code to keep a job on the nodes running under your own key.

4. Bringing your own provider key

The other path. Instead of a supporter, Relaybee calls Anthropic, OpenAI, or Groq with a credential you supply. Relaybee does not store it: the key comes back to you encrypted into a blob that only your Relaybee key can open. Two calls, seal once and then send that blob on every request.

# 1. Seal your provider key. Keep the "connection" value it returns.
curl __ORIGIN__/api/connect \
  -H "Authorization: Bearer __KEY__" \
  -H "Content-Type: application/json" \
  -d '{"provider":"anthropic","apiKey":"sk-ant-...","label":"personal"}'

# 2. Send it on every call, in a header.
curl __ORIGIN__/api/v1/chat/completions \
  -H "Authorization: Bearer __KEY__" \
  -H "X-Relaybee-Connection: <the connection value>" \
  -H "Content-Type: application/json" \
  -d '{"model":"anthropic/claude-opus-5",
       "messages":[{"role":"user","content":"hi"}]}'

# 1. Seal your provider key, and keep the connection value it returns.
$seal = @{ provider = 'anthropic'; apiKey = 'sk-ant-...'; label = 'personal' } | ConvertTo-Json

$conn = (curl.exe __ORIGIN__/api/connect `
  -H "Authorization: Bearer __KEY__" `
  -H "Content-Type: application/json" `
  -d $seal | ConvertFrom-Json).connection

# 2. Send it on every call, in a header.
$body = @{
  model    = 'anthropic/claude-opus-5'
  messages = @(@{ role = 'user'; content = 'hi' })
} | ConvertTo-Json -Depth 5

curl.exe __ORIGIN__/api/v1/chat/completions `
  -H "Authorization: Bearer __KEY__" `
  -H "X-Relaybee-Connection: $conn" `
  -H "Content-Type: application/json" `
  -d $body

Comma-separate up to 8 connections in that header to pool them. Relaybee starts at a random one and fails over to the next on 401, 403, 429, or 5xx, so a pool behaves like one key with the combined quota. The X-Relaybee-Pool-Health response header reports how each attempt went, in the order tried.

Models

On a provider model the part after the slash is passed through untouched, so anthropic/claude-opus-5 and groq/llama-3.3-70b-versatile both work. claude-code is the exception: its slash names a pool, not a model. GET /api/v1/models lists the models you can call without bringing anything, and the providers you can route to if you do.

When it does not work

Errors come back in the OpenAI envelope, {"error":{"message":"…","type":"…"}}, with a message written to be read rather than looked up.

Everything else

POST /api/work/next, POST /api/work/stream, and POST /api/work/complete are the supporter side. You do not call those to use Relaybee; a supporter node does. The whole loop is at /llms.txt.

Worth knowing

• Relaybee keeps no record of your key, so a lost key cannot be shown again. Copy it somewhere.
• A claude-code/public answer is written by a stranger's machine, and that stranger can read your prompt. It is a disclosed trust relationship in both directions. Plain claude-code never leaves the nodes running under your own key.
• Either way somebody has to be running a node. For claude-code that is your own, which the light above reports directly. For claude-code/public the count is a ceiling rather than a promise: watching the shared pool is opt-in, and the count cannot see who opted in.
• This is a demo on free hosting, not a production service.