Skip to content
MCP server

rent.dev

Pay-per-second Linux sandboxes and GPU pods that agents can rent themselves

Status and history

Answered our latest tool-list check 15 hours ago with 35 tools. It will be marked verified after 3 successful checks in 7 days.

Pricing
Paid
Platforms
API, CLI
Runs
Locally or Remotely
Version
0.1.1
Listing updated
3 days ago

About rent.dev

rent.dev is a paid MCP server for cloud and infrastructure. It can run locally on your machine or as a hosted remote server.

rent.dev lets an agent connect without a key and start using free tools straight away, such as price quotes and provider lists. When it needs an account it signs in, or calls rent_signup to get one. The full endpoint exposes 35 tools covering the provider catalog, funds, sandboxes, GPU pods, the account and partner supply; a separate /mcp/public endpoint has five tools and needs no credentials.

Sandbox pricing is a formula: provisioned memory at $0.0162 per GiB-hour plus CPU, with the CPU part capped at what E2B's list rate would charge for the same shape. Before a sandbox starts, rent.dev reserves the most it could cost, then returns what was unused. A paused sandbox costs nothing. Adding credit carries a fee of 5.5%, at least $0.80 by card.

GPU pods run on your own RunPod key and RunPod bills them. The docs give connection snippets for roughly two dozen clients.

Install

Run in a terminal

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

Add to Settings → Connectors → Add custom connector

https://mcp.rent.dev/mcp
Install in CursorOpens Cursor, which asks you to confirm. Or add it by hand:

Add to ~/.cursor/mcp.json

{
  "mcpServers": {
    "rent": {
      "url": "https://mcp.rent.dev/mcp"
    }
  }
}
Install in VS CodeOpens VS Code, which asks you to confirm. Or add it by hand:

Add to .vscode/mcp.json

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

Add to ~/.codeium/windsurf/mcp_config.json

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

Add to your client's MCP settings (most use this shape)

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

Configuration

  • RENT_API_KEYA rent.dev API key (rent_sk_...). Without it the key stored by `rent init` is used; with neither, only the public tools: prices, providers, docs and signup.

Tools this server provides (35)

Read directly from the server.

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 (`cla
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
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, 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 p
rent_get_balance
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.
rent_topup
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 obje
rent_create_sandbox
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
rent_get_sandbox
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.
rent_list_sandboxes
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.
rent_exec
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
rent_start_process
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.
rent_get_process_output
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.
rent_run_code
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
rent_read_file
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.
rent_write_file
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.
rent_get_port_url
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.
rent_extend_sandbox
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).
rent_pause_sandbox
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.
rent_resume_sandbox
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).
rent_terminate_sandbox
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.
rent_create_gpu_pod
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 o
rent_list_gpu_pods
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.
rent_terminate_gpu_pod
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.
rent_set_byok_credential
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 (`
rent_get_usage
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.
rent_get_operation
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.
rent_supply_enroll
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 tok
rent_supply_nodes
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.
rent_supply_node
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`, th
rent_supply_update_node
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 r
rent_supply_probe_node
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_supp
rent_supply_revoke_node
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. Revok
rent_supply_earnings
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 set
rent_supply_payouts
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

What it does

Keyless public tools
Quote prices, list providers and search docs without an account.
Per-second sandboxes
Metered billing on provisioned memory and CPU actually used.
Cost holds
The maximum possible cost is reserved up front and unused amounts return.
GPU pods on your key
Launch GPU capacity billed by RunPod under your own key.
Quotes endpoint
A keyless HTTP endpoint compares rent.dev with other vendors for three workload profiles.
Wide client coverage
Documented setup for Claude Code, Cursor, Codex, VS Code, Zed and many more.

Good for

  • Give a coding agent a disposable Linux sandbox
  • Compare sandbox cost across vendors before choosing
  • Rent a GPU pod through your RunPod key
  • Let an agent sign itself up and fund a balance

Pricing

Paid

Usage-based from a prepaid balance; memory $0.0162/GiB-hour plus capped CPU; 5.5% top-up fee

Prices change. Check rent.dev before you buy.

rent.dev FAQ

Do I need an account to connect?

No key is needed to connect; tools that need an account ask you to sign in or call rent_signup.

Is a paused sandbox billed?

The pricing page says a paused sandbox has no usage and costs nothing.

How do I top up?

Add credit by card or over x402; the fee is 5.5% of the credits, at least $0.80 by card.

How many tools are there?

35 on the main endpoint and 5 on the public one.

Is rent.dev free?

No. rent.dev is a paid product.

How do I add rent.dev to Claude Code?

Run this command in your terminal: claude mcp add --transport http rent https://mcp.rent.dev/mcp

What are the best alternatives to rent.dev?

The closest alternatives to rent.dev are REA, Codebase Memory, GitHub, Serena MCP: the IDE for your agent and XERJ.

Alternatives to rent.dev

  1. REA

    MCP server

    CLI and MCP server that lets coding agents reverse engineer apps and binaries

    Runs locally
    • Open source
    • 464K GitHub stars
    • Developer tools
  2. Codebase Memory

    MCP server

    Local MCP server that builds a code knowledge graph for AI coding agents

    Runs locally
    • Open source
    • 48.7K GitHub stars
    • Knowledge and memory
  3. GitHub

    MCP server

    Official MCP server connecting AI assistants to GitHub repos, issues and workflows

    Not checked yet
    • Remote
    • Open source
    • 34.5K GitHub stars
    • Developer tools
  4. MCP toolkit giving coding agents symbol-level code retrieval and editing

    Runs locally
    • Open source
    • 31.5K GitHub stars
    • Developer tools
  5. XERJ

    MCP server

    Local search engine for AI agents with cited answers over your code and docs

    Runs locally
    • Open source
    • 19.2K GitHub stars
    • Knowledge and memory
  6. Ouroboros

    MCP server

    Spec-first layer that pins requirements and verifies results of AI coding agent work

    Runs locally
    • Open source
    • 6.4K GitHub stars
    • Developer tools