rent.dev

以預付餘額按秒計費的 Linux 沙箱,以及使用您自己的 RunPod 金鑰的 GPU Pod。

託管 MCP 伺服器

npx add-mcp 'https://mcp.rent.dev/mcp'

可安裝到 Claude Code、Codex、Cursor 等客戶端

文件

MCP server

An agent that speaks MCP connects without a key and gets the same account, sandboxes and payments as 35 tools: the ones that need no account run at once, and the others ask it to sign in or to call rent_signup.

POST https://mcp.rent.dev/mcp

Two endpoints

EndpointCredentialsTools
https://mcp.rent.dev/mcpNone to connect. An API key or an OAuth access token for the tools that need an account.35: the provider catalog, funds, sandboxes, GPU pods, the account and partner supply.
https://mcp.rent.dev/mcp/publicNone.rent_quote, rent_list_providers, rent_search_docs, rent_signup, rent_supply_guide

rent_list_providers answers with the catalog as compact summaries: each provider's capabilities, whether an agent can drive it, and the cheapest hourly price among its matching offerings. The whole catalog, with each row's region, source and date, is on the catalog page. A listed provider may be unpriced: its terms may permit display but not comparison, no price row may match the filters, or its rows may carry no hourly figure.

Both are stateless Streamable HTTP. Every request is a POST, there is no session to open or keep, and any other method answers 405.

Connect a client

Each client has two blocks for /mcp: first without a key, where the client signs in on first use if it can, then with an API key in place of rent_sk_…. A client whose docs give no way to send a key has the first block only, and signs in. A block for a file is merged into what it already holds. rent_signup takes the <client> id as client and answers that client's block with its new key. For claude, cursor, codex or stdio, rent mcp --client <client> prints it with the key rent init stored.

/mcp/public is for directories and callers that never sign in. It takes the block without a key, with that URL and the name rent-public; the stdio command takes --public.

Client<client>
Claude Codeclaude
Claude Desktop and claude.aiclaude-ai
ChatGPTchatgpt
Codexcodex
Cursorcursor
VS Code (GitHub Copilot)vscode
Visual Studio (GitHub Copilot)visualstudio
GitHub Copilot CLIcopilot
Gemini CLIgemini
Windsurf (Devin Desktop)windsurf
Clinecline
Zedzed
opencodeopencode
goosegoose
Qwen Codeqwen
Factory Droiddroid
Ampamp
Kirokiro
Warpwarp
Continuecontinue
Google Antigravityantigravity
Kilo Codekilo
Crushcrush
LM Studiolmstudio
Devindevin
Any other clienthttp
A client that only starts local (stdio) serversstdio

Claude Code

claude mcp add --transport http rent --scope user https://mcp.rent.dev/mcp

Sign in from /mcp in Claude Code, or run claude mcp login rent.

claude mcp add --transport http rent --scope user https://mcp.rent.dev/mcp --header 'Authorization: Bearer rent_sk_…'

Docs: code.claude.com/docs/en/mcp.

Claude Desktop and claude.ai

Where it goes: Customize > Connectors > Add > Add custom connector.

Name: rent
MCP server URL: https://mcp.rent.dev/mcp
Authentication: Sign in when needed
Name: rent
MCP server URL: https://mcp.rent.dev/mcp
Authentication: No sign-in
Request headers: authorization, value Bearer rent_sk_…

Request headers is in beta for some organizations; where the dialog lacks it, use the form without a key.

A connector is turned on per conversation, under + > Connectors.

Docs: claude.com/docs/connectors/custom/add-unlisted.

ChatGPT

Where it goes: Plugins > + > Add custom MCP server, in ChatGPT on the web.

Name: rent
Server URL: https://mcp.rent.dev/mcp
Authentication: OAuth or no authentication

ChatGPT signs in to your rent.dev account and takes no API key. Select I understand and want to continue, then Create as a plugin. ChatGPT starts the OAuth sign-in the first time a tool that needs an account is called.

Install the plugin it creates, then type @ in the prompt box and select it. Full MCP, write tools included, is for Business and Enterprise/Edu workspaces; Pro connects read and fetch tools only.

Docs: developers.openai.com/api/docs/guides/custom-mcp-server, help.openai.com/en/articles/12584461, developers.openai.com/plugins/build/auth.

Codex

Where it goes: ~/.codex/config.toml.

[mcp_servers.rent]
url = "https://mcp.rent.dev/mcp"

Run codex mcp login rent.

[mcp_servers.rent]
url = "https://mcp.rent.dev/mcp"
http_headers = { Authorization = "Bearer rent_sk_…" }

Docs: developers.openai.com/codex/mcp.

Cursor

Where it goes: ~/.cursor/mcp.json.

{
  "mcpServers": {
    "rent": {
      "url": "https://mcp.rent.dev/mcp"
    }
  }
}
{
  "mcpServers": {
    "rent": {
      "url": "https://mcp.rent.dev/mcp",
      "headers": {
        "Authorization": "Bearer rent_sk_…"
      }
    }
  }
}

Docs: cursor.com/docs/mcp.

VS Code (GitHub Copilot)

Where it goes: ~/.copilot/mcp-config.json.

{
  "mcpServers": {
    "rent": {
      "type": "http",
      "url": "https://mcp.rent.dev/mcp",
      "tools": [
        "*"
      ]
    }
  }
}

Sign in when VS Code asks, or with Authenticate in the server's actions.

{
  "mcpServers": {
    "rent": {
      "type": "http",
      "url": "https://mcp.rent.dev/mcp",
      "headers": {
        "Authorization": "Bearer rent_sk_…"
      },
      "tools": [
        "*"
      ]
    }
  }
}

Docs: code.visualstudio.com/docs/agents/reference/mcp-configuration.

Visual Studio (GitHub Copilot)

Where it goes: %USERPROFILE%.mcp.json.

{
  "servers": {
    "rent": {
      "url": "https://mcp.rent.dev/mcp"
    }
  }
}

Visual Studio signs in to your rent.dev account and takes no API key. Select Manage Authentication for the server from the CodeLens in the file, then sign in in the browser pop-up.

Saving the file reloads the servers. Their tools start disabled: turn them on in the chat's tool picker, in Agent mode.

Docs: learn.microsoft.com/en-us/visualstudio/ide/mcp-servers.

GitHub Copilot CLI

copilot mcp add --transport http rent https://mcp.rent.dev/mcp

Sign in with /mcp auth rent in Copilot CLI.

copilot mcp add --transport http --header 'Authorization: Bearer rent_sk_…' rent https://mcp.rent.dev/mcp

In a running session, /mcp add with the same name, URL and header makes it available at once, with no restart.

Docs: docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/add-mcp-servers, docs.github.com/en/copilot/reference/copilot-cli-reference/cli-command-reference.

Gemini CLI

gemini mcp add --scope user --transport http rent https://mcp.rent.dev/mcp

Sign in with /mcp auth rent in Gemini CLI.

gemini mcp add --scope user --transport http --header 'Authorization: Bearer rent_sk_…' rent https://mcp.rent.dev/mcp

Gemini CLI connects to MCP servers, user-level ones included, only in a folder you have trusted: choose Trust folder when it asks, or run /permissions trust in that folder.

Docs: github.com/google-gemini/gemini-cli/blob/main/docs/tools/mcp-server.md, github.com/google-gemini/gemini-cli/blob/main/docs/cli/trusted-folders.md.

Windsurf (Devin Desktop)

Where it goes: ~/.config/devin/mcp_config.json.

{
  "mcpServers": {
    "rent": {
      "url": "https://mcp.rent.dev/mcp"
    }
  }
}

It asks you to sign in the first time the server is used.

{
  "mcpServers": {
    "rent": {
      "url": "https://mcp.rent.dev/mcp",
      "headers": {
        "Authorization": "Bearer rent_sk_…"
      }
    }
  }
}

After adding it, refresh the server list: Customize > MCPs, or the refresh button in Cascade's MCP menu.

Docs: docs.devin.ai/desktop/devin-local/customizations, docs.devin.ai/windsurf/plugins/cascade/mcp, docs.devin.ai/cli/extensibility/mcp/configuration.

Cline

Where it goes: ~/.cline/data/settings/cline_mcp_settings.json for the CLI; in the IDE, the file MCP Servers > Configure > Configure MCP Servers opens.

{
  "mcpServers": {
    "rent": {
      "type": "streamableHttp",
      "url": "https://mcp.rent.dev/mcp"
    }
  }
}

Sign in with Authorize OAuth in cline mcp.

{
  "mcpServers": {
    "rent": {
      "type": "streamableHttp",
      "url": "https://mcp.rent.dev/mcp",
      "headers": {
        "Authorization": "Bearer rent_sk_…"
      }
    }
  }
}

Docs: docs.cline.bot/mcp/mcp-overview.

Zed

Where it goes: ~/.config/zed/settings.json.

{
  "context_servers": {
    "rent": {
      "url": "https://mcp.rent.dev/mcp"
    }
  }
}

Zed asks you to sign in with OAuth.

{
  "context_servers": {
    "rent": {
      "url": "https://mcp.rent.dev/mcp",
      "headers": {
        "Authorization": "Bearer rent_sk_…"
      }
    }
  }
}

Docs: zed.dev/docs/ai/mcp, zed.dev/docs/configuring-zed.

opencode

opencode mcp add rent --global --url https://mcp.rent.dev/mcp

Sign in with opencode mcp auth rent, or from /mcps in opencode.

opencode mcp add rent --global --url https://mcp.rent.dev/mcp --header 'Authorization=Bearer rent_sk_…'

Docs: opencode.ai/docs/mcp-servers/.

goose

Where it goes: ~/.config/goose/config.yaml.

extensions:
  rent:
    type: streamable_http
    name: rent
    enabled: true
    uri: "https://mcp.rent.dev/mcp"
    timeout: 300
extensions:
  rent:
    type: streamable_http
    name: rent
    enabled: true
    uri: "https://mcp.rent.dev/mcp"
    headers:
      Authorization: "Bearer rent_sk_…"
    timeout: 300

A change to the file applies to new sessions, not to a running one.

Docs: goose-docs.ai/docs/guides/config-files.

Qwen Code

qwen mcp add --scope user --transport http rent https://mcp.rent.dev/mcp

Sign in from the /mcp dialog in Qwen Code.

qwen mcp add --scope user --transport http rent https://mcp.rent.dev/mcp --header 'Authorization: Bearer rent_sk_…'

A session that was already running needs a restart to use it.

Docs: github.com/QwenLM/qwen-code/blob/main/docs/users/features/mcp.md.

Factory Droid

droid mcp add rent https://mcp.rent.dev/mcp --type http

Sign in from /mcp in Droid.

droid mcp add rent https://mcp.rent.dev/mcp --type http --header 'Authorization: Bearer rent_sk_…' --no-oauth

Droid reloads when its mcp.json changes: a running session can use it at once.

Docs: docs.factory.com/harness/mcp.

Amp

Where it goes: ~/.config/amp/settings.json.

{
  "amp.mcpServers": {
    "rent": {
      "url": "https://mcp.rent.dev/mcp"
    }
  }
}
{
  "amp.mcpServers": {
    "rent": {
      "url": "https://mcp.rent.dev/mcp",
      "headers": {
        "Authorization": "Bearer rent_sk_…"
      }
    }
  }
}

A running thread loads it when MCP is reloaded: the Reload MCP command, or the reload_mcp tool.

Docs: ampcode.com/docs/customize/mcp.

Kiro

Where it goes: ~/.kiro/settings/mcp.json.

{
  "mcpServers": {
    "rent": {
      "url": "https://mcp.rent.dev/mcp"
    }
  }
}
{
  "mcpServers": {
    "rent": {
      "url": "https://mcp.rent.dev/mcp",
      "headers": {
        "Authorization": "Bearer rent_sk_…"
      }
    }
  }
}

Kiro reloads the file on save: a running session uses it from its next turn.

Docs: kiro.dev/docs/mcp/configuration/.

Warp

Where it goes: Settings > Agents > MCP servers > + Add.

{
  "mcpServers": {
    "rent": {
      "url": "https://mcp.rent.dev/mcp"
    }
  }
}
{
  "mcpServers": {
    "rent": {
      "url": "https://mcp.rent.dev/mcp",
      "headers": {
        "Authorization": "Bearer rent_sk_…"
      }
    }
  }
}

Docs: docs.warp.dev/agents/capabilities/mcp/.

Continue

Where it goes: ~/.continue/config.yaml.

mcpServers:
  - name: rent
    type: streamable-http
    url: "https://mcp.rent.dev/mcp"
mcpServers:
  - name: rent
    type: streamable-http
    url: "https://mcp.rent.dev/mcp"
    requestOptions:
      headers:
        Authorization: "Bearer rent_sk_…"

Continue reloads config.yaml when you save it in the IDE. MCP tools work only in agent mode.

Docs: docs.continue.dev/customize/deep-dives/mcp, docs.continue.dev/reference, docs.continue.dev/customize/deep-dives/configuration.

Google Antigravity

Where it goes: ~/.gemini/config/mcp_config.json.

{
  "mcpServers": {
    "rent": {
      "serverUrl": "https://mcp.rent.dev/mcp"
    }
  }
}

In the Antigravity App, choose Authenticate next to the server under Customizations > Installed > MCP Servers, then paste the code the browser shows into Enter authorization code.

{
  "mcpServers": {
    "rent": {
      "serverUrl": "https://mcp.rent.dev/mcp",
      "headers": {
        "Authorization": "Bearer rent_sk_…"
      }
    }
  }
}

Docs: antigravity.google/docs/mcp.

Kilo Code

Where it goes: ~/.config/kilo/kilo.jsonc.

{
  "mcp": {
    "rent": {
      "type": "remote",
      "url": "https://mcp.rent.dev/mcp"
    }
  }
}

Kilo Code starts the OAuth sign-in when it connects; in VS Code, choose the notification it shows.

{
  "mcp": {
    "rent": {
      "type": "remote",
      "url": "https://mcp.rent.dev/mcp",
      "headers": {
        "Authorization": "Bearer rent_sk_…"
      }
    }
  }
}

Docs: kilo.ai/docs/automate/mcp/using-in-kilo-code.

Crush

Where it goes: ~/.config/crush/crush.json.

{
  "mcp": {
    "rent": {
      "type": "http",
      "url": "https://mcp.rent.dev/mcp"
    }
  }
}

To sign in with OAuth, add "oauth": true to the entry.

{
  "mcp": {
    "rent": {
      "type": "http",
      "url": "https://mcp.rent.dev/mcp",
      "headers": {
        "Authorization": "Bearer rent_sk_…"
      }
    }
  }
}

Docs: github.com/charmbracelet/crush/blob/main/docs/config/README.md, github.com/charmbracelet/crush/blob/main/README.md, github.com/charmbracelet/crush/blob/main/schema.json.

LM Studio

Where it goes: mcp.json, from the Program tab > Install > Edit mcp.json.

{
  "mcpServers": {
    "rent": {
      "url": "https://mcp.rent.dev/mcp"
    }
  }
}

LM Studio opens the sign-in page in a browser.

{
  "mcpServers": {
    "rent": {
      "url": "https://mcp.rent.dev/mcp",
      "headers": {
        "Authorization": "Bearer rent_sk_…"
      }
    }
  }
}

Docs: lmstudio.ai/docs/app/mcp, lmstudio.ai/docs/integrations/mcp-remote.

Devin

Where it goes: Customize > MCPs > Add MCP > Add custom MCP, which needs the Manage MCP Servers permission.

Server Name: rent
Short Description: rent.dev
Transport: HTTP
Server URL: https://mcp.rent.dev/mcp
Authentication method: OAuth
Access: Personal

Save it, then choose Connect on the server in Customize > MCPs to sign in.

Server Name: rent
Short Description: rent.dev
Transport: HTTP
Server URL: https://mcp.rent.dev/mcp
Authentication method: Auth Header
Header key: Authorization
Header value: Bearer rent_sk_…

Test tools on the server's page checks that Devin connects and lists its tools.

Docs: docs.devin.ai/work-with-devin/mcp.

Any other client

Where it goes: The client's settings for a remote server.

URL: https://mcp.rent.dev/mcp
Transport: Streamable HTTP

A client that implements MCP authorization signs in with OAuth when a tool that needs an account answers 401.

URL: https://mcp.rent.dev/mcp
Transport: Streamable HTTP
Header: Authorization: Bearer rent_sk_…

Docs: modelcontextprotocol.io/specification/2025-11-25/basic/transports, modelcontextprotocol.io/specification/2025-11-25/basic/authorization.

A client that only starts local (stdio) servers

Where it goes: The client's command for a local (stdio) server.

RENT_MCP_URL=https://mcp.rent.dev/mcp npx -y rentdev mcp --stdio

It sends the key rent init stored, or RENT_API_KEY; with neither it serves the public tools.

RENT_MCP_URL=https://mcp.rent.dev/mcp RENT_API_KEY='rent_sk_…' npx -y rentdev mcp --stdio

Docs: modelcontextprotocol.io/docs/develop/connect-local-servers.

After rent_signup

No key yet? A client with OAuth sign-in signs in the first time it calls a tool that needs an account, and a passkey creates the account. Any client can call rent_signup instead, here or on the public endpoint: it answers the key once. Pass idempotency_key, a random value you keep, to repeat the call without making a second account.

Then go on at once over REST with that key: send it as Authorization: Bearer rent_sk_… to https://api.rent.dev, for example POST /v1/sandboxes. With client, the answer's reconnect is your client's block with the key in it: a client that adds a server mid-session uses it at once, and any other from its next session.

curl -s https://mcp.rent.dev/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "MCP-Protocol-Version: 2025-11-25" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'

The answer comes back as JSON or as an event stream with one message.

Authentication

/mcp takes the credentials the REST API takes: Authorization: Bearer rent_sk_…, X-API-Key, or an OAuth access token issued for the resource https://mcp.rent.dev/mcp. Each tool states what it needs in _meta.securitySchemes: noauth, or oauth2 with its scope. Every tool with a scope needs an account, and so does rent_get_operation, whose Scope reads account only in the tools table; to a caller without credentials their descriptions open by saying so.

Such a tool called without credentials answers 401 before it runs. The WWW-Authenticate challenge points at the protected-resource metadata (RFC 9728), and its scope names what to sign in for: sandbox gpu billing keys, plus the tool's own scope when it is another (supply for the partner supply tools). A credential that is unknown, expired or revoked answers 401 invalid_token whatever the call.

Each tool checks its scope before it runs. An API key has every scope but supply, so the partner supply tools need an OAuth token that carries it; an API key gets a forbidden result from them. An OAuth token that lacks a scope gets a 403 insufficient_scope challenge naming the scope to ask for.

A request that carries a browser Origin must come from this server's origin, from the site's, or from localhost when the endpoint itself is local. Any other origin answers 403.

Protocol versions

The server speaks MCP 2026-07-28: server/discover, and the client's version, capabilities and name in each request's _meta. A client on an earlier revision negotiates with initialize; these are accepted: 2025-11-25, 2025-06-18, 2025-03-26, 2024-11-05, 2024-10-07.

A tools/list answer may be kept for 5 minutes (ttlMs).

A typical session

  1. rent_quote: what a task costs.
  2. rent_get_balance, and rent_topup when it is short.
  3. rent_create_sandbox.
  4. rent_exec, or rent_start_process for work that outlasts one call.
  5. rent_terminate_sandbox.

Tools on /mcp

ToolWhat it doesScopeHints
rent_quoteQuote sandbox pricesnoneread-only, idempotent
rent_list_providersList providersnoneread-only, idempotent
rent_search_docsSearch the rent.dev docsnoneread-only, idempotent
rent_signupSign upnonenone
rent_supply_guideRead the provider guidenoneread-only, idempotent
rent_get_balanceGet the balancebillingread-only, idempotent
rent_topupTop up the balancebillingopen world
rent_create_sandboxCreate a sandboxsandboxopen world
rent_get_sandboxGet a sandboxsandboxread-only, idempotent
rent_list_sandboxesList sandboxessandboxread-only, idempotent
rent_execRun a commandsandboxdestructive, open world
rent_start_processStart a background processsandboxdestructive, open world
rent_get_process_outputRead process outputsandboxread-only, idempotent, open world
rent_run_codeRun code in a kernelsandboxdestructive, open world
rent_read_fileRead a filesandboxread-only, idempotent, open world
rent_write_fileWrite a filesandboxdestructive, idempotent, open world
rent_get_port_urlGet a port URLsandboxread-only, idempotent
rent_extend_sandboxExtend a sandboxsandboxidempotent, open world
rent_pause_sandboxPause a sandboxsandboxidempotent, open world
rent_resume_sandboxResume a sandboxsandboxidempotent, open world
rent_terminate_sandboxTerminate a sandboxsandboxdestructive, idempotent, open world
rent_create_gpu_podCreate a GPU podgpuopen world
rent_list_gpu_podsList GPU podsgpuread-only, idempotent, open world
rent_terminate_gpu_podTerminate a GPU podgpudestructive, idempotent, open world
rent_set_byok_credentialStore a vendor keykeysopen world
rent_get_usageGet usagebillingread-only, idempotent, open world
rent_get_operationGet an operationaccount onlyread-only, idempotent
rent_supply_enrollEnrol nodessupplynone
rent_supply_nodesList your nodessupplyread-only, idempotent
rent_supply_nodeGet a nodesupplyread-only, idempotent
rent_supply_update_nodeChange a nodesupplyidempotent
rent_supply_probe_nodeProbe a node nowsupplyopen world
rent_supply_revoke_nodeRevoke a nodesupplydestructive, idempotent, open world
rent_supply_earningsGet your earningssupplyread-only, idempotent
rent_supply_payoutsList your payoutssupplyread-only, idempotent

rent_quote

Dollars per completed task for rent.dev's own sandboxes beside every published-rate vendor, by workload profile, plus hourly GPU rows. Defaults: all three profiles, 2 vCPU, 4096 MiB. A quote is a price list, not a reservation; it holds nothing.

rent_list_providers

Lists rent.dev's provider catalog as compact summaries: each provider's capabilities (offerings, pricing types, interfaces, auth and product capabilities), display-only summary_verdict, agentic flag, the provenance of its cheapest matched offering and that offering's price row. Read-only; needs no account. A listed provider may be unpriced: its terms may permit display but not comparison (clause names that denial and its prices are withheld), no price row may match the filters, or its rows may carry no hourly figure (a GPU row then gives unpriced_reason: monthly_rate, no_time_unit or unknown_gpu_count; a per-unit row has usd and unit but no hourly figure). include_offerings carries every matching offering, not just the cheapest. use asserts a rights use on providers and figures (default display). limit caps providers only. Every offer carries covers, gpu.count, region_id and comparison_group: the group names the purchasable unit (GPU model, count, market, pricing type, canonical region and commitment), so two offers are price-comparable exactly when their groups match. region accepts the vendor's label or the canonical id; gpu_count, covers and figure narrow the grain.

rent_search_docs

Keyword search over the sections of rent.dev's full docs (llms-full.txt): each hit is one section, best first, with its heading path and Markdown. The docs are re-read every five minutes.

rent_signup

Creates a rent.dev account and answers its API key, shown this once (store it; it stays valid until revoked), with the MCP URL and the Authorization header that unlocks its account tools, and a three-line REST quickstart. Go on over REST with the key now: next_step creates a sandbox. reconnect is your MCP client's /mcp block with the key in it (pass client; without it, the generic URL and header): a client that can add a server or a header mid-session uses it at once, any other in its next session. To be able to retry, pass idempotency_key, a random value you keep (a UUID will do): if the answer is lost, call again with the same value within 24 hours and you get the same account with a new API key that replaces the first, not a second account. That holds while the account is untouched (its key never used, nothing bound to it, no money in); after that the repeat is refused with idempotency_key_reused and answers no key. Without idempotency_key every call creates a new account. The account starts with a zero balance unless a promotion gives it promotional credit (rent_get_balance shows it): a call that needs more credit than it has answers 402 with a card pay link and an x402 top-up, or use rent_topup with the key. While a limit is set, one network address can create only a limited number of free accounts in 24 hours; past it the call answers 429 signup_limit with retry_after.

rent_supply_guide

For someone who runs a machine, their own or a VPS rented elsewhere, and wants to sell its compute; to get a machine to use, rent a sandbox instead, with rent_create_sandbox on /mcp or POST /v1/sandboxes over REST. The guide for running a machine as a rent.dev node, as Markdown: whether supply is open on this deployment, the two ways to run a node, every step with its exact command, each node state and what to do next, every check with its fix, every problem, rates and the holdback. Read it before rent_supply_enroll. Needs no scope, and the public endpoint serves it too.

rent_get_balance

Your prepaid balance in micro-USD (1 USD = 1,000,000): total, held by running sandboxes, and available, the part of total that is promotional credit (it pays only for sandboxes on rent.dev's own machines), and whether the account is frozen.

rent_topup

method "card": answers a pay link for a person (valid 24 hours; Stripe Checkout, no API key needed). On clients that take URL elicitation the link is shown to the person first, then the tool answers it. method "x402": charges USDC over MCP with x402. The first call answers isError with the PaymentRequired object (amount = credits + 5.5%; sign within its maxTimeoutSeconds, 120 s); retry the same call with the PaymentPayload in _meta["x402/payment"]. The paid call settles, credits, and answers the SettleResponse in _meta["x402/payment-response"]. The balance shows card payments once Stripe confirms them; check with rent_get_balance.

rent_create_sandbox

Starts a Linux sandbox: this is how to get a VPS, server or VM to use on rent.dev. It holds its cost from your balance and is charged by the second while it runs. On rent.dev's own machines it is a Firecracker microVM; a partner's machine declares its own isolation, which may be a container. A sandbox ends at its timeout: timeout_s, default 300 seconds, at most 86400. At the timeout it stops, or pauses with auto_pause; rent_extend_sandbox moves the timeout and rent_terminate_sandbox ends it sooner. By default (active) it may run on a verified partner's machine; routing.partners: none keeps it on rent.dev's own machines and your own vendor keys. The operator of a partner machine can read what runs on it. Waits up to wait_s for placement and answers the sandbox; past that it answers an operation id (op_…) to poll with rent_get_operation, whose response is the sandbox. A short balance answers 402 insufficient_balance with a card pay link (valid 24 hours) and an x402 top-up URL. Arguments not listed here go to the REST route as they are, which refuses them by name.

rent_get_sandbox

One sandbox by id: state (requested, placing, running, paused, settling, terminated, failed), template, size, timeout_at, port-URL domain, and what it has been charged and holds.

rent_list_sandboxes

Your sandboxes, newest first. By default every state but terminated and failed; state picks one. next_cursor is opaque and only for the next call of this tool.

rent_exec

Runs a shell command (/bin/bash -l -c) in a running sandbox and answers when it exits: stdout, stderr, exit_code (null when killed by the timeout), timed_out. timeout_s defaults to 50, so the answer comes back inside common client tool timeouts. For work that runs longer (servers, builds, training), start it with rent_start_process and read its output with rent_get_process_output. Arguments not listed here go to the REST route as they are, which refuses them by name.

rent_start_process

Starts a command in the background and answers at once with its process id. The process id is valid while the sandbox runs; read its output with rent_get_process_output. The process ends with the sandbox. Arguments not listed here go to the REST route as they are, which refuses them by name.

rent_get_process_output

Output of a background process after a cursor, whether it still runs, and its exit code. Omit cursor to read from the start; pass the answer's cursor back unchanged to read only newer output. Cursors and process ids are valid while the sandbox runs.

rent_run_code

Runs code on the Jupyter kernel of a code-interpreter-v1 sandbox and answers its rich results (text, images as base64, …), stdout, stderr and error. State persists between calls in one context_id; a context lives as long as the sandbox. timeout_s defaults to 50. Arguments not listed here go to the REST route as they are, which refuses them by name.

rent_read_file

Reads a file from a running sandbox. Without encoding the content comes back as UTF-8 text when it is valid UTF-8, else as base64.

rent_write_file

Writes a file in a running sandbox, creating parent directories and replacing what is there. content is UTF-8 text, or base64 with encoding base64.

rent_get_port_url

The public HTTPS URL of a port in the sandbox (https://{port}-{sandbox}.{domain}). It serves while the sandbox runs and something listens on the port.

rent_extend_sandbox

Sets a running sandbox to stop timeout_s seconds from now (at most 86400), holding the added cost first on the key that started it; a short balance answers 402 with top-up links. An API key with a spend limit cannot extend a sandbox another key started (403 forbidden).

rent_pause_sandbox

Pauses a running sandbox, keeping its memory and files; the id stays valid and rent_resume_sandbox continues it.

rent_resume_sandbox

Resumes a paused sandbox with a new timeout (default 300 s), holding its cost first on the key that started it; a short balance answers 402 with top-up links. An API key with a spend limit cannot resume a sandbox another key started (403 forbidden).

rent_terminate_sandbox

Ends a sandbox now, deleting its memory and files, and settles its charge. Terminating an ended sandbox answers it unchanged. The id keeps answering rent_get_sandbox.

rent_create_gpu_pod

Starts a GPU pod on RunPod with your own RunPod key (store it with rent_set_byok_credential, vendor runpod). RunPod bills your key by the hour until rent_terminate_gpu_pod; no rent.dev balance is used. The pod id (lse_…) lives until it is terminated. Arguments not listed are refused by name. When RunPod is out of that GPU type it answers 503 no_capacity with retry_after and the pod is listed failed; retry after that, or pick another RunPod GPU type from rent_quote, which may be in stock.

rent_list_gpu_pods

Your GPU pods, newest first, every state. next_cursor is opaque and only for the next call of this tool.

rent_terminate_gpu_pod

Ends a GPU pod on RunPod, deleting its container disk, and stops RunPod's billing. Terminating an ended pod answers it unchanged.

rent_set_byok_credential

Stores your own vendor key (BYOK) for e2b and vercel sandboxes or runpod GPU pods, after one read-only call to the vendor checks it. The secret is an argument of this call; it is stored sealed and never returned. fields: e2b {api_key}, vercel {token, team_id, project_id}, runpod {api_key}. The credential id (cred_…) stays valid until you delete it (DELETE /v1/byok/credentials/{id}). An API key with a spend limit cannot store one (403 forbidden): use an uncapped key or a signed-in person.

rent_get_usage

Usage over a period (default the last 30 days): what rent.dev billed for its own sandboxes, beside showback of BYOK usage your vendors bill you for.

rent_get_operation

A long-running operation by id (op_… or operations/op_…), as tools answer them for work that outlasts a call (sandbox placement, x402 settlement). Poll about every 2 s until done; then exactly one of response (the finished resource) or error (a Problem). The id stays readable after it is done.

rent_supply_enroll

For someone who runs a machine, their own or a VPS rented elsewhere, and wants to sell its compute; to get a machine to use, rent a sandbox instead, with rent_create_sandbox on /mcp or POST /v1/sandboxes over REST. Makes claim tokens for new nodes, one per node, each valid for 10 minutes and shown only in this answer. lines holds the exact shell line for each token: run it on the machine and the node kit sets the machine up, claims the node, links it and reports each step. The token reaches the kit on stdin, never as a process argument. On a host the claim comes after the install, and a first install can outlast the token: when the line ends with claim_invalid, call this tool again and run the same line with the new token. payout registers the USDC address every node of this enrolment is paid to; without it the nodes are not paid until one is set with rent_supply_update_node. Ask the user for the address; never make one up. Each node is paid once a day, in USDC, to the address registered on that node; a node without an address is not paid and its releasable earnings wait until one is registered. A payout cannot be reversed, and a payout made is never sent again to another address. A refusal carries retryable, owner_action_required and next; run next.command after next.after_s seconds, on a driver machine through npx and with its driver file, as rent_supply_guide says.

rent_supply_nodes

For someone who runs a machine, their own or a VPS rented elsewhere, and wants to sell its compute; to get a machine to use, rent a sandbox instead, with rent_create_sandbox on /mcp or POST /v1/sandboxes over REST. Your nodes, newest claim first, each with its state, checks and next step. next_cursor is only for the next call of this tool.

rent_supply_node

For someone who runs a machine, their own or a VPS rented elsewhere, and wants to sell its compute; to get a machine to use, rent a sandbox instead, with rent_create_sandbox on /mcp or POST /v1/sandboxes over REST. One of your nodes: state, wire, region, ask, capacity, templates, checks with their fixes, suspension reasons, placement, setup timings and payout, the address it is paid to (null while none is registered: the node is not paid). next names the one command to run and when; poll this until next.action is none.

rent_supply_update_node

For someone who runs a machine, their own or a VPS rented elsewhere, and wants to sell its compute; to get a machine to use, rent a sandbox instead, with rent_create_sandbox on /mcp or POST /v1/sandboxes over REST. Changes a node's ask, capacity, region or payout. A new ask applies to leases placed from now on; running leases keep their rates. More slots or a new region sends the node back to probing. payout is the USDC address this node is paid to from the next payout on; the node view shows it as payout, null while none is registered. Change it only when the user asks, with the address the user gave. Each node is paid once a day, in USDC, to the address registered on that node; a node without an address is not paid and its releasable earnings wait until one is registered. A payout cannot be reversed, and a payout made is never sent again to another address. Changing payout needs signed_nonce: a nonce from GET /v1/accounts/nonce, signed with your account's agent key over the message rent.dev payout v2\n<node_id>\n<nonce>\n<public_key>\n<network>\n<address> (six lines joined by newlines, no newline at the end). <address> is payout.address in lowercase. <network> is payout.network when you send it, else the payout network: payouts.network in rent_supply_earnings (while that is null, send payout.network and sign over it). Sign over exactly the address and network you send; a proof for another node, address or network is refused with payout_proof_required, and so is the old four-line message. A refusal carries retryable, owner_action_required and next; run next.command after next.after_s seconds, on a driver machine through npx and with its driver file, as rent_supply_guide says.

rent_supply_probe_node

For someone who runs a machine, their own or a VPS rented elsewhere, and wants to sell its compute; to get a machine to use, rent a sandbox instead, with rent_create_sandbox on /mcp or POST /v1/sandboxes over REST. Makes the node's next probe due now, and takes a suspended node back to probing. The probe starts within about a minute. Read the outcome with rent_supply_node. A probe already running is refused with probe_in_progress. A refusal carries retryable, owner_action_required and next; run next.command after next.after_s seconds, on a driver machine through npx and with its driver file, as rent_supply_guide says.

rent_supply_revoke_node

For someone who runs a machine, their own or a VPS rented elsewhere, and wants to sell its compute; to get a machine to use, rent a sandbox instead, with rent_create_sandbox on /mcp or POST /v1/sandboxes over REST. Takes a node out for good: it gets no new leases and its link is removed. A revoked node cannot come back; enrol the machine again for a new node. Revoking a revoked node answers it unchanged. A refusal carries retryable, owner_action_required and next; run next.command after next.after_s seconds, on a driver machine through npx and with its driver file, as rent_supply_guide says.

rent_supply_earnings

For someone who runs a machine, their own or a VPS rented elsewhere, and wants to sell its compute; to get a machine to use, rent a sandbox instead, with rent_create_sandbox on /mcp or POST /v1/sandboxes over REST. What your nodes have earned, in micro-USD (one micro-USD is one USDC base unit): totals and one page of entries, newest first. A lease shows once it settles, never while it runs. Each entry counts in exactly one total, named by its state: pending (in the holdback, which is longer when the customer paid by card), releasable (waiting for its node's next payout), frozen (never paid while frozen), in_payout (in an open payout, named by payout_id), paid (the chain shows its payout made). unaddressed_micros is the releasable part on nodes with no payout address on the payout network: register one with rent_supply_update_node. payouts says whether this environment pays, and on which network, token and wallet. Each node is paid once a day, in USDC, to the address registered on that node; a node without an address is not paid and its releasable earnings wait until one is registered. A payout cannot be reversed, and a payout made is never sent again to another address. rent_supply_payouts lists the payouts themselves. next_cursor is only for the next call of this tool.

rent_supply_payouts

For someone who runs a machine, their own or a VPS rented elsewhere, and wants to sell its compute; to get a machine to use, rent a sandbox instead, with rent_create_sandbox on /mcp or POST /v1/sandboxes over REST. The payouts to your nodes, newest first: node, amount in micro-USD (USDC base units), network, token, the wallet paid from, the address paid to, and the transaction once known. node keeps one node's payouts. state is open until the finalized chain shows the transfer made (paid) or its last authorization expired unused (void; its earnings go into a later payout). reason says why a payout is void, or what the last send was refused with. To check a payout without trusting rent.dev, eth_call its verify (to, data) on any RPC of its network: the token answers 1 once the payout landed. nonce is the authorization's nonce the token accepts once. Each node is paid once a day, in USDC, to the address registered on that node; a node without an address is not paid and its releasable earnings wait until one is registered. A payout cannot be reversed, and a payout made is never sent again to another address. next_cursor is only for the next call of this tool.

Tools on /mcp/public

ToolWhat it doesScopeHints
rent_quoteQuote sandbox pricesnoneread-only, idempotent
rent_list_providersList providersnoneread-only, idempotent
rent_search_docsSearch the rent.dev docsnoneread-only, idempotent
rent_signupSign upnonenone
rent_supply_guideRead the provider guidenoneread-only, idempotent

Results and errors

A tool answers its value as structuredContent, and as the same JSON in a text block. A refusal is an isError result whose content is the Problem the REST API would have answered, with its code. The codes are listed on the errors page.

Paying from inside a tool call

When a call needs more credit, the Problem is a 402 with topup.checkout_url and topup.x402_url. A 2026-07-28 client that takes URL elicitation is handed the pay link as an input request instead, and the call runs again once the person has answered.

rent_topup with method: "card" answers a pay link for a person, valid 24 hours. With method: "x402" it charges USDC over MCP:

  1. The first call answers isError with the x402 PaymentRequired object as its structured content.
  2. Sign it within 120 seconds and call again with the same arguments and the PaymentPayload in _meta["x402/payment"].
  3. The paid call settles, credits the balance and answers the settlement in _meta["x402/payment-response"].

A payment that is broadcast but not yet confirmed answers an operation instead. Poll it with rent_get_operation.

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "rent_topup",
    "arguments": {
      "method": "x402",
      "amount_usd": "5.00"
    },
    "_meta": {
      "x402/payment": "<PaymentPayload>"
    }
  }
}