Everything the dashboard does, over HTTP

Hand this to your agent

Help me set up Megaloop using its supported API onboarding flow.

Read https://megaloop.dev/llms.txt and follow the setup instructions.
Ask for my email, terms confirmation, and verification code when needed.
Help me connect the AI subscription I choose, configure my app,
and verify the connection with one small test request.

Authenticating

Mint a key on Keys. It starts sk-ml-v1-. Lose it and the key control on its row shows it again — to somebody signed in, never to an API key. Send it as Authorization: Bearer <key> — the same header the management API and the inference endpoint both take.

Three independent capabilities. read — accounts, usage, traffic, limits, keys, plan. inference — serve requests through the pool and choose which account they land on. manage — link accounts, mint and revoke keys. None implies another.

The default is inference alone. Choose on Keys, or send {"capabilities":["read","inference"]} to POST /v1/keys. A key can only grant what it already holds, so it cannot widen itself. A missing capability returns 403 naming it.

The rows marked Session only refuse every key, whatever it carries: they link an account from a credential you hold, unlink accounts, close the account, resume a paused account, move the sign-in address, accept the terms, or reach billing. A session token comes from POST /v1/auth/verify, so an agent holding one can make them too.

Full reference, always current: openapi.json

Pointing a client at the pool

Two settings, the same pair every client needs: the base URL https://api.megaloop.dev and your key as a bearer token. All that differs between clients is what they call them.

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.megaloop.dev",
    "ANTHROPIC_AUTH_TOKEN": "YOUR_KEY"
  }
}

claude

claude --settings ./megaloop-settings.json

model = "gpt-6-sol"
model_provider = "megaloop"

[model_providers.megaloop]
name = "Megaloop"
base_url = "https://api.megaloop.dev/v1"
wire_api = "responses"
env_key = "MEGALOOP_API_KEY"
requires_openai_auth = false

export MEGALOOP_API_KEY="YOUR_KEY"
codex

$env:MEGALOOP_API_KEY="YOUR_KEY"
codex

Cursor Settings → Models → API Keys
OpenAI API Key             YOUR_KEY
Override OpenAI Base URL   https://api.megaloop.dev/v1

base URL   https://api.megaloop.dev
token      YOUR_KEY          sent as:  Authorization: Bearer YOUR_KEY

Use the auth token, not the API key

An interactive session treats an API key found in your environment as something to ask you about: it shows an approval dialog, and the default answer is no. Decline it — or press Enter — and the session does not stop. It falls back to the login already on your machine and sends that credential here, which megaloop rejects, after which the client retries ten times and rotates the login token on each attempt.

So the symptom is not silence. It is a session that looks as though your own subscription login has broken, while your dashboard shows no traffic at all. An auth token has no such dialog: it replaces the ambient login outright.

A one-shot run never shows the dialog, which is why a sample that works the first time can fail the moment the same settings are used in a real session.

Confirming it took

The one string that proves it is Auth token: ANTHROPIC_AUTH_TOKEN. A line naming the base URL is printed whenever the variable is set, whichever credential is actually being used — it tells you the variable arrived, not that your requests did.

The fastest check needs no command: a client running on the pool bills as API usage rather than against a plan, and says so on the line it prints at startup. The authority is this end — GET /v1/requests shows the request or it never arrived.

From an editor

An editor points at https://api.megaloop.dev/v1 — with the /v1, because the editor appends the rest of the path itself. Get it wrong and the error names the correct URL back to you.

Then add the models by hand, under whatever the editor calls a custom model. Use the `megaloop-` names, exactly as listed under Cursor above — an editor will refuse to add a model it already ships, and the built-in it offers instead goes to its own servers rather than to your subscriptions. That failure is silent: no error, the request simply never reaches the pool. Copy a name from the list; only advertised aliases are supported.

GET /v1/models lists every name your key can use, aliases included. A model on your own hardware is typed under the name you pulled it as.

From an agent

megaloop-mcp is a stdio MCP server. Requires node 20 or newer; nothing to clone or build. Pick your client below and swap YOUR_KEY for a key from Keys.

How it authenticates

Mint the key on Keys with the Read and serve option — most tools read your account, so an inference-only key is refused by them. Set it as MEGALOOP_API_KEY; the server sends it as an x-api-key header to https://megaloop.dev. No OAuth step.

The three linking tools, mint_key and revoke_key need Full access. Give the server one only if it should link accounts or rotate keys.

The key is read once from the environment and sent only in that header — never to a log line, an error message, or a tool result. Revoking it on Keys stops the tools working.

Leave MEGALOOP_BASE_URL unset. It defaults to the management API; pointing it at the inference host breaks every tool.

Installing it

claude mcp add megaloop --env MEGALOOP_API_KEY=YOUR_KEY -- npx -y megaloop-mcp

# ~/.codex/config.toml
[mcp_servers.megaloop]
command = "npx"
args = ["-y", "megaloop-mcp"]
env = { MEGALOOP_API_KEY = "YOUR_KEY" }

{
  "mcpServers": {
    "megaloop": {
      "command": "npx",
      "args": ["-y", "megaloop-mcp"],
      "env": { "MEGALOOP_API_KEY": "YOUR_KEY" }
    }
  }
}

To verify, ask the agent “what is in my megaloop pool?” — it should call get_status. If no megaloop tools appear at all, the host has not restarted since the config changed.

What it can then do

Nineteen tools. Start with help, which maps each question to the tool that answers it. get_status returns the whole pool in one call; get_limits returns every subscription’s remaining headroom side by side.

There is no unlink tool: unlinking is Session only, so a tool for it could only fail.

Linking a subscription over the API

Two calls with a person in between — for when whoever owns the subscription is not the one running the code.

1. Call link/start. You get an authorize_url and a link_session_id, good for ten minutes.
2. Send them the URL. They approve in a browser and are handed something back.
3. Call link/complete with the session id and whatever they were handed, verbatim.

curl -X POST https://megaloop.dev/v1/accounts/link/start \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "content-type: application/json" \
  -d '{"provider":"<id from /v1/providers>","name":"my-account"}'

# -> { "link_session_id": "...", "authorize_url": "https://...", "expires_at": "..." }

curl -X POST https://megaloop.dev/v1/accounts/link/complete \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "content-type: application/json" \
  -d '{"link_session_id":"...","code":"<exactly what they pasted>"}'

What the user is handed back differs per provider — a short code, or a whole URL. Do not guess: GET /v1/providers carries the exact wording to show them in paste_prompt. Pass their answer through verbatim, untrimmed.

Providers that take a key rather than a browser approval skip all of this. One call to link/direct.

The endpoints

Management calls go to https://megaloop.dev; inference goes to https://api.megaloop.dev. Errors are JSON with a stable code — branch on that, not the message. A resource owned by someone else and one that never existed both answer 404.

Each row names the capability it needs. Without it: 403. Session only means no key can call it at all: 401.