Documentation Index
Fetch the complete documentation index at: /llms.txt
Use this file to discover all available pages before exploring further.
Skip to main content
Private beta · Reactor Serve is available by invitation. Request access
Private beta · Reactor Serve is available by invitation. Request access
Pricing & Billing
Copy pageCopy page
How Reactor charges for sessions, when billing starts and stops, and how to track usage
Copy pageCopy page
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.
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:
The meter starts the moment your session reaches 
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 |
- 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 |
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.
Recoverable disconnects
If you disconnect withrecoverable=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.
JavaScript
Python
// 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
connectingandwaitingis 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
JavaScript
Python
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.
⌘I
Assistant
Responses are generated using AI and may contain mistakes.