Pricing

GPU rental

GPUVRAMPer GPU-hour
RTX 4090 (rtx4090)24 GB$0.40
RTX 5090 (rtx5090)32 GB$0.70

RTX 5090s need a CUDA 12.8+ image (Blackwell, sm_120): see GPU rental.

Each GPU in /platform/pricing carries three availability fields, all worked out by the scheduler itself from what is free this instant (after everything already placed or reserved). We don't publish how many GPUs are free or how many we have, only these:

FieldMeaning
onlineA machine with this GPU is online and taking rentals. false means a create asking for it returns 400. The same test as GET /platform/nodes/supported.
availabilityavailable: GPUs are free. almost_fully_rented: some are free, but few. fully_rented: none are free right now, and a create is refused at once with 503 no_capacity; join the waitlist to hear when one frees up. on_request: no machine with it is taking rentals (online is false); write to support@green-compute.com.
available_nowtrue while availability is available or almost_fully_rented: at least one is free. false when it is fully_rented (or on_request).

The website's GPU pages show the same states, from the same count, so the site and the API always agree. A multi-GPU rental also needs its GPUs free together on one machine; if they aren't, the create fails at once with 503 no_capacity and nothing is created.

  • Billed per started minute while running: every minute a deployment is ready that it has begun, so 10 seconds pays for one minute and 61 seconds for two. Startup is free: image pulls, start-up and failed deployments cost nothing. Usage is metered about once a minute and charged in whole cents, with fractions carried forward; when the rental stops (you delete it, it fails, it is paused, it reaches max_runtime_minutes), the rest of the minute it stopped in and the fraction carried are charged in one ledger line ending (final minute), rounded up to a cent. If the balance can't cover that line, as when credit has run out, the rest is charged if you resume the rental and written off if you don't (at most about a minute). A 10-second rental on an RTX 4090 costs 1¢ (two-thirds of a cent, rounded up). Each time a paused rental runs again counts afresh, and time while its machine isn't reporting is never charged.
  • No deployment fee, no egress fee, no minimum term. Stop with DELETE /platform/deployments/{id} and billing stops.
  • To start a rental, your balance must cover one hour of its price.
  • The price is fixed when a GPU is assigned to your deployment, so later list-price changes don't affect a running rental.

Inference (shared models)

Per token, input and output priced separately, with a minimum charge of $0.01 per request. Prices vary by model.

Private models

A model you deploy yourself (Models → Deploy, or a deployment of your own inference workload) is charged like a GPU rental: the GPU's hourly price times its GPU count, billed per started minute while it is ready, whether it gets requests or not. On one RTX 4090 that is $0.40 an hour.

  • Requests to it aren't charged per token, whether they come from you or from an account you've shared it with.
  • Downloading the model and starting up are free, and so is a deployment that fails.
  • Starting one needs one hour of its price in your balance. The price is fixed when a GPU is assigned to it, and is never more than it was quoted when you started it (hourly_rate_cents on the deployment, per GPU).
  • It pauses itself after 30 minutes with no requests, and when your balance runs out. A paused model costs nothing: there is no storage charge, because a model keeps no data of yours. Resume it from its page or with POST /platform/deployments/{id}/resume, which needs one hour of its price in your balance.
  • Stop it with DELETE /platform/deployments/{id} and billing stops.

Live, machine-readable prices

The figures above can change. The authoritative source, which billing itself uses, is public and needs no key:

curl -s https://api.green-compute.com/platform/pricing
{
  "currency": "USD",
  "payment_bonuses": {"alpha": 0.1},
  "gpu_rental": {
    "billing": "per started minute while running, per GPU; starting up is free",
    "deployment_fee_usd": 0,
    "gpus": [
      {"gpu_model": "rtx4090", "online": true, "available_now": true, "availability": "available", "vram_gb": 24, "cents_per_gpu_hour": 40, "usd_per_gpu_hour": 0.4, "usd_per_gpu_hour_paid_in_alpha": 0.3636}
    ]
  },
  "inference": {
    "billing": "per token; minimum charge per request",
    "minimum_charge_usd": 0.01,
    "models": [{"model": "…", "usd_per_million_input_tokens": 0.2, "usd_per_million_output_tokens": 0.6}]
  },
  "private_model": {
    "billing": "per started minute while running, at the gpu_rental rate per GPU; requests to it are not charged per token. Starting or resuming one needs one hour of that rate in credit",
    "idle_pause_minutes": 30
  }
}

Checking your balance and charges

curl -s https://api.green-compute.com/platform/billing/balance -H "Authorization: Bearer $GC_KEY"
curl -s "https://api.green-compute.com/platform/billing/ledger?limit=20" -H "Authorization: Bearer $GC_KEY"

The ledger lists every top-up and charge, newest first, with amount_cents (negative for charges) and balance_after. The balance also gives pending_usage_cents: what your running rentals and private models have used since the meter's last minute, not charged yet, and available_cents, the balance less that.

Paying

Top up on the Billing page by card, or with USDC or USDT (on Base or Ethereum), TAO, or subnet 110 alpha. Alpha top-ups get 10% extra credit, so an RTX 4090 at $0.40/hr costs about $0.364/hr when you pay in alpha ($0.40 ÷ 1.10). /platform/pricing gives this as usd_per_gpu_hour_paid_in_alpha for every GPU, and the bonus itself as payment_bonuses. Fees your wallet or exchange charges to move or swap alpha aren't included. A crypto invoice must be paid with its exact amount; from a verified wallet you can send any amount without one. Adding credit explains both, and what to do if a payment isn't credited.

Your balance is drawn down per minute by rentals and private models, and per request by shared models.