Renting an 8x B300 by the hour: what it costs and how to start

Posted by the Lium team. Lium is the GPU marketplace used in this post. Every number links to a public source you can check yourself.

Video (24 s, play the MP4): one command for 8x B300. The prices on screen were live on lium.io at 02:29 UTC on 24 September 2026.

An 8x B300 node has 2,304 GB of GPU memory (288 GB per card, per Lium's price feed). That is enough to hold very large models on one machine. This post covers three things: what is on the market right now, what an hour costs to the cent, and the commands that take you from nothing to a running 8-GPU pod.

What is free right now

Lium publishes two unauthenticated feeds: pricing.json, one row per GPU model, and the public nodes feed, one row per rentable node. I read both at 02:44 UTC on 24 September 2026 (nodes feed generated_at 02:44:13Z). These are the whole 8-GPU hosts that were free at that minute:

GPU	Free 8x hosts	Price per GPU-hour
B300	5	$8.50–$9.50
B200	0	–
H200	1	$4.00
H100 80GB HBM3	1	$2.75
A100-SXM4-80GB	4	$1.13–$1.23

On the same read, single GPUs were free too: 43 B300 at $8.25–$9.50, 2 B200 at $5.60, 19 H200 at $3.00–$4.22, 27 H100 at $1.30–$2.75 and 33 A100 80GB at $0.999–$1.23.

Video (23 s, play the MP4): the lowest live ask for ten GPU models, from one curl. Its prices are from 02:29 UTC; the table above is the 02:44 UTC read.

Providers set their own prices, so these numbers move. The feed is rebuilt at most once a minute (docs). This one-liner prints every free 8-GPU host of these five models when you read this:

curl -sS https://lium.io/api/public/v1/nodes | jq -c '.nodes[]
  | select((.gpu_model | test("B300|B200|H200|H100|A100")) and .available_gpu_count >= 8)
  | {gpu_model, available_gpu_count, price_per_gpu_hour, reliability_score, country_code}'

What it costs

Lium bills per second at the listed hourly price: a pod costs hourly price × seconds / 3600 for the exact seconds it exists, with no minimum (billing docs). At $8.50 per GPU-hour, the lowest 8x B300 ask on this read, an 8x B300 pod costs $68.00 per hour:

Pod lifetime	Cost for 8x B300 at $8.50/GPU-hour
20 seconds (a smoke test that fails fast)	$0.38
1 minute	$1.13
10 minutes	$11.33
1 hour	$68.00

Three billing details are worth knowing before you start:

• Balance floor. A rent needs a balance that covers at least 15 minutes of the pod's hourly price. For $68.00/hour that is $17.00.
• When money moves. Running pods are charged every 5 minutes, and the remainder is settled the moment the pod is removed.
• The clock starts at deploy. The short provisioning window before the pod reads RUNNING is billed, so a pod that takes 60 seconds to boot costs $1.13 before your code runs.

Start from the CLI

The CLI and the Python SDK come in one package (README). Install and sign in:

curl -fsSL https://lium.io/install.sh | bash   # or: pip install lium.io
lium init                                     # opens the browser to approve; --no-browser prints the URL
lium balance

Top up in the dashboard (card or crypto). Then list the B300 nodes. --gpu B300 matches both B300 SXM6 model names on Lium (AC and PC), which are the same card (CLI quickstart):

lium ls --gpu B300

Rent eight GPUs with a hard stop, and have the CLI prove the pod has the GPUs you pay for:

lium up --gpu B300 --count 8 --name b300 --ttl 2h --verify-gpus --strict-gpus --yes --no-ssh

• --gpu with --count 8 takes the lowest-priced matching node. --ttl 2h removes the pod after two hours, so a forgotten pod stops billing on its own. --budget 150 stops it once $150 has been spent.
• --verify-gpus counts the GPUs nvidia-smi -L sees inside the pod and compares that with the billed count. --strict-gpus removes the pod on a mismatch (lium up reference).

Run, copy results back, and stop billing:

lium exec b300 "nvidia-smi -L"
lium scp b300 /workspace/out.tar ./ -d
lium rm b300 -y

Start from Python

The SDK's rent() picks a node that fits a spec. dry_run=True shows the node and the price without renting (SDK reference):

from lium.sdk import Lium

lium = Lium()
quote = lium.rent(gpu_type="B300", gpu_count=8, max_price_per_gpu_hour=9.50,
                  name="b300", dry_run=True)
print(quote.executor.huid, quote.gpu_count, quote.price_per_hour)

rented = lium.rent(gpu_type="B300", gpu_count=8, max_price_per_gpu_hour=9.50, name="b300")
pod = lium.wait_ready(rented.pod, timeout=900)
print(lium.exec(pod, command="nvidia-smi -L", timeout=60)["stdout"])
lium.down(pod)

Two minutes of checks before a big job

On any 8-GPU pod, the first two commands decide whether a tensor-parallel job will run well (Before you rent 8 GPUs):

lium exec b300 "nvidia-smi topo -m && nvidia-smi topo -p2p r"

Every off-diagonal GPU cell of topo -m should read NV#, and every cell of -p2p r should read OK. Then time a real download to the disk you will use, since checkpoint pulls vary widely between nodes:

lium exec b300 "cd /workspace && time hf download openai-community/gpt2 model.safetensors --local-dir /workspace/probe"

Two notes for Blackwell from the README: use a cu128 or newer PyTorch build (pip install torch --index-url https://download.pytorch.org/whl/cu130), and use FlashAttention-4 or cuDNN attention, since FlashAttention-3 is Hopper-only.

When no 8x B300 is free

File a machine request: dashboard → Machine Requests → ADD NEW, then pick the GPU model and a GPU count of 8. Providers subscribed to that GPU type are emailed your request. Lium checks the marketplace every 5 minutes for 30 days and emails you, at most once a day, when a node that fits is listed (docs). New 8x B300 hosts go fast: on 22 September, Lium's rental records show two new hosts rented within 22 and 41 minutes of listing, so rent from the link when the email arrives.

Current prices per model are on lium.io/pricing, and the B300 page is lium.io/gpu/b300-sxm6-ac.