---
sidebar_position: 2.1
tags: [account, agents]
description: Your first hour on Lium, step by step — sign up, top up, install the CLI, pick a node, rent it, run PyTorch on the GPU, copy a result back and stop billing. Every step shows what you will see and how long it takes.
---

> ## Documentation Index
> Fetch the complete documentation index at: https://docs.lium.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Your first hour

This page walks the whole path once: from no account to a result file on your laptop and a pod that has stopped billing. Each step says what you will see, how long it took when we timed it (6 Sep 2026, CLI 0.0.33, a 1×RTX 3090 at $0.25/h), and the one thing that trips people up. The dashboard-only version is the [Quickstart](./quickstart); this page adds the money and the CLI.

Whole run, install to `torch.cuda.is_available() == True`: **under 10 minutes** of wall clock, about $0.03 of GPU time.

## 0. What you need (2 min)

- An email address — or nothing at all, if you sign up with a [fingerprint](./fingerprint-signup).
- A way to pay: a card, a crypto wallet (USDT, USDC, ETH, BTC and others on several networks), or TAO. All top-ups are non-refundable.
- An SSH client (`ssh`, `scp`). Linux and macOS have one; on Windows use WSL.

What it costs: the cheapest single-GPU nodes are RTX 3090 / RTX 4090 at $0.20–0.35 per hour. You pay for the seconds the pod exists, from the moment it is created (provisioning included); the ledger is settled every 5 minutes and once more when the pod is removed. There is no hourly minimum.

## 1. Sign up (1 min)

Go to [lium.io/register](https://lium.io/register). Four ways in:

| Method | What happens next |
|---|---|
| Email + password | A verification email is sent; click its link before you log in. Look for the mail titled *"Please confirm your email"* — the welcome mail has no link. |
| GitHub / Google | Signed in at once. |
| **Register with fingerprint** | No email. You get a 32-character string that is your login **and the only way back into the account** — save it before you continue. |

New accounts may get **$5 of free credit** — only when the platform has it switched on *and* nobody has signed up from your IP address before. Check the balance in the top-left of the dashboard (or `lium balance`) rather than assuming it landed; a second signup from an office or home network normally gets nothing.

## 2. Top up (2–5 min)

Sidebar → **Billing** → **TOP UP**. Enter any amount above $0 (the presets are $10 / $20 / $50 / $100; there is no minimum) and pick a rail:

| Rail | Where it happens | Bonus | When the balance moves |
|---|---|---|---|
| Card | Stripe checkout in the browser | — | When Stripe confirms the payment — normally by the time you are redirected back to `/billing` |
| Crypto | Hosted invoice (21 currency/network pairs, e.g. USDT on Tron, USDC on Base) | +2.5 % | After on-chain confirmation; the invoice expires after 30 minutes, so send from a wallet you control, not an exchange withdrawal |
| TAO | `btcli` transfer from a wallet you first verify on the account | +5 % | After the transfer is seen; send from the verified wallet only |

Card top-ups exist only in the browser; the API and CLI can create crypto invoices (`lium topup`) and TAO transfers (`lium fund`).

:::caution Renting has a balance floor
`Rent` is refused until your balance is **above 15 minutes of the node's hourly price** — $0.07 for a $0.25/h node, $0.75 for a $3/h node. With a balance of exactly $0 the only message you get, on the web and from `lium up`, is *"Insufficient balance"*; with a balance between $0 and the floor the message names the node price and the amount required.
:::

## 3. Install the CLI (1 min)

```bash
curl -fsSL https://lium.io/install.sh | bash     # 36 s measured; binary, no Python needed
exec $SHELL -l                                    # or: export PATH="$HOME/.lium/bin:$PATH"
lium --version                                    # lium, version 0.0.33
```

The Python package is also fine — `uv tool install lium.io` or `pip install lium.io`. The name on PyPI is **`lium.io`**; `pip install lium` fails with *No matching distribution found for lium*.

## 4. Connect the CLI to your account (2 min)

```bash
lium init            # opens the browser, you click Approve, the key is stored in ~/.lium/config.ini
lium init --no-browser   # prints the approval URL instead (headless machines, agents)
```

If you have no SSH key, the CLI generates one at `~/.ssh/id_ed25519` the first time it needs one and registers it when you rent. If you would rather paste an API key than approve in the browser, create one under sidebar → **Access** → **API Keys** (it is shown once) and run `lium config set api.api_key sk_...`.

Check with `lium balance` — it prints your balance when the key works and an error when it does not. (`lium config show` also works, but it prints the full key; keep it out of logs and screenshots.)

## 5. Pick a node (2 min)

```bash
lium ls --gpu RTX4090          # or RTX3090, A6000, H100, ...
```

The table adapts to your terminal width, and that matters on the first run: at the default 80 columns it shows neither the node name nor the row index and truncates the prices to `0…`; the **Id** and **Location** columns only appear from about 130 columns, and the full table needs about 160. Widen the window or ask for JSON:

```bash
lium ls --gpu RTX4090 --format json | jq '.[] | {id, huid, price_per_hour, download_mbps, country}'
```

What the columns mean:

| Column | Meaning |
|---|---|
| **Id** | The node's name (e.g. `brave-wolf-26`) — in JSON as `huid`, next to the UUID `id` |
| **Config** | `N×GPU` — the number of GPUs you get and their model |
| **Tier** | `secure` (dedicated) or `spot` (may be reclaimed) |
| **Max CUDA** | The highest CUDA version the host driver supports |
| **$/GPU·h** | Price **per GPU** per hour. An `8×A100` row at `0.60` costs $4.80/h — multiply by the GPU count. JSON has both `price_per_gpu_hour` and `price_per_hour` |
| **Location** | Country of the machine |
| **VRAM / RAM / Disk** | GB per GPU, host RAM, disk available to the pod |
| **Upload / Download** | The provider's speed-test result in Mbps. A rough filter, not a promise: measure inside the pod before a large download |
| **Ports** | How many ports you can expose besides SSH |
| **★** | Pareto-optimal on price against bandwidth — the rows the CLI would auto-select from |

Not shown yet: CPU count and whether multi-GPU nodes have NVLink — both are on the way; until then check `nvidia-smi topo -m` on the pod for anything with more than one GPU.

## 6. Rent (1 min)

```bash
lium up 54075f7a-1114-40fa-884a-9b617ab2dc31 --name first --ttl 2h -y --no-ssh
```

- Use the **UUID** from `--format json`. The released CLI (0.0.37) answers the short name the table shows (`brave-wolf-26`) with *"Node 'brave-wolf-26' not found"*; the name is accepted with lium#153 (not released).
- `--ttl 2h` is your safety net: the pod removes itself and stops billing even if you forget it. Set it every time.
- `-y` skips the confirmation, `--no-ssh` returns instead of dropping you into an SSH session.

What you see: `Est. deploy time: ~1m 0s (image: ~3.5 GB, download: 614 Mbps)` and then nothing until `Pod brave-hawk-d5 (name: first, id: …) ready` — 42 seconds here. Typical is 20–60 s with the default image; a node that has to pull the image first can take several minutes. `lium ps` shows the status meanwhile.

## 7. Run something on the GPU (3 min)

```bash
lium exec first "nvidia-smi -L"
lium exec first "python -c 'import torch; print(torch.__version__, torch.cuda.is_available(), torch.cuda.get_device_name(0))'"
# 2.12.0+cu130 True NVIDIA GeForce RTX 3090
lium ssh first        # an interactive shell, when you want one
```

The default template (`daturaai/pytorch`, Ubuntu 24.04, Python 3.12) has PyTorch with CUDA ready. Things that surprise people in the first ten minutes:

- **`pip install x` fails** with `externally-managed-environment` (PEP 668). Use `pip install --break-system-packages x`, or a venv: `python -m venv /workspace/venv && . /workspace/venv/bin/activate`.
- **Jupyter is not running** even though port 8888 is mapped. Ask for it when you rent (`lium up ... --jupyter`, or the Jupyter checkbox in the web form) and the CLI prints the URL and token.
- **`/root` is an encrypted volume** (persists across a reboot, but slower for large files); **`/workspace`** is plain disk. Keep datasets, model weights and caches in `/workspace` (`export HF_HOME=/workspace/hf`).
- **Missing tools**: `nvcc`, `ffmpeg`, `screen`, `git-lfs`. Present: `git`, `rsync`, `tmux`, `htop`, `jq`, `vim`, `curl`. `apt-get update && apt-get install -y ffmpeg` works.
- **Long commands**: `lium exec` waits for the command to finish; start anything over a minute with `nohup … > log 2>&1 &` and tail the log.

## 8. Get a result back (1 min)

```bash
lium exec first "python train.py > /root/out.txt"
lium scp first /root/out.txt ./ -d       # -d = download
```

The CLI copies over SSH through the pod's public port; a 10 MB file took 18 s in our run. For anything above a few hundred megabytes, push from the pod straight to object storage or Hugging Face instead of pulling it through your laptop.

## 9. Stop billing (1 min)

```bash
lium rm first -y
lium ps               # the pod is gone within seconds
```

Removal settles the last partial billing interval. **Billing** in the dashboard shows what you spent per day, split into pods and volumes; while a pod runs, `lium ps` shows its `$/h` and `Spent`. There is no per-pod statement after removal today, so note the `Spent` figure before you remove a pod if you need it.

## Measured timeline

| Step | Time | Notes |
|---|---|---|
| Install the CLI | 36 s | binary download + PATH line |
| Sign up (fingerprint) | 1 s | `signup_credit_granted: false` on a network that had signed up before |
| Top up | — | the only step that needs a human and a payment method |
| `lium ls` | 3 s | 162 nodes listed |
| `lium up` → `ready` | 42 s | 1×RTX 3090, default template |
| first `torch.cuda` result | 8 s after `ready` | via `lium exec` |
| `pip install` (10 MB of wheels) | 5 s | with `--break-system-packages` |
| `lium scp` 10 MB out | 18 s | |
| `lium rm` → gone from `lium ps` | 6 s | |
| GPU time billed for the run | $0.024 | 5 min 43 s at $0.25/h |

## Next

- [Quickstart](./quickstart) — the same journey from the dashboard only
- [Templates](./templates) — other images, or your own
- [Scheduled termination](./scheduled-termination) — what `--ttl` does and how to change it on a running pod
- [API keys](./api-keys) — keys for agents, CI and teammates
- [AI agents](/developers/agents) — the same first hour with no human in the loop