Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.reactor.inc/llms.txt

Use this file to discover all available pages before exploring further.

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.
New accounts receive free credits so you can try Reactor before adding a payment method. See the Dashboard for your current balance.

​
How pricing works

Reactor is a real-time streaming platform, so billing is per session-second. While your session is connected to a GPU, you are billed for every second of wall-clock time, regardless of whether you are actively sending commands or receiving media. Prices below are in US dollars; your Dashboard balance is shown in credits.
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

​
Buying credits

Your balance is held in credits, which you buy up front and draw down as your sessions run.
DetailValue
Exchange rate10,000 credits per US dollar
Minimum purchase$1
Maximum per transaction$1,000
Maximum balanceUp to $10,000 of credits held at one time
Credits expire based on how they were added to your account:
  • Promotional credits (including the free signup credits) expire 90 days after they are issued.
  • Purchased credits expire 365 days after they are issued.

​
When billing starts and stops

Sessions move through a four-state lifecycle. Billing follows the lifecycle precisely:
StateBilled?Why
disconnectedNoNo session exists
connectingNoNegotiating with Reactor; no GPU has been assigned yet
waitingNoReactor is allocating a GPU on your behalf
readyYesA 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.
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);
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. Send a GET request to https://api.reactor.inc/pricing. No authentication is required. 
curl -i https://api.reactor.inc/pricing

​
Response

200 OK 
{
  "settings": {
    "credits_per_dollar": 10000,
    "purchase": {
      "min_dollars": 1,
      "max_dollars": 1000
    },
    "auto_topup": {
      "min_dollars": 5
    },
    "max_account_credits": 0
  },
  "models": [
    {
      "id": "f7d3a8b2-1c4e-4d2a-9b6f-0d8e3c1b5a47",
      "name": "helios",
      "rate": {
        "amount_per_sec": 17,
        "unit": "credits",
        "denomination": "second"
      }
    }
  ]
}
FieldTypeAlways presentDescription
settings.credits_per_dollarintegeryesCredits awarded per US dollar in self-serve purchases.
settings.purchase.min_dollarsintegeryesMinimum self-serve top-up amount, in whole dollars.
settings.purchase.max_dollarsintegeryesMaximum self-serve top-up amount, in whole dollars.
settings.auto_topup.min_dollarsintegeryesMinimum auto top-up amount, in whole dollars.
settings.auto_topup.max_threshold_creditsintegernoHighest balance threshold (in credits) an auto top-up can be set at. Omitted when max_account_credits is 0 (no cap).
settings.max_account_creditsintegeryesOn-ledger credit-balance ceiling for an account, in credits. 0 means no cap is enforced.
modelsarraynoPublic-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[].idstring (UUID)when presentModel UUID.
models[].namestringwhen presentModel name (e.g. "helios", "lingbot").
models[].rate.amount_per_secintegerwhen presentCost rate, expressed in unit per denomination. Today, credits per second.
models[].rate.unitstringwhen presentCurrently "credits".
models[].rate.denominationstringwhen presentCurrently "second".
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, free credits, and current spend.

Rate Limits

Concurrent session limits, token TTL, and error handling.