VPS and sandbox APIs you can pay per call

What a VPS or sandbox API does, and who calls it

A VPS, a virtual private server, is a machine you rent for a period, often by the month. It keeps its disk, its address and its running processes between requests, and you manage it yourself over SSH. A sandbox API sells something narrower: each call sends code or a command, the provider runs it in an isolated environment and returns the output. What happens to that environment afterwards is up to the provider. A GPU route does the same with a graphics card attached, for work that needs one.

An agent calls a sandbox to check a calculation, run a test, convert a file or try code it has just written, without running that code on its own host. It calls a GPU route to run or fine-tune a model, render images or process a batch that would be too slow on a CPU. In both cases the boundary of a single call decides what you can do: the time limit, the network, the files that survive and what happens when the job fails.

The table covers 5 services with a matching priced compute route as of October 26, 2026: 2 services run work on a rented GPU, 2 services run code sent with the call in an isolated sandbox and 1 service runs a command in a sandbox that is already running. It leaves out 6 candidates that pass the listing checks but list no matching priced compute route; a GPU price feed, a storage route or compute named only in a service description does not count.

What the 5 compute services actually run

The classification follows each route's documented product. A service with more than one product appears in more than one row, and each quote comes from the cheapest priced route of that type, with its path attached.

Each price is the cheapest endpoint of that service for that kind of data: the same number wherever this page quotes it.

A sandbox that receives code with each call and a sandbox that is already running differ in what a call can rely on. Isolation is a provider statement; whether files, packages or other state from an earlier call are still there, or are wiped, is a separate question. Treat it as unknown unless the route description documents it. Model inference on a provider's GPU returns text, not a shell, so it is listed as its own type and never sets a service's price in the main table. Notes on GPU models, time caps and network access report what a route description states. They are provider statements, not benchmarks by x402-list.

The 5 VPS and sandbox APIs and their matching route prices

One row per service, ordered by measured buyers. The price is the cheapest GPU, sandbox or running-sandbox route of the service, named under the price, never an unrelated tool on the same host.

$/CALL is the price of the endpoint named under it: the cheapest workload or command on a rented gpu, code sent with the call, run in an isolated sandbox and command in a sandbox that is already running endpoint of the service or, for a service without one, its cheapest compute route. Never the cheapest tool of a gateway. Other kinds of data have their own price in the tables below. COMPUTE ROUTES counts the compute routes out of all the endpoints the service lists. BUYERS 30D counts distinct wallets that paid the whole service on-chain in 30 days, not only its compute routes. "Generalist" marks a gateway that sells more than three unrelated kinds of tools: it is never called the cheapest.

The buyer figure counts wallets that paid the whole service, so for a gateway it does not show demand for compute. Monitoring latency describes our unpaid checks of the service; it says nothing about how long your code or your GPU job will run once paid.

How to choose a VPS or sandbox API

Code per call, a running sandbox or a GPU

Start from the job. A self-contained script that reads its input and prints a result fits a sandbox that takes the code with each call, as long as it does not rely on anything left over from an earlier call. A sequence of commands that build on each other needs a sandbox that stays up, and then you also need to know how it is started, stopped and paid for while idle. A model, a render or a large numeric job needs a GPU; 1 service names the GPU model in the route description. Do not compare these prices as if they bought the same work.

Time, size and output limits

A per-call sandbox has limits whether or not a description states them. As of October 26, 2026, 2 services state a time limit in the route description: scrape402 and Kilawatt Cloud. Where no limit is stated, ask for it before you send a job that might run long, and check the maximum size of the code you send and of the output you get back. A job that hits a limit usually returns a truncated output or an error, and you may still pay for the call.

Network access and secrets

Decide whether your code needs the network. A sandbox without network access, as stated for agent-exec, blocks package installs and API calls but also stops code from sending data out. Whatever the provider states, do not put long-lived keys or private customer data in code that runs on infrastructure you do not control; pass short-lived credentials if a job must call out.

Files and state between calls

Ask what survives a call: files written to disk, installed packages, environment variables. Unless a route description documents it, assume neither a clean environment nor kept files: send everything a job needs with the call, save anything it must resume from elsewhere, and do not leave secrets behind on the assumption that the environment is wiped. A GPU block ends when its time is up; copy results out before then.

A running sandbox is reused by later commands; for the Modal sandbox reached through vaaya, the route description does not say what it keeps or for how long, so ask before you depend on it.

Billing on failure

Read what happens when the job fails, times out or produces nothing. As of October 26, 2026, 1 service says a command is charged only if it succeeds; elsewhere, assume a failed run is a paid call unless the terms say otherwise. A pay-on-success rule still needs a definition of success, such as an exit code of zero, before you rely on it.

Languages and runtimes

Check the runtime before you write code for it. 2 services name accepted languages in the route description: scrape402 and agent-exec. Ask for the exact interpreter versions and preinstalled libraries, and pin your code to what is there rather than to what your own machine has.

Which route fits which job

Start with the job, then compare the candidates whose classified routes match it. The price in a job list is tied to those types and can differ from the service's price in the main table.

Run a short script in isolation

Check the languages, the time cap and the output limit first, then whether the code may reach the network. Send inputs in the request, keep the exact code and the returned exit code with the result, and treat an empty stdout as a failure to investigate, not as an answer.

Candidates today, most buyers first: vaaya ($0.01/call, generalist, 57 buyers) · scrape402 ($0.018/call, generalist, 26 buyers) · agent-exec ($0.001/call)

Run a job that needs a GPU

Compare the GPU model, the length of the block you pay for and how the workload and its results are moved. A fixed block suits a job of known length; for anything longer, ask how the provider extends or chains runs before you start.

Candidates today, most buyers first: Kilawatt Cloud ($0.58/call, 6 buyers) · Prism Network ($0.03/call)

Get model output without managing a GPU

If the job is only to generate text, an inference route avoids managing a machine. Check the model, the context limit and how a batch reports partial failures, and compare with the LLM API page before you choose.

Candidates today, most buyers first: Prism Network ($0.012144/call)

Service details and limits to check

The notes below are read from each provider's description and endpoint list captured on October 22, 2026. They attribute advertised capabilities; x402-list has not run code or GPU jobs on these services. Prices, uptime and buyers come from the current page model.

Kilawatt Cloud

Kilawatt Cloud lists one route, POST /api/public/x402/exec, described as GPU compute on one NVIDIA H100 for 600 seconds, at $0.58 per call. The service description presents a multi-provider orchestration platform that routes AI and machine-learning workloads across RunPod, Vast.ai, Lambda and Hyperstack, with automatic failover, per-second billing and no egress fees; those are provider statements. The captured route quotes a fixed amount for a ten-minute block, so ask whether a job that ends early is billed for the whole block. The endpoint description does not say how the workload is supplied, as a container image, a script or a command, nor how results and files come back, so read the provider's schema before paying.

1 compute route of 1 · $0.58/call (POST /api/public/x402/exec) · Base · uptime 30d 98.7% · 6458 ms · 6 buyers in 30 days

Prism Network

Prism Network lists GET /x402/run, one shell command on a rented GPU, at $0.03, and says the command is charged only if it succeeds. Its service description goes further: a dedicated NVIDIA GPU rented by the second, with any container image and SSH access, destroyed when the work is done, plus a confidential tier inside an Intel TDX enclave. The endpoint list read for this page shows the single-command route and two inference routes, not a lease with SSH access, so the longer rental is not priced here. The inference routes, one generation or a batch of prompts from $0.012144, return model output rather than a shell; they are listed as a separate type and do not set the price in the table. Ask what counts as success for a command before you rely on that billing rule.

3 compute routes of 3 · $0.03/call (GET /x402/run) · Base · uptime 30d 100% · 223 ms · 0 buyers in 30 days

agent-exec

agent-exec lists POST /execute at $0.001: Python 3 or Node code runs in an isolated sandbox without network access, and the reply carries stdout, stderr and the exit code as JSON. No network means the code cannot download packages or call an external API during the run, so send everything it needs in the request. The description calls this the default tier and does not state time or memory limits; test with your heaviest expected input before you depend on it. The same host sells small paid storage, a subdomain rental, URL attestations and a disposable inbox, each on its own route and outside this comparison.

1 compute route of 15 · $0.001/call (POST /execute) · Base/SOL · uptime 30d 99.9% · 410 ms · 0 buyers in 30 days

scrape402

scrape402 lists POST /sandbox at $0.018. The body takes the code and an optional language: Python by default, JavaScript, Bash, R or Java. The reply returns stdout, stderr, results and an error field. The description sets hard caps of 25 seconds of wall-clock time, 100 KB of code and 64 KB of output per run, and calls the sandbox fully isolated without saying whether outbound network calls are allowed. Those caps suit a calculation, a parser or a unit test, not a long build. scrape402 is a generalist gateway with scraping, search and market data; its key-value store can keep small JSON values between runs, but that is a separate paid route, not part of a sandbox call.

1 compute route of 40 · $0.018/call (POST /sandbox) · Base · uptime 30d 100% · 109 ms · 26 buyers in 30 days

vaaya

vaaya lists POST /api/run/modal/sandbox-exec at $0.01, described as running a command in a running Modal sandbox and returning its output. The route needs a sandbox that already exists, and the endpoint list read for this page has no route that creates one. Ask the provider how a sandbox is started, how long it stays up and who pays for its idle time before you plan a workflow on it. vaaya presents itself as one MCP server for many paid tools, from media generation to lead enrichment, so its buyer count covers that whole gateway rather than this route.

1 compute route of 7 · $0.01/call (POST /api/run/modal/sandbox-exec) · Base · uptime 30d 100% · 450 ms · 57 buyers in 30 days

What the calls cost at different volumes

The median selected route costs $0.018 per call. At that same request shape, 100,000 calls would cost $1,800.00. This is a comparison aid, not an invoice: a sandbox call and a GPU block are both one call, but they buy very different amounts of compute.

Each service at the price of its main compute route, the one named in the table above.

For a sandbox, count the calls your workflow makes, including retries after a timeout and the calls that only check a result. For GPU work, count blocks: a job that needs twenty minutes on a ten-minute route is at least two calls, plus the time to move data in and out. Keep the route, the duration and the price of each call in your job record.

Inspect a request and its payment evidence

For a short script, scrape402 documents POST /sandbox, with a sandbox quote of $0.018. The description names two body fields, the code and an optional language, and lists stdout, stderr, results and an error field in the reply; check the provider's schema for the exact field names before sending code.

The listed method and description establish the advertised contract. This explanation does not reproduce an HTTP 402 challenge or certify a paid response. Open the service page's payment evidence and request the challenge for the exact body before authorizing payment. Compare resource, method, network, asset and amount together, and do not reuse a challenge obtained for a different route on the same host.

What this comparison measures

The listing requires an online, payment-ready service, a usable description, an advertised price and at least 90% measured uptime over 30 days. Task selection then reads the endpoint list and keeps routes that run a workload: a job or command on a rented GPU, code sent with the call to an isolated sandbox or a command in a running sandbox. Model inference is shown as a separate type and does not qualify a service alone. A GPU price feed, a storage or DNS route, prepaid credits for another product and compute named only in a service description are not compute routes, and a free test network mentioned as a sandbox is not a code sandbox.

Uptime and average latency come from monitoring checks. Buyer counts are distinct paying wallets observed for the whole service in the window. A successful unpaid HTTP 402 response shows a payment requirement, not that code ran correctly after payment. Run a representative job, including one that fails on purpose, before putting a recurring workflow on any route.

Questions

How to pay

Each service answers an unpaid call with HTTP 402 and its price; your agent signs a USDC payment on the listed network and retries. No API key, no account, no subscription. See what x402 is.