Developers

GPU cloud,
from your terminal.

One static binary for macOS, Linux and Windows. Launch a GPU, SSH in, install Jupyter and tear it down without opening a browser. The same REST API runs your CI jobs and your agents.

~ packet
$ packet launch --gpu b200 --name trainer --wait
Launched 1 x NVIDIA B200 Dynamic
  Instance ID: cmr8x2k9a
  Price:       $4.25/hr
Waiting for the instance to take SSH...
Ready: ssh -p 30122 ubuntu@203.0.113.24

$ packet setup jupyter-torch cmr8x2k9a
$ packet ssh cmr8x2k9a --command "nvidia-smi -L"
GPU 0: NVIDIA B200
$ packet terminate cmr8x2k9a --force
Install

Download one file.
That's the install.

No runtime, no package manager. Put the binary on your PATH, paste an API key from the console, and you're in.


    

Then log in

Create an API key in the console under API keys, and paste it once. In CI, set PACKET_API_KEY instead.

$ packet login

With sshpass installed, packet ssh and packet setup also type the instance password for you.

All downloads
Commands

Every command,
on one screen.

packet <command> -h lists a command's flags.

CommandWhat it does
packet gpusGPU types, regions and prices
packet launch --gpu b200 [--region 7] [--name x] [--wait]Launch a GPU; --wait returns when SSH is ready
packet psYour instances and their state
packet ssh <id> [--command cmd] [--copy]Log in, run one command, or print the ssh line
packet setup list · packet setup <preset> <id>Install vscode, jupyter, jupyter-torch, workspace or full-dev on a running GPU
packet logs <id> [--follow]Instance status, refreshed until it ends
packet note set <id> --note "run 4"Label an instance so you remember what it was
packet terminate <id> [--force]Stop and delete; charges stop
packet whoami · packet logoutWho you're logged in as; forget the key
REST API

Everything the console does,
over HTTP.

JSON over HTTPS with a Bearer API key. Launches take an Idempotency-Key, so a retried request never starts a second GPU.

GET /instances/launch-optionsProducts and regions
POST /instancesLaunch
GET /instancesList
GET /instances/{id}/connectionSSH details
DELETE /instances/{id}Terminate
Full API reference
curl · https://dash.packet.ai/api/v2
# 1. pick a product and region
curl -s https://dash.packet.ai/api/v2/instances/launch-options \
  -H "Authorization: Bearer $PACKET_API_KEY"

# 2. launch it
curl -s -X POST https://dash.packet.ai/api/v2/instances \
  -H "Authorization: Bearer $PACKET_API_KEY" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"product_id": "<id>", "region_id": 7, "name": "trainer"}'
{"id": "cmr8x2k9a"}

# 3. connect when it's ready
curl -s https://dash.packet.ai/api/v2/instances/cmr8x2k9a/connection \
  -H "Authorization: Bearer $PACKET_API_KEY"

# 4. done
curl -s -X DELETE https://dash.packet.ai/api/v2/instances/cmr8x2k9a \
  -H "Authorization: Bearer $PACKET_API_KEY"
CI/CD

A GPU for one job,
then gone.

Launch a GPU at the start of a pipeline, run training or evals on it, and terminate it in a step that always runs. You pay for the minutes the job took.

  • Works in GitHub Actions, GitLab CI, Buildkite or a Makefile
  • API key from a CI secret, no interactive login
  • if: always() terminate, so a failed job never leaves a GPU running
  • Team budgets cap what pipelines can spend
.github/workflows/train.yml
name: train
on: workflow_dispatch
jobs:
  train:
    runs-on: ubuntu-latest
    env:
      PACKET_API_KEY: ${{ secrets.PACKET_API_KEY }}
    steps:
      - name: Install the packet CLI
        run: |
          curl -fLo packet https://dash.packet.ai/downloads/packet-v2.1.0-linux-amd64
          chmod +x packet && sudo mv packet /usr/local/bin/
          sudo apt-get install -y sshpass
      - name: Launch a B200
        run: |
          ID=$(packet launch --gpu b200 --name "ci-$GITHUB_RUN_ID" --wait \
               | awk '/Instance ID:/ {print $3}')
          echo "ID=$ID" >> "$GITHUB_ENV"
      - name: Train
        run: |
          packet ssh "$ID" --command \
            "git clone --depth 1 https://github.com/$GITHUB_REPOSITORY app && cd app && python train.py"
      - name: Terminate
        if: always()
        run: packet terminate "$ID" --force
Agents

Let your agent
rent its own GPU.

Coding agents already drive a terminal, so the CLI is all they need. For your own agent loop, wrap the API in a tool. Budgets and roles keep it inside the limits you set.

AGENTS.md
## GPUs
When a task needs a GPU, use the packet CLI:
- `packet gpus` to see types and prices
- `packet launch --gpu <type> --wait` (note the Instance ID)
- `packet ssh <id> --command "<cmd>"` to run work
- Always `packet terminate <id> --force` when done.
Prefer the cheapest GPU whose memory fits the model.
tools.py · a GPU tool for any agent framework
import os, uuid, requests

API = "https://dash.packet.ai/api/v2"
H = {"Authorization": f"Bearer {os.environ['PACKET_API_KEY']}"}

def launch_gpu(product_id: str, region_id: int, name: str) -> str:
    """Start one GPU and return its instance id."""
    r = requests.post(f"{API}/instances", json={
        "product_id": product_id, "region_id": region_id, "name": name,
    }, headers={**H, "Idempotency-Key": str(uuid.uuid4())})
    r.raise_for_status()
    return r.json()["id"]

def terminate_gpu(instance_id: str) -> None:
    """Terminate the GPU so billing stops."""
    requests.delete(f"{API}/instances/{instance_id}", headers=H).raise_for_status()

Your next run
starts at $0.39.

Sign up, top up, launch. You'll be on a GPU in minutes.

No contractHourly or flat monthlyTalk to a human any time