A GPU is a machine of your own with 1, 2, 4 or 8 cards of one kind, near a place you name. You are root in a container on it. Your robots connect straight to the ports you open, from the addresses you allow; a command you give runs when it starts and is started again if it stops; a snapshot brings your setup back on the next GPU; and a name of yours keeps pointing at whichever GPU has it. It runs, and is billed by the second, until you remove it.
Start one
Install the CLI and log in (Install). Then add a GPU near your robot, with the port your server will listen on:
seq gpu add --gpu L4 --place "San Francisco, CA" --port 8000 # gpu-1a2b3c4d5e6f L4 San Francisco, CA running 192.0.2.10 ports 8000 expected 9 ms $0.80/h + CPU and memory # root on it: install your model, start your server on port 8000 seq gpu ssh gpu-1a2b3c4d5e6f # done: billing stops and its disk is deleted seq gpu remove gpu-1a2b3c4d5e6f
add waits until the GPU is up, then prints its address, its ports, the round trip to expect from that
place (Round trips) and what it costs an hour. Your robot connects to that address and port
directly: nothing of ours is in between. Until you say otherwise, only the address you ran add from can
connect (Ports).
Once it is set up the way you want, save it. From then on, one command a day brings it back, under a name your robots keep, with your server already started:
# once: install, then save it (names ending in -user are yours) seq gpu ssh gpu-1a2b3c4d5e6f -- 'pip install -r requirements.txt' seq gpu save gpu-1a2b3c4d5e6f --name policy-v1-user seq gpu remove gpu-1a2b3c4d5e6f # each day: from the snapshot, under your name, your server running seq gpu add --gpu L4 --place "San Francisco, CA" \ --from policy-v1-user --name lab-user \ --port 8000 --allow 0.0.0.0/0 --run "python serve.py --port 8000" # gpu-4d5e6f7a8b9c L4 San Francisco, CA running lab-user.k7q2xb.gpu.generalsequences.com 192.0.2.11 ports 8000 expected 9 ms $0.80/h + CPU and memory # in the evening seq gpu remove gpu-4d5e6f7a8b9c
Your robot is set once to ws://lab-user.k7q2xb.gpu.generalsequences.com:8000, and never again
(A name that stays). With --allow 0.0.0.0/0 any address can connect, so have
your server check a token or a certificate.
For more than one card, say how many with --count: 2, 4 or 8, the cards of one machine.
seq gpu add --gpu L4 --place "San Francisco, CA" --count 4 --port 8000 # gpu-7a8b9c0d1e2f L4 × 4 San Francisco, CA running 192.0.2.12 ports 8000 expected 9 ms 4 × $0.80/h + CPU and memory
A GPU is one machine, and your container sees all of its cards. A machine holds 1, 2, 4 or 8 of them, and which of those depends on the card: an L4 or an A100 comes in each, an H100 or an RTX PRO 6000 one to a machine. Any other count is refused, and nothing is added; the refusal lists the counts a machine holds. For another number, add more than one GPU — five L4s are a GPU of 4 and a GPU of 1 — and for cards in different places, add each place on its own.
Every card costs the same, on a machine of one or of eight (What it costs). A machine of
more cards is at fewer places, so it may open farther from yours than one card would, and the round trip
add prints for it says so.
From your code
To start GPUs from your own code — a fleet tool, a schedule — use the Python client, or the API from any
other language. They take the same arguments as the CLI, by the same names (snapshot= in Python for
--from), and give back what your robot needs:
# everything ending in _user or -user is yours gpus_user = sequence_ai.gpu.add( gpu="L4", place="San Francisco, CA", snapshot="policy-v1-user", name="lab-user", ports=[8000], allow=["0.0.0.0/0"], run="python serve.py --port 8000") gpu_user = gpus_user[0] gpu_user["address"], gpu_user["ports"], gpu_user["expected_rtt"] # in the evening sequence_ai.gpu.remove(gpu_user["id"])
curl -X POST https://api.generalsequences.com/v1/gpus \ -H "Authorization: Bearer $SEQUENCES_API_KEY" \ -H "Content-Type: application/json" \ -d '{"gpu": "L4", "place": "San Francisco, CA", "ports": [8000], "allow": ["0.0.0.0/0"]}'
count= is the cards of its machine, as --count is: 1, 2, 4 or 8
(more than one card). add() returns a list, as the API’s
"gpus" is, of the one GPU it added, with its cards.
seq gpu exits as every seq command does, by the error it prints
(error codes): 0 when the GPU you asked for is up;
1 when it had its card and did not start — its container stopped before it ran, say, or it
did not come up within 20 minutes — which trying again is unlikely to change: add says how it
ended, and seq gpu logs <id> says why;
2 when an argument cannot be had (a place outside the US, a count that is not 1, 2, 4 or 8 or that
its card has no machine of, a port that cannot be opened, a snapshot to start from that is not there or not
ready); 4 for a GPU or a snapshot of yours that is not there;
5 when a limit of yours does not allow it, or the GPU or the snapshot is not in a state for it (a GPU
not running or saving a snapshot, a name you have a snapshot of); 6 when your credit does not allow
it; and 7 when no card can be had now, or none came within 20 minutes, which is not billed and is
worth trying again later. A command that could not reach the platform at all exits 7 too. In Python, every sequence_ai.gpu call raises GpuBadRequest
for what you asked, GpuOverLimit at a limit or your credit, or GpuNoCard when no card
can be had, and add raises InternalError when a GPU had its card and did not start,
each imported from sequence_ai; the API answers as The API lists.
--no-wait returns once the GPU is asked for, starting: in seconds, not the minute or
two it takes to run. Pressing Ctrl-C while add waits — or while it is still being answered
— cancels it if it does not run yet, leaves it running if it does, and says what a cancelled GPU was
billed: nothing, or the seconds one of the places asked for it held a card
(What it costs). While it is still being answered, add says it is stopping
and removes what the platform adds as soon as it answers, in a few seconds; pressed again before then, it stops
at once and says they were not cancelled, as the platform may have added them: seq gpu list shows
them, and seq gpu remove <id> ends one. In Python, a KeyboardInterrupt while
add() is still being answered stops that call alone: what the platform adds then is yours all the
same — sequence_ai.gpu.list() shows it, and sequence_ai.gpu.remove() ends it.
Where it opens
place is where you want it near, in the United States: a US city, as "San Francisco, CA" or
"Austin, TX", or a latitude and longitude in the US, "37.77,-122.42". It is read on our
servers from a table of cities of 15,000 people or more, and sent nowhere else; for a smaller town, name the city
beside it, or give its latitude and longitude. Nothing is guessed: a name no city goes by, none in the state you
name, one that fits places more than 100 km apart, or a place outside the US — a city there, or a
latitude and longitude whose nearest city is — is refused with a 400 whose
details.reason is place_unknown, and details.candidates lists the US places it
could be, written as you can say them back ("Springfield, MO, US"; "Paris, TX, US" for
"Paris, France").
To choose a city from a list, as the console’s Add GPUs dialog does, seq gpu places and
sequence_ai.gpu.places() list the US cities whose name, or another name they go by, starts with what
you type (an airport’s code, as SFO, only typed whole): those of their own name first, each the
largest first, with its latitude and longitude; either is a place. A city found by another name says it:
seq gpu places big apple lists New York City (as Big Apple), and in Python its
also is that name, None for a city found by its own. A state after a comma narrows them,
and with nothing typed they list the largest US cities.
# the 8 largest, or limit= up to 20 cities_user = sequence_ai.gpu.places("san fr") # {"name": "San Francisco", ..., "lon": -122.4194, "also": None} city_user = cities_user[0] sequence_ai.gpu.add( place=f"{city_user['lat']},{city_user['lon']}", gpu="L4")
seq gpu places san fr # San Francisco, California, United States 37.7749, -122.4194 # Albuquerque, New Mexico, United States 35.0845, -106.6511 (as San Francisco Xavier) seq gpu add --place "37.7749,-122.4194" --gpu L4
Each GPU is then asked for at the places nearest yours, up to three at once, the quickest to reach first, by the
round trips Globalping’s public probes within 150 km of it measured over the
last 30 days — twice a day, at noon and at midnight US Eastern, probes in homes and data centres across the
states time a TCP handshake to each place — and by distance where no probe that near measured them. Some
places answer on the spot, with a card or with none, and only one of those is asked at a time: the next of them
waits for that answer, and a place farther off that takes longer to answer is asked meanwhile, so the three asked
together are not always the three nearest. A place
with no card is replaced by the next nearest, and the first to have the card wins; the others are cancelled
— one that had the card too is billed the seconds it held it, and those are in this GPU’s Spent. A GPU is shown by the place you asked for,
as you gave it — "San Francisco, CA", or the latitude and longitude — wherever its card
is: every place it is asked for at is in the United States, as its place must be.
City names and coordinates are from GeoNames, licensed under CC BY 4.0.
Ports, and who can reach them
--port opens a TCP port your server listens on; give it once for each port, up to 8, each from 1024 to
65535 but 8080, which SSH uses. --allow says which addresses can reach those ports: an IPv4 address or a
range (203.0.113.0/24), once for each, up to 16. Without --allow, only the address you ran
add from can: its public IPv4 address, so add reaches us over IPv4 to send it; on a network
with no IPv4 at all, it asks you for --allow instead. --allow 0.0.0.0/0 lets every
address in, and then your server has to check who is calling — a token in your protocol, or TLS of your
own — since we only check addresses.
Your robots connect to the GPU’s address and port directly, and nothing of ours is in between. A robot behind NAT is fine: it connects out to the GPU, which never connects back. A GPU has an IPv4 address only, so a robot with IPv6 alone cannot reach it.
When your robot’s or your office’s address changes, give the GPU its new list; it replaces the old one within seconds, without a restart:
seq gpu allow gpu-4d5e6f7a8b9c 203.0.113.0/24 198.51.100.7
In Python it is sequence_ai.gpu.allow(id, [...]), and in the API PUT
/v1/gpus/{id}/allow. Each says whether the GPU has taken the new list yet (applied); if it has
not, run it again in a few seconds.
A command at start
--run gives a command that bash runs in your container, from /root, as the GPU starts
— your server, typically. Its
output goes to /var/log/seq-run.log and to its logs. When it exits, it is
started again, waiting a little longer each time; if it exits within 10 seconds five times in a row, it is left
stopped and the GPU’s run says failing. The GPU keeps running and billing: fix what
the command runs over SSH, or remove the GPU. A command is at most 8,192 characters.
Only removing a GPU ends it. A process of yours that crashes or runs out of memory is started again, and so is SSH;
reboot in the container restarts the container, and the GPU stays.
Snapshots
seq gpu save <id> --name NAME saves what you changed on a GPU: what you installed and wrote, over
the base environment it started from, and its --run command. It answers saving at once and
saves in the background; your GPU keeps running, nothing paused or restarted, its reads and uploads given way to
what you run. --from NAME starts a GPU from it, with its command.
# --replace saves over one of that name seq gpu save gpu-1a2b3c4d5e6f --name policy-v1-user # each one: saving, ready or failed; its size; what it costs a month seq gpu saved seq gpu add --gpu L4 --place "Austin, TX" --from policy-v1-user # deleted, and its storage no longer billed seq gpu saved remove policy-v1-user
- A file being written while it saves may be saved half-written: stop what writes it first, or save again.
- A snapshot opens on any card, since your container does not depend on one; a program you built only for one card’s architecture may not run on another.
- A snapshot keeps what you changed, not the base environment under it: a GPU started from it gets the base environment new GPUs get, with your changes laid over it.
- A GPU started from a snapshot restores it before its command starts: the larger the snapshot, the longer it takes, and that time is billed as the GPU’s. Its log says when the restore starts, and how long it took.
- One snapshot saves at a time on a GPU, and a name is used once unless you
--replaceit. A snapshot larger than your storage limit allows is refused. - Removing a GPU while it saves is refused unless you add
--force, which gives that snapshot up, never billed. - When your account can spend no more, its GPUs end with their disks, and nothing is saved for you: save what you want to keep first.
A snapshot is kept in your account’s storage, at $0.12 a GB-month, and counts toward your storage limit (What it costs; who can read it, Data safety).
A name that stays
--name NAME (name= in Python) gives a GPU an address that stays,
NAME.<id>.gpu.generalsequences.com, where <id> is your account’s own
short id — made at random, never changed, the same for all your names, nothing of your email in it. A name is
lowercase letters, digits and hyphens, at most 40 of them; add and list give the whole
address as host. It is DNS alone: your robot still connects straight to the GPU. Set your robot to it
once:
- Add another GPU under the same name, and the name moves to it once it is running; the one before keeps running, without the name, until you remove it. So add the new one first, and your robots move over when it is up.
- When a GPU ends, its name is gone at once; your next GPU under that name brings it back.
- We ask for an answer to be kept 30 seconds at most, and a robot looks the name up again whenever it reconnects, as WebSocket, gRPC and HTTP clients do, so after a switch the name usually reaches the new GPU within seconds. Some DNS caches, a router’s or an internet provider’s, keep an old answer a minute or two longer, though, and until then can send your robot to a GPU the name was on before, even one that has ended, whose address the cloud may since have given someone else.
- So reaching the name is no proof of reaching your server: have your robot check that it has, before it sends anything or acts on a reply, by a certificate or a token of your own, as your server checks your robot.
Logs
Each GPU keeps a log, as a cloud’s console does: what happened to it, in our words — asked for, up, its image loaded, a snapshot it started from being restored and how long that took, answering over SSH, the addresses its ports are open to, its name pointed at it or gone to another of your GPUs, the command you gave it started, stopped or given up on, its end and why, and what it was billed — and every line that command printed. It is kept for 90 days after the GPU ends.
seq gpu logs <id> --follow # 21:04:11 EST Asked for: L4 near Denver, CO # 21:04:33 EST Started: its L4 came up 22 s after it was asked for # 21:05:30 EST Ready: SSH answers, 1 min 19 s after it was asked for # 21:05:31 EST Its command started # 21:05:33 EST | serving on :8000 # 22:10:02 EST Ended: removed by you # 22:10:02 EST Billed 1 h 5 min of L4: $1.32 seq gpu logs <id> --since 1h
--since takes 30m, 1h or 2d back from now, or a time such as
2026-11-12T21:00:00Z. In Python, sequence_ai.gpu.logs(gpu_id_user, since="1h") returns one
page; pass its next as after= to read on (The API). A line longer
than 2,000 characters goes on in the lines after it, and a GPU keeps its newest 10,000 lines of output.
The lines are oldest first, by their times. What your command did — started, exited — carries the
second it happened, and a line it printed the time it reached the log; both reach it within a few seconds, which
is when --follow shows them.
Its status
| status | what it means |
|---|---|
starting | a place is finding its card, and its machine is booting and making its image |
running | it answers over SSH |
failed | it ended on its own, and reason says why:
gpu_no_card, every place that could open it said it had no card, or none got one within 20
minutes; could_not_start, it did not
come up; container_exited, its container stopped (What you can do on
it); machine_lost, its machine went away |
shut_down | you removed it; or, with reason out_of_credit,
your account could spend no more (What it costs) |
A GPU that is not up 20 minutes after you asked for it fails. One that no place has a card for fails sooner,
once every place that could open it has said so. The list (seq gpu list) is of those
starting and running; one that has ended, shut down or failed, moves to its history (seq gpu history,
sequence_ai.gpu.history(), the console’s History), the one ended last first, for 30 days.
While it runs, its run says how the command you gave it is doing: running,
restarting, or failing once it is no longer started again, which seq gpu
list shows as run failing in place of running (A command at
start).
SSH in
seq gpu ssh <id> opens a shell on a running GPU, as root in its container, and
seq gpu ssh <id> -- nvidia-smi runs one command instead. It uses your key in
~/.ssh — id_ed25519, else id_rsa, else id_ecdsa, else the
first other .pub there — and makes an ed25519 key if you have none. Only the public half is sent:
the platform signs it into a certificate that lets that key in as root on that GPU alone, for 365 days, and
seq gpu ssh hands it to ssh without writing anything into ~/.ssh: the
GPU’s host key, learned on its first connect, is kept in a file of that GPU’s own under
~/.config/sequences, which seq gpu remove deletes with it.
# prints a Host block to add to ~/.ssh/config; its certificate # and host key are kept under ~/.config/sequences seq gpu ssh <id> --print # then, by its id, the name the block gives it ssh <id>
Run --print again when the certificate expires. Without the CLI, POST /v1/gpus/{id}/ssh
with your public key returns the GPU’s host, its port, 8080, and the
certificate: save it beside your private key as <key>-cert.pub
(~/.ssh/id_ed25519-cert.pub), where ssh finds it, or name it with
-o CertificateFile=. An ed25519 or ECDSA key works, and an RSA key of 2048 bits or more.
What you can do on it
A GPU’s machine is yours alone. You are root in a container on it that starts from our base environment:
Ubuntu 24.04 with Python 3.12 and its headers, pip, git, build tools, SSH and nvidia-smi, CUDA 12.8
with its compiler and headers, PyTorch 2.11 built for it, and NumPy 2.5 — torch.compile works as
it comes. That environment is base 2026.11, and we do not update it, so a snapshot you
save opens on the same base whenever you start a GPU from it. For other versions, install them on your GPU and save a
snapshot.
| You can | You cannot |
|---|---|
be root: install anything with apt or pip, and write anywhere in the
container | touch the machine itself: its host, its driver, its kernel modules |
| run any program, and use all of its cards | change or stop what we run outside your container: what starts it and what watches it |
open ports to your robots (Ports); SSH, scp, rsync,
port forwarding, VS Code Remote-SSH | start containers inside it: Docker does not run there |
| reach the internet | reach our internal network, private addresses, or the machine’s metadata service |
From outside, SSH reaches it on port 8080, and your robots the ports you opened, from the addresses you allowed.
Cryptocurrency mining is not allowed (Acceptable Use Policy). Outside your container we read, once a minute, how busy the card is, the names of the processes using it and where your container’s connections go — never your files or what is sent — and keep only what looks like mining (Data safety).
Remove
seq gpu remove <id>, sequence_ai.gpu.remove() or Remove on the console shuts a GPU
down at once: its machine ends, its billing stops, and its disk is deleted with it. Nothing on it
can be brought back, so save a snapshot first, or copy off what you want to keep with
scp, rsync or to your own storage. While a snapshot of it is saving, removing it is refused
unless you add --force, which drops that snapshot, unbilled. Removing one that is already shut down
answers the same.
We never shut a GPU down for sitting idle, and it has no time limit: it runs until you remove it, or until your account can spend no more.
What it costs
A GPU costs its card’s price an hour, plus the CPU and memory of the machine that card comes with at the
serving rates: an L4 is $0.80 an hour, and its machine has 8 cores and 32 GiB. Every card costs the same, on
a machine of several as on one of its own: a GPU of four L4s costs four times that. seq
gpus lists every card’s price, its machine and the rates, and the pricing page
the prices; seq gpu add says each GPU’s card price an hour, times its cards where it has
several, with + CPU and memory after it, and seq gpu list what each has cost so far.
A GPU is billed by the second from when its machine had its card, once it answers over SSH, and for at least 60
seconds each time one starts; one that never comes up is not billed. Of the places asked for a GPU at once, one that
had its card by the time another won is billed the seconds it held it, and those seconds are in what the GPU says it
spent (usd_so_far, the console’s Spent): what it says is what it is billed.
What a GPU sends out to the internet is billed at its cloud’s own price for that traffic, passed on as it is:
$0.09 or $0.12 a GB, by where it runs. It is counted in its container each minute, it is in what the GPU says it
spent — seq --json gpu list says it apart, as sent_usd — and your invoice
names it Data sent out. What it receives is not billed.
Saving a snapshot is not billed, whatever it sends into your storage. A snapshot is billed at $0.12 a GB-month
from when it is saved until you remove it, and sequence_ai.billing() lists what each one cost a day
as snapshot <name>.
Each is billed for its own size: two snapshots of the same files are billed twice, though the second sent almost nothing.
Earlier saves were billed for what they sent, and an invoice from then names them Snapshot saves;
stored_usd in seq --json gpu list is what a GPU’s saves were billed then, and 0
for every save since.
A GB of traffic sent out is 230 bytes, as the clouds count it; a GB stored is 109
bytes, as seq gpu saved shows a snapshot’s size.
Adding one needs no payment method on the account: like all usage, it is paid from your month’s credit first
(Account and billing). When your account can spend no more, adding a GPU is refused
with 402 insufficient_credit, and the GPUs you have are shut down, their disks with them
(shut_down, out_of_credit).
Limits
Each card of a GPU counts against your account’s GPU limit, the one your policies’ workers and your
evals count against too: 15 on Starter and 50 on Team (Plans), so a GPU of 8 cards
counts 8. seq gpu list shows how many of yours are in use. Its machine’s CPU and memory count
against your plan’s CPU and memory limits as well, so a card with a large machine reaches those first. Past
any limit, adding is refused with a 409 that says which limit it is, and nothing is added.
Each GPU has a disk of its own of at least 200 GB, and your container starts with at least 150 GB of it free for your weights, data and what you install. It is deleted with the GPU (Remove): keep what you need in a snapshot or off the GPU.
The API
What the SDK and the CLI call, under your own key (seq_dev_…) or a signed-in session. A robot
key is refused.
{"gpu", "place", "count", "from", "name", "ports", "allow", "run"}: count is the cards
of its machine, 1, 2, 4 or 8, and 1 unless you say; the others none unless you say; allow only with
ports, and the address the request came from where you give none. Returns
{"gpus": […]} once it is asked for, in seconds: the one GPU as GET lists it,
starting, with expected_rtt:
{"ms", "probes", "within_km": 150, "days": 30}, the median round trip the probes within 150 km of its
place measured over the last 30 days to where it gets its card — the place that took it, where that place
had the card over the last 14 days, else the quickest of the three nearest places that did — and how many
probes; "ms" null and "probes" 0 where none that near measured it;
expected_rtt null where the measures could not be read.
{"gpus": [{"id", "place", "gpu", "cards", "status", "started_at", "usd_so_far", "usd_per_hour", "address",
"name", "host", "ssh_port", "ports", "allow", "image", "robots", "run", "request", "request_cards"}], "quota":
{"used", "limit"}}, those live — starting or running — oldest first.
place is the place you gave POST, as you gave it; gpu is its card and
cards how many of it the machine has; request and request_cards are its
own id and cards, kept for programs that read them;
usd_so_far is what it is billed, the seconds another place held its card among them;
usd_per_hour is an hour of it in all, cards times one card’s — its price
plus its CPU and memory — as seq --json gpu list prints it; a card’s own price is what
seq gpus and the pricing page list
(What it costs); quota counts cards, a GPU of 4 using 4;
address and ssh_port once it runs; name and
host, the address the name reaches, on the GPU that holds its name (A name that
stays); image is base 2026.11 or snapshot <name>;
robots is {"count", "rtt_p50_ms"}; run is running,
restarting or failing, said within a few seconds of its command starting, and is not
there for a GPU with no command.
Those over, the one ended last first, kept 30 days: {"gpus": […], "total", "offset",
"next_cursor"}, each as GET /v1/gpus lists one, with its ended_at, and its
reason where it failed or ran out of credit. limit (1–200, 50 unless you say) and
cursor, the last page’s next_cursor, page it.
{"allow": […]}, the ranges that reach its ports from now on, in place of those it had. Returns
{"id", "allow", "applied"}, applied true once the GPU says its ports are open to those
alone.
{"name", "replace"}: saves a snapshot of it in the background, answering saving at once.
GET /v1/gpus/saved lists your snapshots, {"snapshots": [{"name", "status", "size_gb", "gpu",
"image", "saved_at", "usd_per_month", "reason"}]}, reason where one failed; DELETE
/v1/gpus/saved/{name} removes one.
{"public_key"}, one line of a .pub file. Returns {"host", "port": 8080, "user":
"root", "certificate"} for a GPU that is running.
Its log, oldest first: {"id", "status", "ended", "entries": [{"id", "at", "kind", "what", "text",
"detail"}], "next"}. kind is event, which what names —
requested, started, loaded, ready, allow,
name, run_started, run_exited, run_failing, ended (why in
detail.reason), billed — or output, a line its command printed.
since (30m, 1h, 2d, or a time with its zone),
after (a page’s next: ask again with it to follow, until ended and
nothing new) and limit (1–1000, 500 unless you say). Kept 90 days after it ends.
Shuts it down and returns {"id", "status": "shut_down"}, the same for one already shut down.
?force=true removes one while a snapshot of it is saving, giving that snapshot up, unbilled.
With no key: the round trips the latency map shows — of each place a probe measured from over the last 30
days, its median handshake to where a GPU there gets its card, the quickest of the three nearest places that really
had an L4 over the last 14 days —
{"measured", "opened_only", "places": [{"city", "state", "lat", "lon", "connection", "ms"}]}.
opened_only is false when no place had an L4 in that time; each place with the card then counts.
A refusal’s details.reason says why:
details.reason | status | when |
|---|---|---|
place_unknown | 400 | the place is no city and no latitude and longitude, or
names places far apart; details.candidates lists them |
gpu_unknown | 400 | no card is called that; the error lists those you can name |
gpu_count | 400 | count is not 1, 2, 4 or 8, or its card has
no machine of that many; details.counts lists the counts it can be |
gpu_ports | 400 | a port, a range or the command cannot be had, or
allow came without ports; the message says which |
snapshot_not_found | 400 | no snapshot of yours by that name is ready |
gpu_name | 400 | the name is not 1 to 40 lowercase letters, digits and hyphens; nothing was added |
gpu_name_unavailable | 503 | no GPU can be named right now; none was added, add it again shortly |
gpu_limit_reached, cpu_limit_reached, memory_limit_reached,
container_limit_reached | 409 | past one of your plan’s limits; nothing was added |
gpu_no_card | 503 | no machine of that card and count is free near that place right now; none was added |
gpu_busy | 503 | the platform’s GPUs are all in use right now |
gpu_not_running | 409 | SSH asked of a GPU that is not running, or an allow list of one that is over |
gpu_no_port | 409 | an allow list for a GPU that opened no port |
public_key | 400 | no ed25519, ECDSA or RSA public key of 2048 bits or more |
gpu_logs_since | 400 | a log’s since is no time and no span
back from now |
gpu_not_found | 404 | no GPU of yours has that id |
When your account can spend no more, adding is refused with 402 insufficient_credit
(Account and billing).