Volt API Reference

Base URL & Authentication

All Volt API endpoints live under a single base URL. Every request must include your API key in the X-API-Key header.

Base URL

Authentication Header

Example: List Your Pods

API Key Setup

Generate an API key from the VoltageGPU dashboard. Navigate to Dashboard → API Keys → Generate. Your key is shown once, store it securely.

Header Format

Rate Limits

Each endpoint accepts up to 10 requests per 10 seconds from one client IP. Beyond that it returns 429 Too Many Requests with a Retry-After header in seconds. When you poll a pod, one request every 10 to 15 seconds is enough.

Key Permissions

Each API key has access to the following resource scopes:

• pods, Create, read, stop and delete Confidential VMs and standard pods
• templates, List the curated templates
• ssh-keys, Add and remove SSH public keys
• docker-credentials, Store private registry credentials
• machines, Browse confidential and standard GPU inventory with live pricing
• balance, Read your balance and running pod count

List & Manage Confidential Pods

List your running pods: Confidential VMs first, then standard pods. Every entry carries provider ("confidential" or "standard") and confidential_compute.

Create a Confidential VM (Intel TDX, full Ubuntu 24.04 guest, NVIDIA driver and CUDA preinstalled). Always pass provider: "confidential", a name and a resource_name from GET /api/volt/machines. Your balance is debited one hour upfront at deploy. With provider: "standard" the same endpoint deploys a standard pod: see Standard Pods. A request without provider is refused with 400.

Get full details for a specific pod including IP, ports, and resource usage

Release a confidential pod. For Intel TDX pods this destroys the enclave and is equivalent to DELETE /api/volt/pods/:id. Confidential pods cannot be paused and resumed.

Permanently destroy a confidential pod and its enclave. This action cannot be undone.

Deploy and manage Confidential VMs

Live Confidential VM inventory with your selling price and how many machines are free right now. Prices are computed server side, never sent by the client.

curl -H "X-API-Key: $VOLT_API_KEY" \
  https://api.voltagegpu.com/api/confidential/vm/tiers

{
  "tiers": [
    {
      "resourceName": "rtx6000b-small",
      "displayName": "NVIDIA RTX Pro 6000B - Small",
      "gpuType": "RTX6000B",
      "gpuCount": 1,
      "vcpu": 32,
      "memoryGb": 128,
      "pricePerHour": 3.8,
      "available": 10,
      "gpuAttestation": true,
      "attestation": {
        "verified": true,
        "verifiedOn": "2026-09-17",
        "evidenceUrl": "https://voltagegpu.com/blog/two-proofs/evidence/rtx6000b-2026-09-17/README.txt",
        "generatedBy": "tenant, inside the VM, on a nonce the tenant chooses",
        "verifyInsideTheVm": ["curl -sS https://bootstrap.pypa.io/get-pip.py | python3 - --user --break-system-packages", "..."],
        "index": "https://voltagegpu.com/api/attestation/evidence"
      }
    }
  ]
}

gpuAttestation is true only on the SKUs where we have actually run the NVIDIA attestation from inside the VM and kept the report. It is not a marketing flag, and it reads false on hardware we have not tested. The attestation block says when, links the published evidence, and lists the exact commands to reproduce both proofs inside the VM (the image ships without pip, which is why the list starts with get-pip). The same list, per SKU and without any key, is served by GET /api/attestation/evidence.

Start a Confidential VM. One hour is charged upfront and the unused part is returned to your balance per second when you stop it, so a short test costs cents.

curl -X POST \
  -H "X-API-Key: $VOLT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-vm",
    "resource_name": "h100-small",
    "hardstop_hours": 4,
    "ports": [{"port": 8080, "protocol": "tcp"}]
  }' \
  https://api.voltagegpu.com/api/confidential/vm/deploy

ports is optional and opens inbound TCP or UDP ports on the VM, up to eight of them, in the range 1 to 65535. Port 22 is rejected because SSH is already mapped for you. The response has no address yet, the VM is still being provisioned: poll GET /api/volt/pods below for it.

{
  "success": true,
  "podId": "cmu5i01bz001vl9042ag1ps0w",
  "workloadUid": "wrk-xhnrun04sbj8",
  "resourceName": "rtx6000b-small",
  "hourlyPrice": 3.8,
  "sudoPassword": "shown once, never again",
  "hardStopAt": "2026-09-17T13:20:45.887Z",
  "hardStopRequested": true,
  "ports": [],
  "attestation": { "verified": true, "verifiedOn": "2026-09-17", "...": "same block as the tier" },
  "message": "Confidential VM is starting"
}

One hour at hourlyPrice is debited when this call returns. Use podId to stop the VM and workloadUid to find it in the listing.

A bare JSON array of your running Confidential pods. Poll it every 15 seconds after a deploy: a VM shows provider_status "provisioning" until it has an address, then "running" with ssh_ready true. VMs are reached directly as user ubuntu on their own host and port, not through the container gateway. Measured on 17 September 2026: 15 seconds to an address, 19 seconds more for both proofs.

[
  {
    "id": "wrk-xhnrun04sbj8",
    "name": "wrk-xhnrun04sbj8",
    "status": "RUNNING",
    "provider_status": "running",
    "resource_name": "rtx6000b-small",
    "hourly_price": 3.8,
    "ssh_ready": true,
    "ssh_host": "157.254.50.65",
    "ssh_port": 20000,
    "ssh_user": "ubuntu",
    "ssh_command": "ssh -p 20000 ubuntu@157.254.50.65",
    "provider": "confidential",
    "confidential_compute": true
  }
]

Generate the two proofs inside the VM, then verify them outside

Both proofs are produced by you, inside the VM, on a challenge you choose. VoltageGPU is not in the trust chain. The image ships without pip, hence the first line.

ssh -p 20000 ubuntu@157.254.50.65
curl -sS https://bootstrap.pypa.io/get-pip.py | python3 - --user --break-system-packages
python3 -m pip install --user --break-system-packages "voltage-verify[attest]>=0.2.1"
export PATH=$HOME/.local/bin:$PATH
voltage-verify manifest --challenge auto -o manifest.json        # prints your challenge, keep it
sudo env PATH=$PATH PYTHONPATH=$(python3 -c 'import site;print(site.getusersitepackages())') \
  voltage-verify attest --manifest manifest.json --mode single-gpu -o bundle.json
voltage-verify verify bundle.json --challenge <your challenge>   # RESULT: VERIFIED

The verification that counts is the one you run on your own machine, on the copied bundle, with the challenge you issued. A replayed bundle answers NOT VERIFIED.

scp -P 20000 ubuntu@157.254.50.65:bundle.json .
pip install "voltage-verify>=0.2.1"
voltage-verify verify bundle.json --challenge <your challenge> --hwmodel GB20X --gpus 1
voltage-verify verify bundle.json --challenge <your challenge> --offline   # no network at all

Reference run, by API key alone, with the bundle anyone can re-verify: voltagegpu.com/blog/two-proofs/evidence/rtx6000b-api-2026-09-17/README.txt

Pass the podId from the deploy response. Billing is per second: the unused part of the prepaid hour comes back to your balance in the same call (prepaidRefund). Documented in full above.

Public, no key. Which SKUs have a published tenant-side attestation, on what date, the evidence URLs, what is not attested and why (8x H200, B200, B300, the NVSwitch fabric), and the reproduce commands. Read it before you pay.

Deploy a standard pod by API

Four calls: list the machines, pick a template (optional), make sure an SSH key is registered, deploy. Then poll the pod until it has an SSH command, and release it when you are done.

Machines you can deploy right now, cheapest first. Only machines whose GPUs are all free are listed: a standard machine is rented whole. The list is refreshed at most once a minute.

price_per_hour is what one hour of the whole machine costs, markup included: it is the amount charged at deploy and the hourly rate billed afterwards. price_per_gpu_hour is the per-GPU price shown on the pricing page; because of rounding, it can differ by a cent from price_per_hour divided by gpu_count. Use ?provider=all to get confidential and standard machines in one array.

The curated environments a standard pod can start from. Only these ids are accepted as template_id. The entry with default: true is used when you omit it.

SSH key

The pod is reached over SSH with a key registered on your account. If you have none, register one with POST /api/volt/ssh-keys (see SSH Keys). If you have exactly one, the deploy uses it. If you have several, pass ssh_key_id from GET /api/volt/ssh-keys. As in the dashboard, a VoltageGPU service key is also added to the pod so the web terminal works.

Deploy a standard pod on one machine. The price is read server-side from the live machine list; a price sent in the body is refused.

Errors

Every error has the shape {"success": false, "error": "...", "status_code": 402, "timestamp": "..."}. The error text says what to call next. Refusals from the deploy step itself also carry "charged": false.

Poll with the id from the deploy response, every 10 to 15 seconds, until ssh_command is set. The pod also appears in GET /api/volt/pods and in the dashboard. Values below are illustrative.

Release the pod. Billing stops and, within the first hour, the unused seconds of the prepaid hour are returned to your balance (prepaidRefund). Releasing deletes the pod, including its local disk. Standard pods cannot be paused: POST /api/volt/pods/:id/stop answers 501 for them, and a running pod cannot be edited: PUT /api/volt/pods/:id answers 405. A release sent while the deploy is still in progress answers 409; retry a minute later.

Available Confidential Machines

List the available Confidential VM tiers with live pricing and availability. Add ?provider=standard for standard machines (see Standard Pods) or ?provider=all for both.

SSH Key Management

List the SSH public keys of your account, newest first. The id is the ssh_key_id a standard pod deploy accepts.

Add a new SSH public key to your account

Remove an SSH key from your account. Running pods keep existing authorized keys until redeployed.

Read-only. A deploy charges the first hour up front, so check that the balance covers it before a scripted deploy. Four decimals, because billing is per second.

Template Catalog

List all curated public templates (cached 2 minutes). For standard pods, call GET /api/volt/templates?provider=standard instead: its id values are the template_id a standard deploy accepts (see Standard Pods).

Fetch a single template with the full manifest (commands, args, ports, env)

Registry Credentials

List all stored Docker registry credentials (passwords are redacted)

Add credentials for a private Docker registry

Get details for a specific credential (password is always redacted)

Delete a stored credential. Templates referencing it will fail to pull on next deploy.

API Key Management

List all API keys for your account (key values are partially redacted)

Generate a new API key. The full key is returned only once in this response.

Revoke an API key. The id goes in the id query parameter, not in the body. Takes effect immediately.

HTTP Status Reference

Error Response Format