Task billing & refunds

Tasks are billed for container runtime, nothing else. This page covers when the meter starts and stops, which credit is used, and what happens to the money for every way a task can end.

How billing works

• The meter starts when the container is Running. Queueing, scheduling, and image pulls before that are free.
• While the task runs, your prepaid credit is deducted on a ~60-second cycle, and the task card shows Cost so far live.
• When the container ends, the charge is trued-up to the actual end time — you are never billed for time after your script exited, even if it exited between billing cycles.
• The hourly rate is the same as a GPU Pod on the same hardware — see Pricing & Instances. CPU presets have their own listed rates, shown on the submit form.
• pip install -r requirements.txt time runs on the clock — it happens inside the running container.

Paid credit only

Tasks draw from purchased credit only. Free and bonus credit cannot be used for tasks — a task won’t start (and won’t keep running) against bonus balance alone.

Who pays when something goes wrong

Every finished task is classified as succeeded, a user fault, or a platform fault (the fault_class field in webhooks and on the task page). That classification decides the money:

Outcome	Fault	Billing
Script exits 0	—	Charged for actual runtime
Script raises / exits non-zero	User	Charged in full
Out of memory (exit code 137)	User	Charged in full
Output disk budget exceeded → evicted	User	Charged in full
requirements.txt install fails	User	Charged in full
Max run time reached (Timed out)	User	Charged up to the ceiling — no refund
You press Stop	—	Charged for actual runtime
Node goes down mid-run	Platform	Automatic refund: min(1 hour’s worth, total charged)
Scheduling / image preparation fails	Platform	Same automatic refund

Platform-fault refunds are automatic — no ticket needed. The refund is capped at one hour’s worth of the task’s rate (or the full charge, if the task ran less than an hour), and it appears in your billing history alongside the charge.

Why user code failures are charged

Your code ran on reserved hardware for that whole time — the outcome of the code doesn’t change what was consumed. This matches how GPU Pods bill. Make failures cheap: test locally, start with a short max run time, checkpoint to /outputs as you go.

Timeouts

Timed out is treated exactly like Failed for billing: charged up to the max run time, no refund.

When the ceiling is hit, the script receives SIGTERM, then 30 seconds of grace before the container is killed. Use it to flush final results:

import signal, sys

def save_and_exit(signum, frame):
    checkpoint.save("/outputs/checkpoint.pt")   # you have ~30s
    sys.exit(0)

signal.signal(signal.SIGTERM, save_and_exit)

Files already written to /outputs are uploaded even for failed and timed-out tasks — a timeout loses the remaining work, not the finished output.

Running out of credit

Billing is prepaid: if your paid credit is exhausted mid-run, the task is stopped. Keep enough balance to cover rate × max run time for anything you can’t afford to lose — or checkpoint to /outputs so a stop is recoverable.