Dynamic GPU Pricing for Neoclouds: Set Hourly Prices From Your Costs and the Live Market

A neocloud knows three things about its servers that no marketplace knows: what each GPU hour costs, which contracts start next week, and how much idle time it can live with. A fixed price set by someone else ignores all three.

On Paralon the price of every server you connect is yours, and you can change it from your own systems as often as you like: by the Provider API, by an AI agent through the MCP server, or by hand in the dashboard. This guide is a method for using that well: where the floor is, how to follow the market without racing to the bottom, a tested script, the same policy for an AI agent, and a simulation of what it is worth.

What you control, and the limits

You keep 80% of what each rental bills, credited by the minute.

Step 1: your floor

The floor is the lowest hourly price at which a server still pays for itself. Below it, every rental loses money, however full the fleet looks.

Start with what one GPU costs you per hour whether it is rented or not. An example for a B300 you own, with assumptions you should replace with your own:

Then divide by the share of hours you plan to be rented and by what is left after the platform fee:

floor per GPU-hour = cost per GPU-hour / (planned utilization × (1 − fee))

With 60% planned utilization and a 20% fee: $2.19 / (0.6 × 0.8) = $4.57 per GPU-hour. Plan on 40% and the floor rises to $6.84. The planned utilization is the number to be honest about: it is what turns a cost into a price.

If you lease the capacity instead of owning it, your cost per GPU-hour is the lease, and the floor is far closer to the market. Run the numbers before you list.

Step 2: read the market

Paralon publishes a public price feed, https://paraloncloud.com/pricing-api/offers, with an entry per GPU model: the lowest price among the servers free to rent right now, and whether any is in stock. That is the price a renter sorting by price sees first.

Use it as a ceiling, not a target. If your servers carry something renters can see (location, bandwidth, a reputation score, interconnect), you can sit above the cheapest offer. Twenty-five percent above it is the cap in the script below.

Step 3: rules that hold margin

Four rules cover most of it:

1. Never below the floor. Not for a quiet afternoon, not to win one rental.
2. Raise when you are nearly full. At 85% of the fleet rented, the next free server is scarce: add 5%.
3. Lower when a server sits idle. After four hours without a rental, take 5% off, then again after the next run if it is still idle.
4. Move in small steps. 5% per run at most. Big jumps confuse renters and overshoot.

Run them every hour. Rented nodes are skipped: their price is locked until the rental ends.

The script

Sixty lines of Python on the Provider API. It needs a key with the My nodes scope (Console → API keys) in PARALON_API_KEY. It prints what it would change, and changes prices only with --apply. The API does not record when a node's last rental ended, so the script keeps that in a small file of its own.

import json, os, sys, time, requests

API = "https://paraloncloud.com/api/v1"
FEED = "https://paraloncloud.com/pricing-api/offers"
H = {"Authorization": f"Bearer {os.environ['PARALON_API_KEY']}"}
APPLY = "--apply" in sys.argv            # without it, print what would change
STATE = os.path.expanduser("~/.paralon-pricer.json")

COST_PER_GPU_HOUR = 2.19   # depreciation + power + colocation and ops
TARGET_UTIL = 0.60         # the share of hours you plan to be rented
FEE = 0.20                 # platform fee
STEP = 0.05                # largest change per run
IDLE_HOURS = 4             # lower the price after this long without a rental
FULL = 0.85                # raise when this share of the fleet is rented
CAP_OVER_MARKET = 1.25     # never more than 25% above the cheapest free node

def model(name):
    return name.replace("NVIDIA ", "").replace("GeForce ", "")

nodes = requests.get(f"{API}/nodes", headers=H, timeout=30).json()["nodes"]
market = {model(o["name"]): o["price_per_gpu_hour_usd"]
          for o in requests.get(FEED, timeout=30).json()["offers"]}
try:
    last_rented = json.load(open(STATE))
except (OSError, ValueError):
    last_rented = {}

fleet = [n for n in nodes if n["type"] == "gpu" and not n["spot"] and n["gpus"]]
share_rented = sum(n["state"] == "rented" for n in fleet) / max(len(fleet), 1)
now = time.time()

for n in fleet:
    if n["state"] == "rented":
        last_rented[n["id"]] = now        # a running rental keeps its price
        continue
    if n["state"] != "available":
        continue
    gpus, price = len(n["gpus"]), n["price"]
    current = price["renter_pays"]
    floor = COST_PER_GPU_HOUR * gpus / TARGET_UTIL / (1 - FEE)
    idle_h = (now - last_rented.setdefault(n["id"], now)) / 3600

    target = current
    if share_rented >= FULL:
        target = current * (1 + STEP)
    elif idle_h >= IDLE_HOURS:
        target = current * (1 - STEP)
    cheapest = market.get(model(n["gpus"][0]["model"]))
    if cheapest:
        target = min(target, cheapest * gpus * CAP_OVER_MARKET)
    target = round(min(price["max"], max(price["min"], floor, target)), 2)

    print(f"{n['name']}: {current} -> {target} (idle {idle_h:.0f} h, floor {floor:.2f})")
    if APPLY and abs(target - current) >= 0.01:
        requests.patch(f"{API}/nodes/{n['id']}", headers=H,
                       json={"price_per_hour": target}, timeout=30).raise_for_status()

json.dump(last_rented, open(STATE, "w"))

Run it from cron every hour: 0 * * * * python3 pricer.py --apply. We ran it against the live API and against a simulated fleet of B300 servers priced at $12.20, with the cheapest free one at $11.50. With seven of eight rented, the free one went to $12.81. A server idle for six hours went to $11.59. One idle for thirty hours at $6.40 stopped at $6.10, half the default, where the API's range ends.

The same policy for an AI agent

The @paraloncloud/mcp server gives Claude Code, Claude Desktop or Cursor the tools to do this from a sentence: list_my_nodes, get_my_node, set_node_price, update_node, set_node_available and get_earnings, with list_gpus for what renters see. Give the agent the rules as a policy, with the floor as a hard limit:

Every hour: list my nodes and the GPUs on the market. Never set a B300 server below $4.57 per GPU-hour. Skip rented nodes. If 85% or more of my fleet is rented, raise free nodes by 5%. If a node has had no rental for four hours, lower it by 5%. Never go more than 25% above the cheapest free B300. Tell me every change and why.

A script does exactly what it says. An agent can also weigh what the rules cannot see: a contract that starts tomorrow (take those servers off the market tonight instead of discounting them), a maintenance window, a customer who asked for capacity next week. Keep the floor in the policy either way, and read the changes it reports.

What it is worth: a 30-day simulation

We simulated a fleet of eight single-GPU B300 servers for 30 days, hour by hour, 20 runs each, with the cost and floor from step 1. Renters arrive more often in the European and American day than at night and at weekends, and each one picks the cheapest free server, more likely to take it the closer its price is to the market's. The market price drifts and dips mid-month as new supply arrives. Three ways to price:

• Fixed at the default, $12.20 all month.
• Fixed at the bottom, the lowest price allowed.
• Dynamic, the four rules above.

Owner profit over 30 days, after the 20% fee and the fixed costs, with the share of hours rented:

Three things to take from it:

• Dynamic pricing came out ahead in all three markets. In the busy month it made 31% more than the fixed default and twice what the cheapest price made.
• The cheapest price fills the fleet and leaves money on the table. At 96% utilization in the busy month it earned less than the default at 63%. Utilization is not the goal; margin is.
• In a slow month no price saves you. Every strategy lost money. Pricing moves demand between sellers; it does not create it.

The demand model is ours and simple: your market will differ. Treat the ranking as the lesson, not the dollar figures, and rerun the logic with your own costs.

When demand is slow: sell ahead instead

The answer to a slow month is not a lower price but a different sale:

• Reserved deals. List servers in the capacity directory for monthly reservations on your terms: price, minimum term, down payment. See Reserved GPU Capacity, With or Without a Down Payment.
• Private nodes. Keep a server for one customer, by email, company domain or organization; nobody else sees it (private nodes).
• Spot. Rent servers you will need back at the default minus the spot discount, and reclaim them with two minutes' notice when a contract starts.

The same fleet can do all of it at once, with the pricing loop running on the servers that are on the open market. How the pieces fit for a neocloud is in For Neoclouds: Sell Idle GPU Capacity Without Selling It at a Discount.

Get started

1. Connect your servers: add a node, one command per machine.
2. Create a key with the My nodes scope in the console, and read the Provider API reference.
3. Put your costs in the script, run it without --apply for a day, read what it would do, then let it run.

Running a large fleet, or want to price a reserved deal together? Write to [email protected] with the GPU model, how many, where and for how long. Everything for owners, buyers and brokers is on one page: Reserved GPU capacity.