rent.dev

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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).

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. Your GPU pods, newest first, every state. `next_cursor` is opaque and only for the next call of this tool.

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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. Pauses a running sandbox, keeping its memory and files; the id stays valid and rent_resume_sandbox continues it.

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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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).

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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.

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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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.

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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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, call rent_create_sandbox instead. 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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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, call rent_create_sandbox instead. 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. That run is quick, because the host is already set up. `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.

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, call rent_create_sandbox instead. 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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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, call rent_create_sandbox instead. 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`.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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, call rent_create_sandbox instead. Your nodes, newest claim first, each with its state, checks and `next` step. `next_cursor` is only for the next call of this tool.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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, call rent_create_sandbox instead. 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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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, call rent_create_sandbox instead. 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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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, call rent_create_sandbox instead. 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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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, call rent_create_sandbox instead. 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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. Ends a GPU pod on RunPod, deleting its container disk, and stops RunPod's billing. Terminating an ended pod answers it unchanged.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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.

Needs a rent.dev account: sign in when your client offers it, or call rent_signup first. 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.