Docs

GPUs

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:

an L4 near San Francisco, port 8000 open to youshell
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:

set up once, then one command a dayshell
# 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.

four L4s on one machineshell
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:

the same day, from Pythonpython
# 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"])
or from any languageshell
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.

choose San Francisco from a listpython
# 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")
the same from the command lineshell
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:

change who can connectshell
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.

save, list, start from, removeshell
# --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 --replace it. 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.

its log, then what comes, until it endsshell
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

statuswhat it means
startinga place is finding its card, and its machine is booting and making its image
runningit answers over SSH
failedit 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_downyou 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.

VS Code Remote-SSH, or a plain sshshell
# 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 canYou cannot
be root: install anything with apt or pip, and write anywhere in the containertouch the machine itself: its host, its driver, its kernel modules
run any program, and use all of its cardschange 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-SSHstart containers inside it: Docker does not run there
reach the internetreach 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.

POST/v1/gpus

{"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.

GET/v1/gpus

{"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.

GET/v1/gpus/history

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.

PUT/v1/gpus/{id}/allow

{"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.

POST/v1/gpus/{id}/save

{"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.

POST/v1/gpus/{id}/ssh

{"public_key"}, one line of a .pub file. Returns {"host", "port": 8080, "user": "root", "certificate"} for a GPU that is running.

GET/v1/gpus/{id}/logs

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.

DELETE/v1/gpus/{id}

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.

GET/v1/gpus/rtt

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.reasonstatuswhen
place_unknown400the place is no city and no latitude and longitude, or names places far apart; details.candidates lists them
gpu_unknown400no card is called that; the error lists those you can name
gpu_count400count 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_ports400a port, a range or the command cannot be had, or allow came without ports; the message says which
snapshot_not_found400no snapshot of yours by that name is ready
gpu_name400the name is not 1 to 40 lowercase letters, digits and hyphens; nothing was added
gpu_name_unavailable503no GPU can be named right now; none was added, add it again shortly
gpu_limit_reached, cpu_limit_reached, memory_limit_reached, container_limit_reached409past one of your plan’s limits; nothing was added
gpu_no_card503no machine of that card and count is free near that place right now; none was added
gpu_busy503the platform’s GPUs are all in use right now
gpu_not_running409SSH asked of a GPU that is not running, or an allow list of one that is over
gpu_no_port409an allow list for a GPU that opened no port
public_key400no ed25519, ECDSA or RSA public key of 2048 bits or more
gpu_logs_since400a log’s since is no time and no span back from now
gpu_not_found404no GPU of yours has that id

When your account can spend no more, adding is refused with 402 insufficient_credit (Account and billing).