The Everpod API

Make a key

1. Open everpod.ai/account/keys and sign in with your email address and the code we send you. If you have no account yet, signing in makes one.
2. Name the key after what will use it, and make it.
3. Copy the key. It starts with everpod_.

We show a key once, when you make it, and keep no copy of it. You can revoke a key in your account at any time, and anything using it stops working at once. A key is not a way to sign in. Whoever holds a key can use it, so keep it secret. Give each agent or app a key of its own, so that revoking one leaves the others working.

What a key can do

Three operations. An agent you connect has each as a tool, with the description shown here, and a script calls each as a route.

• List pods (list_pods, GET /api/v1/pods): List the pods on the owner's Everpod account, oldest first. Each has its kind, its status and the link its owner needs: pay_url while it is awaiting payment, url (the pod's page on everpod.ai) once it is paid.
• Get a pod (get_pod, GET /api/v1/pods/{id}): Read one pod by its id: its status and the link its owner needs. This is how to check whether a started pod has been paid for, whether it is ready, and for a developer pod, which of its owner's steps to connect it are done.
• Start a pod (start_pod, POST /api/v1/pods): Start a new pod for the owner: an OpenClaw pod, or with kind 'developer' a developer pod. This call charges nothing: the pod stays unpaid until its owner opens pay_url in their browser and pays there. While the account has an unpaid pod, calling again returns that same pod, changed to the name and kind now asked for.

A pod is one of two kinds: a developer pod, a cloud computer you run yourself, with your pick of Claude Code, Codex, OpenCode, Pi, Hermes and OpenClaw installed, or an OpenClaw pod, OpenClaw set up and run for you on a computer of its own. The OpenClaw among a developer pod’s agents is the same agent installed for you to run yourself, not the OpenClaw pod. An agent starts either. What a pod costs is on the page where you pay for it, on the developer pod’s page, and on everpod.ai for an OpenClaw pod.

Connect an agent

An MCP client connects to https://everpod.ai/mcp over HTTP and sends the key as the header Authorization: Bearer YOUR_KEY. Each tool tells the agent what it does and which link to give you, so it can tell you where to pay and where to open your pod.

Claude Code

claude mcp add --transport http --scope user everpod https://everpod.ai/mcp \
  --header "Authorization: Bearer YOUR_KEY"

Codex

export EVERPOD_API_KEY=YOUR_KEY
codex mcp add everpod --url https://everpod.ai/mcp \
  --bearer-token-env-var EVERPOD_API_KEY

Codex reads the key from that environment variable each time it starts, so set it in the shell Codex runs in.

OpenClaw

openclaw mcp set everpod '{"url": "https://everpod.ai/mcp",
  "transport": "streamable-http",
  "headers": {"Authorization": "Bearer YOUR_KEY"}}'

An OpenClaw agent can run this itself, and has the tools from its next message. Or install the Everpod skill from ClawHub, and the agent connects itself, starts a new agent or a developer pod for you, and prepares its own move onto a pod: openclaw skills install @everpod/everpod.

Another MCP client

Give it the address and the header. As a JSON entry, in the form Claude Code’s .mcp.json takes, with the key read from an environment variable so that it is never written into a file you share:

{
  "mcpServers": {
    "everpod": {
      "type": "http",
      "url": "https://everpod.ai/mcp",
      "headers": { "Authorization": "Bearer ${EVERPOD_API_KEY}" }
    }
  }
}

Then ask the agent, for example:

Start an Everpod pod called Otto and tell me where to pay.

Start an Everpod developer pod called atlas, with alex as my username, and tell me where to pay.

Get a developer pod with your agent

A coding agent on your own computer, such as Claude Code or Codex, can take you from nothing to a developer pod you are logged in to. It needs a key, and it does not need the MCP server: the REST routes below do the same from a shell. The steps that open the machine are yours.

1. You make a key in your Everpod account and give it to your agent.
2. Your agent starts the pod with the name you want for the machine, your username on it, which of Claude Code, Codex, OpenCode, Pi, Hermes and OpenClaw you want installed (Claude Code and Codex, unless you say) and which size, S, M or L (the S, unless you say), and gives you the link where you pay.
3. About 10 minutes after you pay, the machine is built, and we email you.
4. On the pod’s page, you join the machine to your Tailscale network, signing in with the same Tailscale account as the laptop or phone you will log in from, which needs Tailscale installed too. You open the sign-in link there yourself: whoever signs in adds the machine to their network, so the link is shown only on that page, to you, and a key never carries it.
5. You switch off the machine’s key expiry in Tailscale’s admin console. Tailscale otherwise drops a machine from your network after 180 days by default, and after the hand-over that network is the only way in.
6. You log in over Tailscale SSH from that device (ssh you@your-machine, with no key or password: Tailscale checks it is you, which can mean confirming in your browser); an agent on that device can run it for you. Tailscale’s default rules let you in; a network with rules of its own needs one that lets you SSH into the machine, and so does a tagged machine, which the default rule does not cover.
7. Once you have joined the machine to your Tailscale network, switched off its key expiry and logged in, we remove the access we used to set it up.
8. On the machine, you run claude, codex, opencode or pi, whichever you chose, and sign in with your own subscription or API key (Pi with /login, typed once it is running); Hermes starts with hermes setup and OpenClaw with openclaw onboard --install-daemon, each asking for your own model key or plan, and both are yours to run and update. You chose only what comes installed: the computer is yours to administer, and any agent installs or comes off later, as on a laptop.

Between those steps the agent reads the pod: its status says whether it is paid, built and connected, and machine says which of your steps are done and gives the username and the machine’s name on your network, so it can tell you what is left or log in for you.

For an agent that takes skills, the same steps are a skill, everpod-developer-pod, from github.com/everpod-ai/skills. Claude Code and Codex each install it with two commands; for another agent, copy its folder into the agent’s skills folder.

# Claude Code
claude plugin marketplace add everpod-ai/skills
claude plugin install everpod-developer-pod@everpod

# Codex
codex plugin marketplace add everpod-ai/skills
codex plugin add everpod-developer-pod@everpod

Call it from code

The same three operations over HTTPS. Every request carries the key as Authorization: Bearer YOUR_KEY, and requests and answers are JSON. The list answers { "pods": [...] }; reading or starting a pod answers { "pod": {...} }. Starting one takes { "name": "..." }, the name you want for the pod’s agent, up to 40 characters. A developer pod also takes "kind": "developer" and "login", your username on the machine, and its name is the machine’s, which is also its name on your network. It may take "agents", which coding agents come installed, one or more of "claude" (Claude Code), "codex" (Codex), "opencode" (OpenCode), "pi" (Pi), "hermes" (Hermes) and "openclaw" (OpenClaw, the same agent installed for its owner to run themselves, not the OpenClaw pod); left out, Claude Code and Codex come installed. And "size": "s", "m" or "l", the sizes on the developer pod’s page with their prices; left out, the S. A size is changed later by you, from the pod’s settings, where the change is paid for: a key never moves money.

export EVERPOD_API_KEY=YOUR_KEY

curl https://everpod.ai/api/v1/pods \
  -H "Authorization: Bearer $EVERPOD_API_KEY"

curl -X POST https://everpod.ai/api/v1/pods \
  -H "Authorization: Bearer $EVERPOD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "Otto"}'

curl -X POST https://everpod.ai/api/v1/pods \
  -H "Authorization: Bearer $EVERPOD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "atlas", "kind": "developer", "login": "alex"}'

Client libraries

For JavaScript and Python, a client library makes the same three calls, with no dependencies. A refused request becomes an error carrying the API’s code, status and sentence.

npm install @everpod-ai/sdk
pip install everpod-ai

Each one’s page shows how to use it: @everpod-ai/sdk on npm and everpod-ai on PyPI.

A pod

{
  "pod": {
    "id": "5f0c1a52-8f1e-4d0b-9a57-3f6f2f7c1e9a",
    "name": "Otto",
    "kind": "openclaw",
    "status": "awaiting_payment",
    "created_at": "2026-10-03T09:12:44.512345+00:00",
    "url": null,
    "pay_url": "https://everpod.ai/create?pod=5f0c1a52-8f1e-4d0b-9a57-3f6f2f7c1e9a",
    "plan": null,
    "machine": null,
    "subscription": null
  }
}

• id: the pod’s id, which reading one pod takes.
• name: the name of the pod’s agent, or of a developer pod’s machine.
• kind: openclaw for an OpenClaw pod, or developer for a developer pod.
• status: one of the statuses below.
• created_at: when the pod was started.
• pay_url: where the pod is paid for, by its owner in a browser, with its price. Present while the status is awaiting_payment, and null after.
• url: the pod’s page on everpod.ai, where its signed-in owner opens an OpenClaw pod’s control panel and connects a messaging app, or connects a developer pod, and manages the plan. Null until the pod is paid for.
• plan: the plan the pod is on, base (dev_s, dev_m or dev_l for a developer pod, by its size) when it is first paid for. Null until then.
• machine: null for an OpenClaw pod. For a developer pod, its size (size, with its vcpu, ram_gb and disk_gb), your username on it (login), the coding agents that come installed (agents, as you chose when starting it; Claude Code and Codex when nobody chose), its name on your Tailscale network once it has joined (hostname, null until then), and whether its key expiry is switched off (key_expiry_off) and you have logged in (logged_in):

  "machine": {
    "size": "s",
    "vcpu": 4,
    "ram_gb": 8,
    "disk_gb": 80,
    "login": "alex",
    "agents": ["claude", "codex"],
    "hostname": "atlas",
    "key_expiry_off": false,
    "logged_in": false
  }

• subscription: its status, when the paid period ends (current_period_end), and whether it is set to end then (cancel_at_period_end). Null until the pod is paid for.

Pod status

• awaiting_payment: named, and waiting for its owner to pay at pay_url.
• building: paid, and its computer is being set up. Setup usually takes about 15 minutes for an OpenClaw pod and about 10 for a developer pod; its page (url) shows where this one is, and its owner gets an email when setup is done.
• setup_delayed: setup stopped partway on Everpod's side. Everpod is alerted and will fix it, and setup then carries on from where it stopped. Nothing is needed from the owner, who gets an email when setup is done.
• awaiting_connection: a developer pod that is built, and waiting for its owner to connect it. On its page (url), signed in, they join it to their own Tailscale network; then they switch off its key expiry in Tailscale's admin console and log in over Tailscale SSH. machine says which of these are done. Everpod then removes its own setup access, and the pod is ready.
• ready: an OpenClaw pod is awake: url is its page on everpod.ai, where its signed-in owner opens the agent's control panel and connects a messaging app. A developer pod is in its owner's hands: they reach it over their Tailscale network with ssh, as the login and hostname in machine, and sign in to the agents installed on it (machine.agents).
• needs_attention: was running and has a problem. Its page (url) says what.
• stopped: its subscription ended. Its page (url) says what happens next.

When a request is refused

A refusal answers with a code and a message. The message says what happened and what to do next, in words an agent can pass on to you; over MCP the same message arrives as the tool’s error.

{
  "error": {
    "code": "not_found",
    "message": "No pod with that id on this account."
  }
}

• unauthorized (401): the request carried no key, or one that does not work: mistyped, or revoked.
• rate_limited (429): requests are arriving too quickly. The message says how long to wait.
• not_found (404): No pod with that id on this account.
• name_required (400): A pod needs a name: send a 'name', the name the owner wants for their agent, or for a developer pod's machine.
• kind_unknown (400): A pod's 'kind' is 'openclaw' or 'developer'. Leave it out for an OpenClaw pod.
• login_invalid (400): A developer pod needs a 'login', the username its owner will have on the machine: lowercase letters and numbers, starting with a letter, 31 characters at most. A few names the system already uses, such as root and admin, are taken.
• invalid_body (400): The request body must be JSON.
• server_error (500): Something went wrong on Everpod's side. Try again in a minute; support@everpod.ai if it keeps happening.

Questions

Anything about the API: support@everpod.ai. How your account and your keys are protected is in the Security overview. Everpod as a whole, both kinds of pod and every guide, in one plain-text file: everpod.ai/llms.txt.