# rent.dev

> rent.dev is a paid MCP server for cloud and infrastructure. Pay-per-second Linux sandboxes and GPU pods that agents can rent themselves. It can run locally on your machine or as a hosted remote server.

- **Kind:** MCP server
- **Pricing:** Paid
- **Platforms:** API, CLI
- **Website:** https://rent.dev/docs/mcp
- **MCP Registry name:** dev.rent/rent
- **Categories:** cloud and infrastructure, developer tools
- **Listing updated:** 2026-11-14

## About

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.

## Features

- **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

## Install

### Claude Code (Terminal)

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

### Claude Desktop (Settings → Connectors → Add custom connector)

```sh
https://mcp.rent.dev/mcp
```

### Cursor (~/.cursor/mcp.json)

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

### VS Code (.vscode/mcp.json)

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

### Windsurf (~/.codeium/windsurf/mcp_config.json)

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

### Other clients (your client's MCP settings (most use this shape))

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

## Tools

- `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

## 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

- [REA](https://ai-powered.com/mcp/rea): REA is an open-source MCP server for developer tools.
- [Codebase Memory](https://ai-powered.com/mcp/codebase-memory): Codebase Memory is an open-source MCP server for knowledge and memory.
- [GitHub](https://ai-powered.com/mcp/github-2): GitHub is an open-source MCP server for developer tools.
- [Serena MCP: the IDE for your agent](https://ai-powered.com/mcp/serena-mcp-the-ide-for-your-agent): Serena MCP: the IDE for your agent is an open-source MCP server for developer tools.
- [XERJ](https://ai-powered.com/mcp/xerj): XERJ is an open-source MCP server for knowledge and memory.
- [Ouroboros](https://ai-powered.com/mcp/ouroboros): Ouroboros is an open-source MCP server for developer tools.
- [Claude Code Ultimate Guide](https://ai-powered.com/mcp/claude-code-ultimate-guide): Claude Code Ultimate Guide is an open-source MCP server for ai models and llm tooling.
- [Concord MCP](https://ai-powered.com/mcp/concord-mcp): Concord MCP is a freemium MCP server for developer tools.

---
Source: https://ai-powered.com/mcp/rent-dev
