Pricing & Billing

Reactor uses pay-as-you-go pricing. You only pay for the time your session is actively holding a GPU. There is no subscription, minimum spend, or seat fee.

When you sign up, your account gets a free starting balance so you can try Reactor before you add a payment method. See the Dashboard for your current balance.

How pricing works

Reactor is a real-time streaming platform, so you pay for session time. Reactor meters each session per second of wall-clock time while it holds a GPU, even when you send no commands and receive no media. The prices below are in US dollars per minute, and your Dashboard balance is in US dollars.

You pay for the GPU, not the generation. Once a session reaches ready, the meter runs for every second the GPU is held for you, even if you are idle and not sending commands or receiving media. The same applies to recoverable disconnects: the GPU stays reserved on your behalf, so billing continues until the session is terminated.

Billable metrics are subject to change.

Models

Adding funds

Your balance is what the Terms of Service call Service Credits. It is shown in US dollars and has no cash value. You add funds up front and draw them down as your sessions run.

Detail	Value
Minimum purchase	$1
Maximum per transaction	$1,000
Minimum auto top-up	$5
Amounts	Whole dollars only

Reactor sets these limits, and the pricing endpoint below returns the current values, so you can read them at runtime instead of hard-coding them. Auto top-up, on the Billing page, adds funds for you. Pick a threshold and an amount. When your balance falls below the threshold, Reactor adds that amount. Both values are whole dollars. Each part of your balance has its own expiry date. The date depends on how you got it:

Free starting balance expires 90 days after Reactor adds it to your account.
Purchased funds, including auto top-ups, expire 365 days after Reactor adds them.
Promotional balance from a promo code follows the expiry rule of that code.

When billing starts and stops

Sessions move through a four-state lifecycle. Billing follows the lifecycle precisely:

State	Billed?	Why
`disconnected`	No	No session exists
`connecting`	No	Negotiating with Reactor; no GPU has been assigned yet
`waiting`	No	Reactor is allocating a GPU on your behalf
`ready`	Yes	A GPU is dedicated to your session and is producing media for you

The meter starts the moment your session reaches ready and runs until the session is terminated, not until your network connection drops. In a shared session, only the session creator’s termination stops the meter. A client that adopted the session and then disconnects does not stop billing; the session keeps running for its owner.

Billing lifecycle: connecting and waiting are free; the meter starts at ready and keeps running through a recoverable disconnect while the GPU stays reserved, stopping only when the session terminates

Recoverable disconnects

If you disconnect with recoverable=true, the GPU keeps your session alive on the server so you can reconnect later. Because the GPU is held for you, a recoverable session continues to bill while it waits for you to reconnect.

// Releases the GPU immediately. Billing stops.
await reactor.disconnect();

// Holds the GPU for reconnection. Billing continues.
await reactor.disconnect(true);

# Releases the GPU immediately. Billing stops.
await reactor.disconnect()

# Holds the GPU for reconnection. Billing continues.
await reactor.disconnect(recoverable=True)

Use recoverable=true only when you actually expect the user to come back within seconds. For everyday “the user closed the tab” cases, prefer the default disconnect so you stop paying immediately.

Minimizing cost

A few patterns that materially reduce spend:

Disconnect when idle. A connected session with no commands flowing still bills. Tear it down as soon as the user navigates away or finishes their task.
Default to non-recoverable disconnects. Recoverable sessions are useful, but they keep a GPU reserved (and metered) until you reconnect or the session times out.
Don’t pre-warm sessions speculatively. Time spent in connecting and waiting is free, so there is no benefit to opening sessions before the user is ready to interact.
Cap session length on the client. For interactive demos, set a hard timeout (e.g. five minutes) so a user who walks away from their browser does not run up the bill.

Usage tracking

Coming soon. Programmatic usage and billing endpoints are in development. For now, check the Dashboard for your current balance and spend.

Fetch pricing programmatically

Reactor exposes a public, read-only endpoint that returns the current pricing economics and, where available, the catalog of publicly-priced models. Use it to render up-to-date pricing on a marketing page, drive an in-app billing flow, or replace hard-coded numbers in client code. The endpoint reports the rate of each model per second, as a decimal string such as "0.0017". Multiply it by 60 for the per-minute prices shown above. Send a GET request to https://api.reactor.inc/pricing. No authentication is required.

curl -i https://api.reactor.inc/pricing

const res = await fetch("https://api.reactor.inc/pricing");
const pricing = await res.json();

const helios = pricing.models?.find((m) => m.name === "helios");
const dollarsPerSecond = helios?.rate.amount_per_sec_usd;

import httpx
from decimal import Decimal

pricing = httpx.get("https://api.reactor.inc/pricing").json()

helios = next((m for m in pricing.get("models", []) if m["name"] == "helios"), None)
dollars_per_second = Decimal(helios["rate"]["amount_per_sec_usd"]) if helios else None

Response

200 OK

{
  "settings": {
    "credits_per_dollar": 10000,
    "purchase": {
      "min_dollars": 1,
      "max_dollars": 1000
    },
    "auto_topup": {
      "min_dollars": 5
    },
    "max_account_credits": 0,
    "currency_code": "USD"
  },
  "models": [
    {
      "id": "f7d3a8b2-1c4e-4d2a-9b6f-0d8e3c1b5a47",
      "name": "helios",
      "rate": {
        "amount_per_sec": 17,
        "amount_per_sec_usd": "0.0017",
        "currency_code": "USD",
        "unit": "credits",
        "denomination": "second"
      }
    }
  ]
}

Field	Type	Always present	Description
`settings.purchase.min_dollars`	integer	yes	Minimum self-serve top-up amount, in whole dollars.
`settings.purchase.max_dollars`	integer	yes	Maximum self-serve top-up amount, in whole dollars.
`settings.auto_topup.min_dollars`	integer	yes	Minimum auto top-up amount, in whole dollars.
`settings.auto_topup.max_threshold_usd`	string	no	Highest balance threshold you can set for an auto top-up, in US dollars. Omitted when no cap is enforced.
`settings.max_account_credits_usd`	string	no	Account balance ceiling, in US dollars. Omitted when no cap is enforced.
`settings.currency_code`	string	yes	ISO 4217 currency code for every `*_usd` field under `settings`. Currently `"USD"`.
`models`	array	no	Public-model catalog. May be absent during initial rollout (see note below). When present, an empty array means no publicly-priced models are listed today.
`models[].id`	string (UUID)	when present	Model UUID.
`models[].name`	string	when present	Model name (e.g. `"helios"`, `"lingbot"`).
`models[].rate.amount_per_sec_usd`	string	when present	Cost per second of session time, in US dollars, to four decimal places.
`models[].rate.currency_code`	string	when present	ISO 4217 currency code for `amount_per_sec_usd`. Currently `"USD"`.
`models[].rate.denomination`	string	when present	Currently `"second"`.

Prices and balances are in US dollars. Fields that end in _dollars are whole-dollar integers, and fields that end in _usd are decimal strings. The response also has five fields in the internal ledger unit of Reactor (10,000 per US dollar). They are credits_per_dollar, max_account_credits, auto_topup.max_threshold_credits, rate.amount_per_sec, and rate.unit. Reactor keeps them for backward compatibility. Do not build against them.

The models field may be omitted from responses while the public catalog is rolling out. Treat an absent field and an empty array as semantically equivalent in your application logic. Once the rollout is complete the field will always be present.

Next steps

Sessions

Understand the connection lifecycle that billing is anchored to.

Dashboard

Check your usage, balance, and current spend.

Rate Limits

Concurrent session limits, token TTL, and error handling.

Get Started

Concepts

SDK Reference

Resources

Pricing & Billing

How pricing works

Models

Adding funds

When billing starts and stops

Recoverable disconnects

Minimizing cost

Usage tracking

Fetch pricing programmatically

Response

Next steps

Sessions

Dashboard

Rate Limits

​How pricing works

​Models

​Adding funds

​When billing starts and stops

​Recoverable disconnects

​Minimizing cost

​Usage tracking

​Fetch pricing programmatically

​Response

​Next steps

Sessions

Dashboard

Rate Limits

How pricing works

Models

Adding funds

When billing starts and stops

Recoverable disconnects

Minimizing cost

Usage tracking

Fetch pricing programmatically

Response

Next steps