# Billing and limits --- Prepaid credits, usage, budgets and what happens when funds run out. --- # How billing works > Prepaid credits, holds before every paid action, exact per-second charges, and what happens when money runs out. Source: https://nodus-platform-site.pages.dev/docs/concepts/billing/ Build revision: 211ad9f836655b1c3a2668c4693e442471f28614 Nodus is prepaid. You add credits, every paid action reserves funds before it starts, and charges come from the rate frozen when the capacity was acquired. Work never runs on credit you do not have, and it stops gracefully, with its progress saved, when money runs out. ## Your balance Your org has one balance, made of buckets: * **Purchased credit** from top-ups you pay for by card. * **Credit grants**: the starter credit, promo codes and credits from Nodus support. Each grant is its own bucket and may expire. Charges draw from grants first, soonest expiry first, then from grants that never expire, then from purchased credit. That way a grant is used before it expires, and purchased credit, the only kind that can be refunded, lasts longest. `nodus billing` and **Usage & billing → Overview** show: |Field|Meaning| |-|-| |Available|What you can spend now: your buckets minus open holds| |Reserved|Open holds, with the objects that hold them| |Purchased, credits|What is left in each kind of bucket, and the next grant to expire| |Arrears|Unpaid charges; new work waits until a top-up settles them| ## Holds and captures Before a Job, Sandbox, Workspace, Function worker, agent run or build starts, Nodus places a **hold**: enough funds for the first stretch of work plus the cost of stopping it cleanly. While the work runs, Nodus captures what it used every 5 minutes and renews the hold for the next stretch. When the work ends, the final capture charges the exact amount and the rest of the hold is released. The estimate before launch shows the hold, the expected cost range and the minimum charge. A create that cannot be funded fails at once with the amounts, instead of queuing and failing later: ```text Error from server (InsufficientCredits): job "train-a" needs a $3.20 hold to start (released when it ends); available $1.10. fix: nodus billing top-up 20, or lower spec.maxCostUSD ``` ## What is charged Machines Nodus acquires for you are charged per second from the moment the provider starts billing until the machine is confirmed deleted, at the rate frozen when it was acquired. Usage itemizes each machine’s time by segment (`Boot`, `Restore`, `Running`, `Teardown`). [What you pay for](https://nodus-platform-site.pages.dev/docs/guides/billing/what-you-pay-for/) lists every kind of time and who pays for it, and [Pricing](https://nodus-platform-site.pages.dev/docs/concepts/pricing/) explains how rates are set. ## Limits Three limits apply to every hold, and the tightest wins: * **Your balance.** A hold never exceeds what is available. * **Budgets.** A `Block` Budget over the org, a project or a label selector stops new holds and renewals in its scope when it is exhausted. * **Object caps.** `spec.maxCostUSD` on an object bounds that object and everything it owns. When a limit is reached, running work stops gracefully: Jobs suspend after a checkpoint, Sandboxes and Workspaces stop, and agent runs wait. Each stopped object shows `Funded=False` with the reason, and resumes when funds return. If a charge would still go past the limit, Nodus absorbs the difference. ## Low balance You get a low-balance warning by email, webhook and a console banner when your available balance falls below $5.00 (configurable) or below what your open holds need for their next renewal. Turn on [auto-recharge](https://nodus-platform-site.pages.dev/docs/guides/billing/#auto-recharge) to top up automatically below a threshold. ## Arrears A charge that arrives after its hold is gone, such as daily storage, can leave unpaid charges. While arrears are open, new holds and uploads are refused with `402 ArrearsOutstanding`; your next top-up or grant settles them first. --- # Quotas > See the limits on your org, what counts against them, and how to raise them. Source: https://nodus-platform-site.pages.dev/docs/guides/access/quotas/ Build revision: 211ad9f836655b1c3a2668c4693e442471f28614 Quotas keep one mistake from running away with your credits. See yours with: Terminal window ```bash nodus get quota default -o yaml ``` |Quota|Default before your first purchase|After a purchase| |-|-|-| |`members` (seats, including pending invites)|10|10| |`apiKeys` (live keys, including CLI logins and ServiceAccount tokens)|50|200| |`liveSandboxes` (stopped ones count until their delete completes)|10|100| |`storageGiB`|50|1024| |`egressGiBPerDay`|20|100| |`nodusNodes`|1|10| |`gangNodes` (multi-node jobs)|0|8| |`inferenceRPM` / `inferenceTPM`|60 / 100,000|600 / 1,000,000| |`assistantUSDPerDay`|$1|$10| Going over a count quota refuses the create with `429 QuotaExceeded`, naming the quota. Nothing already running is touched. Daily quotas (`egressGiBPerDay`, `assistantUSDPerDay`) reset at 00:00 UTC. Expired and revoked API keys do not count against `apiKeys`. Multi-node jobs are in Beta: your org needs the distributed training beta, and `gangNodes` counts the nodes of running multi-node jobs. A job that would go over it waits in the queue instead of failing. Owners and Admins of an org that has bought credits set their own seats, up to 1,000, under **Team › Members › Change**, or with `PATCH /apis/nodus.dev/v1/quotas/default` and `{"hard": {"members": 25}}`. Seats never go below the members and pending invites you have. To raise any other org limit, or seats past 1,000, contact support. To cap what one project or one person spends, use a [Budget](https://nodus-platform-site.pages.dev/docs/guides/billing/#cap-spending-with-a-budget). --- # Usage and billing > Add credits, redeem a code, cap spending with Budgets, and see exactly what every run cost. Source: https://nodus-platform-site.pages.dev/docs/guides/billing/ Build revision: 211ad9f836655b1c3a2668c4693e442471f28614 Nodus is prepaid: you add credits, and every run reserves funds before it starts. New orgs get [starter credit](https://nodus-platform-site.pages.dev/docs/guides/billing/credits/) to try things out. This guide covers the everyday tasks; the [billing concept page](https://nodus-platform-site.pages.dev/docs/concepts/billing/) explains holds, captures and limits. ## Check your balance Terminal window ```console $ nodus billing Available $17.42 purchased $15.80 · credits $3.52 (starter, expires Oct 31) Reserved $1.90 job/train-a, sandbox/sb-3, function/embed This month $232.58 budget research-monthly 42 % of $500.00 Auto-recharge on add $50.00 below $10.00 · visa •••• 4242 ``` In the console, open **Usage & billing**. The header shows your available balance everywhere, in amber when it is low. ## Add credits Terminal window ```console $ nodus billing top-up 20 Opening https://checkout.stripe.com/c/pay/cs_live_... (expires in 60 min) Waiting for payment... added $20.00. Available $37.42. Receipt: https://invoice.stripe.com/i/... ``` Top-ups are between $5.00 and $1,000.00 in whole cents, up to $5,000 per org per day. Payment happens on a Stripe-hosted page; Nodus never sees your card number. In the console, **Add credits** offers $10, $20, $50, $100 or a custom amount and brings you back to Billing when the payment completes. A top-up settles any unpaid charges first. Every top-up has a receipt and an invoice PDF under **Receipts & invoices** and in `nodus billing receipts`. Topping up needs the `billing:write` permission, which org Owners and Admins have. ## Auto-recharge Auto-recharge adds credit when your available balance drops below a threshold, so long runs never stop for money: Terminal window ```console $ nodus billing auto-recharge --threshold 10 --amount 50 ``` The first time, this opens a card setup page. Each recharge is a Stripe invoice with its own receipt. At most 5 recharges or $5,000 run per day, and three failed charges in a row turn auto-recharge off and email you. Turn it off with `nodus billing auto-recharge --off`. **Save** updates the amounts and warning level without turning auto-recharge on or off. Use **Turn on** or **Turn off** to change that setting. If another admin or failed payments change it while you edit, the console refreshes the settings and asks you to review them before saving again. ## Redeem a promo code Terminal window ```console $ nodus billing redeem LAUNCH25 Redeemed ****CH25: $25.00 of credit, expires 2026-11-30. ``` See [Promo codes](https://nodus-platform-site.pages.dev/docs/guides/billing/promo-codes/) for limits and errors. ## See what you spent Terminal window ```console $ nodus get usage --group-by project,label:owner --since 30d PROJECT OWNER AMOUNT research ml $212.41 default - $20.17 $ nodus get usage --group-by project,meter --since 30d -o csv > usage.csv $ nodus get transactions --since 7d ``` Group usage by `project`, `kind`, `label:`, `meter`, `day`, `segment` or `rank`. `segment` splits machine time into `Boot`, `Restore`, `Running` and `Teardown`, and `rank` itemizes the members of a multi-node run. The console **Usage** tab shows the same data as a daily chart and a table, and every table exports CSV. Transactions list every change to your balance, with the balance after it: top-ups, grants, captures, storage, egress, refunds and adjustments. [What you pay for](https://nodus-platform-site.pages.dev/docs/guides/billing/what-you-pay-for/) lists every kind of time and who pays for it. ## Cap spending with a Budget A Budget is an enforced limit over the org, a project or a label selector, per month or in total. When a `Block` Budget is exhausted, work in its scope stops gracefully and new work is refused until the next period: budget.yaml ```yaml apiVersion: nodus.dev/v1 kind: Budget metadata: name: examples-billing-monthly spec: limitUSD: "25.00" period: Monthly scope: project: examples action: Block thresholds: [50, 80, 100] ``` Terminal window ```console $ nodus apply -f budget.yaml $ nodus get budgets ``` You get an email at each threshold. The console **Budgets** tab creates and edits Budgets and previews which objects a scope matches now. To cap one person, scope a Budget to them by email. It counts everything they start, with any of their API keys, including inference requests: Terminal window ```console $ nodus create budget ada-monthly --limit 300 --period Monthly --scope-member ada@example.com ``` ## When work is refused for money A create that cannot be funded fails with `402` and the exact amounts, and the console shows an **Add credits** action: |Error|What to do| |-|-| |`InsufficientCredits`|Add credits, or lower `spec.maxCostUSD`| |`BudgetExceeded`|Raise the Budget’s `spec.limitUSD`, or wait for its next period| |`ArrearsOutstanding`|Add credits; the top-up settles the unpaid charges first| |`PaymentDisputed`|Contact support; new work waits until the dispute closes| ## Payment methods and billing details `nodus billing portal` opens the Stripe Customer Portal, where you update cards, your billing email, address and tax ID, and download past invoices. ## Learn more * [Credits](https://nodus-platform-site.pages.dev/docs/guides/billing/credits/): the starter credit, grants and expiry * [Promo codes](https://nodus-platform-site.pages.dev/docs/guides/billing/promo-codes/) * [Refunds](https://nodus-platform-site.pages.dev/docs/guides/billing/refunds/) * [What you pay for](https://nodus-platform-site.pages.dev/docs/guides/billing/what-you-pay-for/) --- # Add a card before running work > Save a payment method without buying credits. Source: https://nodus-platform-site.pages.dev/docs/guides/billing/add-a-card/ Build revision: 211ad9f836655b1c3a2668c4693e442471f28614 Open **Billing → Payment method → Add a card**, or run: Terminal window ```sh nodus billing portal --setup ``` Stripe saves your card without charging it or enabling auto-recharge. Your $30 signup credit keeps its original 30-day expiration. New work needs a verified card even when promotional credit covers its entire cost. An organization billing administrator must add the card. Other members can view its status. After returning from Stripe, wait for Billing to show that the card is ready. Returning to the page alone does not complete verification. If you canceled setup, choose **Add a card** again. CLI and SDK requests receive `PaymentMethodRequired` until verification completes. `PaymentVerificationUnavailable` means to retry shortly. Removing or letting the card expire blocks new work. Existing running work continues within its available credits and budgets. A restart or new allocation checks the payment method again. Adding a card does not let work exceed your prepaid balance. --- # Auto-recharge > Top up automatically from a saved card when your balance falls below a threshold, so running work never stops for money. Source: https://nodus-platform-site.pages.dev/docs/guides/billing/auto-recharge/ Build revision: 211ad9f836655b1c3a2668c4693e442471f28614 Auto-recharge buys credits for you when your available balance falls below a threshold you choose. Each recharge is charged to a saved card and emailed to you as a receipt, exactly like a top-up you buy yourself. It is off until you turn it on. ## Turn it on Terminal window ```bash nodus billing auto-recharge --threshold 10 --amount 50 ``` This recharges $50 whenever your available balance drops below $10. If no card is on file yet, the command first opens a Stripe page to save one, then turns auto-recharge on. You can also save a card while buying credits with `nodus billing top-up 20 --save-card`, and the console billing page has an auto-recharge card that does both. The same settings live on your org’s `BillingAccount`: ```yaml apiVersion: nodus.dev/v1 kind: BillingAccount metadata: name: default spec: autoRecharge: enabled: true thresholdUSD: "10.00" # at least 5.00 amountUSD: "50.00" # 5.00 to 1000.00 ``` |Setting|Default|Allowed| |-|-|-| |`thresholdUSD`|`"10.00"`|$5.00 or more| |`amountUSD`|`"20.00"`|$5.00 to $1,000.00| Turning it on without a saved card is refused; check `PaymentMethodPresent` in `nodus billing`, or save a card through the billing portal (`nodus billing portal`). ## When it recharges Nodus checks your balance each time it renews the hold of running work, settles inference or storage, or refuses a new hold. It recharges when all of these are true: * your available balance is below `thresholdUSD`; * a card is on file; * no other auto-recharge is still being paid; * the org has had fewer than 5 auto-recharges, and less than $5,000 of them, today (UTC); * the last 3 auto-recharges did not all fail. A recharge usually lands in seconds. Work whose funding is running short keeps running while it is paid, so a successful recharge within that window means nothing stops. ## See what it did Each recharge is a `TopUp` with `spec.origin: AutoRecharge`: Terminal window ```bash nodus get topups -o wide nodus billing receipts ``` `nodus billing` shows the auto-recharge state from `status.autoRecharge`: `consecutiveFailures`, `lastAttemptTime`, `lastResult` and, when it has been switched off, `disabledReason`. ## When a recharge fails If the card is declined, the recharge `TopUp` ends `Failed` (`PaymentFailed`), nothing is credited, and the billing email and the org’s owners and admins get an email. Auto-recharge tries again the next time the balance is checked. After 3 failures in a row, Nodus turns auto-recharge off, sets `status.autoRecharge.disabledReason` to `ConsecutiveFailures`, shows a banner in the console and emails the same people. To turn it back on: 1. Update the card in the billing portal: `nodus billing portal`. 2. Run `nodus billing auto-recharge --threshold 10 --amount 50` again, or set `enabled: true`. If your balance runs out while auto-recharge is off, work stops gracefully as described in [When money runs out](https://nodus-platform-site.pages.dev/docs/guides/billing/when-money-runs-out/). ## Turn it off Terminal window ```bash nodus billing auto-recharge --off ``` The saved card stays on file for later; remove it in the billing portal. --- # Budgets and spending caps > Put an enforced limit on what an org, a project or a labelled group of work can spend, and cap any single run. Source: https://nodus-platform-site.pages.dev/docs/guides/billing/budgets/ Build revision: 211ad9f836655b1c3a2668c4693e442471f28614 Nodus enforces two kinds of spending limits. Both are checked before any paid work starts and again every few minutes while it runs, so a limit always stops spend instead of reporting it afterwards. * A **Budget** limits what matching work across your org can spend in a month or in total. * **`maxCostUSD`** caps one object: a Job, Pipeline, Sweep, TrainingJob, Sandbox, Workspace, Function, Agent or InferenceEndpoint. A cap on a Pipeline or Sweep is shared by every run it creates. ## Create a Budget ```yaml apiVersion: nodus.dev/v1 kind: Budget metadata: name: research-monthly spec: limitUSD: "500.00" period: Monthly # a UTC calendar month; Total counts from creation scope: project: research # leave out for the whole org selector: matchLabels: {team: nlp} action: Block # Notify only sends notices thresholds: [50, 80, 100] notify: emails: [research-leads@example.com] ``` Terminal window ```bash nodus apply -f budget.yaml nodus get budget research-monthly ``` `nodus get budget` shows what is spent, what is held for running work, what remains and the thresholds already notified this period. An org can have up to 50 Budgets. ## What a Budget covers A Budget counts every hold and charge of work in its project whose labels matched the selector **when the work was created**. Changing a running Job’s labels does not move it out of a Budget. A Budget you create while work is already running starts covering that work within 5 minutes. ## What happens at the limit With `action: Block`: * New work in scope is refused with `402 BudgetExceeded`, naming the Budget, what is left and what the work needs: ```text budget "research-monthly" has $0.40 left of $500.00 this month; job "train-a" needs $3.20. fix: raise spec.limitUSD on budget/research-monthly, or wait until 2026-11-01 ``` * Running work in scope stops gracefully, as described in [When money runs out](https://nodus-platform-site.pages.dev/docs/guides/billing/when-money-runs-out/), with `Funded=False` and reason `BudgetExceeded`. * Raising `spec.limitUSD`, switching to `Notify`, deleting the Budget or the start of the next month resumes it. With `action: Notify`, nothing is refused; you only get the notices. ## Notices Each threshold is sent once per period as a `BudgetThreshold` Event, a `budget.threshold` webhook and an email to the billing email, org owners and admins, and the addresses in `spec.notify.emails`. Reaching a `Block` limit also sends `BudgetExceeded` (webhook `budget.exceeded`). ## Cap a single run ```yaml kind: Job spec: maxCostUSD: "25.00" ``` A Job never holds more than its cap. When its spend reaches the cap, it checkpoints and becomes `Suspended` with reason `MaxCostReached`; raising `maxCostUSD` resumes it from the checkpoint. You can raise a cap at any time, but not lower it. A Pipeline, Sweep or TrainingJob shares its cap with the Jobs it creates. Each child must fit both its own cap and its parent’s remaining cap, along with every matching Budget. A dry-run reports an insufficient spending limit in `status.estimate.blockingReasons` without reserving funds. --- # Buy credits > Add prepaid credits with a card through Stripe Checkout from the console, the CLI or the API, and add the $20 Indra plan. Source: https://nodus-platform-site.pages.dev/docs/guides/billing/buy-credits/ Build revision: 211ad9f836655b1c3a2668c4693e442471f28614 Nodus is prepaid. You buy credits, and paid work draws on them through a funded hold placed before it starts. You pay on a Stripe-hosted page, so Nodus never sees your card number. Every purchase is a `TopUp` object that you can list and follow until the credit is on your balance. ## Buy from the console Open **Usage & billing**, choose **Add credits**, and pick $10, $20, $50, $100 or a custom amount. The console sends you to Stripe Checkout and brings you back to the billing page, which shows the top-up until it is paid. ## Buy from the CLI Terminal window ```bash nodus billing top-up 20 ``` The CLI opens the payment page in your browser, waits until the payment is credited and prints your new balance. |Flag|Does| |-|-| |`--save-card`|Saves the card for [auto-recharge](https://nodus-platform-site.pages.dev/docs/guides/billing/auto-recharge/)| |`--no-open`|Prints the payment link instead of opening a browser, for a remote shell| |`--no-wait`|Returns as soon as the payment link exists| ## Buy through the API A top-up is an ordinary resource. Create it, then open its `status.checkoutURL`, which appears within about a second: ```yaml apiVersion: nodus.dev/v1 kind: TopUp metadata: name: october-credits spec: amountUSD: "50.00" savePaymentMethod: false # true also saves the card for auto-recharge ``` Terminal window ```bash nodus apply -f topup.yaml nodus get topup october-credits -o yaml ``` The REST path is `/apis/nodus.dev/v1/topups`. By default Checkout returns to the console billing page; set `spec.successURL` and `spec.cancelURL` to return somewhere else on the console, or to an `http://127.0.0.1` address for a local tool. A top-up cannot be edited or deleted; an unpaid one expires by itself. ## Limits |Limit|Value| |-|-| |Amount of one top-up|$5.00 to $1,000.00, in whole cents| |Top-ups per org per day|$5,000 in total, per UTC day| |Payment page|Payable for 1 hour after it is created| An amount outside the range is refused with `422 Invalid` before anything is charged. ## Follow a top-up Terminal window ```bash nodus get topups -o wide ``` |Phase|Reason|Meaning| |-|-|-| |`Queued`||Nodus is creating the payment page| |`Running`||The payment page is open and waiting for you| |`Running`|`PaymentPending`|You paid with a method that confirms later, such as a bank debit| |`Succeeded`||Paid and credited; `status.creditedUSD` is on your balance and `status.receiptURL` links the receipt| |`Failed`|`Expired`|Nobody paid within the hour; nothing was charged| |`Failed`|`PaymentFailed`|The payment did not complete; nothing was credited| A declined card does not fail the top-up: the payment page stays open so you can try another card. When a payment fails after you submit it, such as a bank debit that does not clear, Nodus emails your billing email. ## When the credit arrives Nodus credits each payment once, as soon as Stripe confirms it, which usually takes a few seconds. If a confirmation from Stripe is delayed or lost, Nodus asks Stripe about the payment itself within the hour and again in a nightly check, so a paid top-up is always credited, and never twice. If your org owes arrears, the top-up pays them first and the rest goes to your balance. Work that stopped because money ran out resumes by itself; see [When money runs out](https://nodus-platform-site.pages.dev/docs/guides/billing/when-money-runs-out/). Stripe emails a receipt for every paid top-up to your billing email. See [Receipts and invoices](https://nodus-platform-site.pages.dev/docs/guides/billing/receipts/). ## The Indra plan The Indra plan costs $20 a month. Each paid month adds a $20 credit that only Indra (`nodus/indra`) requests can spend, at list price. Indra requests use that credit before your other credits, and everything else draws on your regular balance. Unused plan credit expires when the month it belongs to ends; it does not carry over. Start the plan by opening an Indra plan checkout session (type `ComposerSubscription`) and paying on the page it returns: Terminal window ```bash curl -X POST "https://api.nodus-compute.ai/apis/nodus.dev/v1/billingaccounts/default/sessions" \ -H "Authorization: Bearer $NODUS_TOKEN" -H "Idempotency-Key: $(uuidgen)" \ -d '{"type": "ComposerSubscription"}' ``` The response is `{url, expirationTime}`. An org can have one Indra plan; a second request while the plan is active is refused with `409 Conflict`. * **Renewal.** Stripe charges the card each month and emails the invoice. A new month’s credit is added only once its invoice is paid; while a renewal payment is failing, Stripe retries it and Indra requests draw on your regular credits. * **Cancel.** Open the billing portal with `nodus billing portal` and cancel the plan there. It ends at the end of the paid month: that month’s credit stays usable until then, and nothing further is charged or added. --- # Credits > The starter credit, credit grants, the order credits are spent in, and when they expire. Source: https://nodus-platform-site.pages.dev/docs/guides/billing/credits/ Build revision: 211ad9f836655b1c3a2668c4693e442471f28614 Credit grants are credit Nodus gives you, as opposed to credit you buy. Each grant is a `CreditGrant` you can read but not change: Terminal window ```console $ nodus get creditgrants NAME SOURCE AMOUNT REMAINING EXPIRES grt_01j9x... Starter $30.00 $12.40 2026-10-31 grt_01j9y... Promo $25.00 $25.00 2026-11-30 ``` The console lists them under **Usage & billing → Credits**, with what each has spent and when it expires. ## Starter credit The first org you create gets **$30.00** of starter credit once your email address is verified. It expires 30 days after the org is created. Each person gets starter credit once, however many orgs they create. Orgs that only have starter credit keep tighter limits until their first top-up: 20 GiB of egress a day, $1 a day of console assistant use and no multi-node runs. ## Where grants come from |Source|How you get it| |-|-| |`Starter`|Your first org, once your email is verified| |`Promo`|[Redeeming a promo code](https://nodus-platform-site.pages.dev/docs/guides/billing/promo-codes/)| |`Admin`|Credit added by Nodus support, for example a pilot or a migrated balance| |`Goodwill`|Credit from Nodus support for a problem on our side| Some plan grants pay only for Indra (`nodus/indra`) model calls; they show `nodus/auto`, Indra’s other name, as their scope and are never spent on anything else. ## Spending order Charges draw from grants first, soonest expiry first, then from grants that never expire, and only then from purchased credit. You never have to pick which credit pays. ## Expiry You get an email 7 days and 1 day before a grant expires. At its expiry the unspent remainder leaves your balance at once, even if a run is still using it; the run keeps going on its other credit. Grants are never refunded or turned into cash. A grant also settles unpaid charges first, the same way a top-up does. --- # Partner offers > Apply an eligible partner offer and understand promotional matching. Source: https://nodus-platform-site.pages.dev/docs/guides/billing/partner-offers/ Build revision: 211ad9f836655b1c3a2668c4693e442471f28614 Open **Billing → Partner offers**, enter your code and optionally add your company or batch. An organization admin submits the request; a platform administrator verifies eligibility before credit is granted. Organization members can view progress. For the YC offer, promotional credit reaches **$100 total**, including earlier grants even if spent or expired. A previous $30 starter grant therefore leaves **$70 extra**. You keep the existing **10 GB storage inclusion**. After approval, earn **10% back on the first $10,000 of eligible usage**, for a maximum **$1,000 bonus**. Only captured usage paid from purchased credit qualifies. Usage paid by starter credit, promotional grants or earned bonuses does not. Earned credit does not expire. Usage corrections adjust the matching benefit, including after an offer is revoked. You can also use the CLI: Terminal window ```sh nodus billing deal nodus billing deal YC --note 'Company and batch' ``` A request snapshots the terms you applied for. Later offer edits do not change them. Approval keeps the usual card prerequisite and usage prices. If an offer is revoked, future matching stops and existing earned credit remains, subject to corrections. --- # Promo codes > Redeem a promo code for credit, and what each redemption error means. Source: https://nodus-platform-site.pages.dev/docs/guides/billing/promo-codes/ Build revision: 211ad9f836655b1c3a2668c4693e442471f28614 A promo code adds a [credit grant](https://nodus-platform-site.pages.dev/docs/guides/billing/credits/) to your org. Redeem it from the CLI or from **Usage & billing → Credits → Redeem code** in the console: Terminal window ```console $ nodus billing redeem LAUNCH25 Redeemed ****CH25: $25.00 of credit, expires 2026-11-30. ``` Codes are not case-sensitive, and spaces around them are ignored. Redeeming needs the `billing:write` permission. The response shows the code masked to its last four characters; Nodus stores only a keyed digest of each code. ## Errors |Error|Meaning| |-|-| |`404 NotFound`|The code does not exist, or it has been withdrawn| |`410 Expired`|The code’s last redemption date has passed| |`409 Conflict`|Your org has already redeemed this code, or the code has been fully redeemed| |`429 TooManyRequests`|More than 5 attempts in a minute; wait a minute and try again| Retrying a redemption with the same `Idempotency-Key` returns the first result and never adds credit twice. The CLI and console set the key for you. ## Expiry A promo grant expires on the date the code sets, counted from when you redeem it. Codes without one never expire. --- # Receipts and invoices > Find the receipt and invoice for every top-up and plan payment, change where receipts are sent, and manage your card and billing details. Source: https://nodus-platform-site.pages.dev/docs/guides/billing/receipts/ Build revision: 211ad9f836655b1c3a2668c4693e442471f28614 Every payment you make to Nodus, whether a top-up you buy, an auto-recharge or an Indra plan month, has a Stripe-hosted invoice with a PDF, and Stripe emails a receipt for it. Nodus does not send postpaid bills: credits are prepaid, and what they paid for is in your [usage records](https://nodus-platform-site.pages.dev/docs/guides/billing/usage-and-costs/). ## Where receipts go Receipts go to the billing email of your org’s `BillingAccount`, which defaults to the email of the owner who created the org. To send them somewhere else, such as a finance mailbox, change `spec.billingEmail`: ```yaml apiVersion: nodus.dev/v1 kind: BillingAccount metadata: name: default spec: billingEmail: finance@example.com ``` Terminal window ```bash nodus apply -f billing.yaml ``` The new address applies to the next payment and is also where Nodus sends money notices, such as a failed auto-recharge, together with the org’s owners and admins. ## Find a receipt Terminal window ```bash nodus billing receipts ``` This lists your top-ups, Checkout and auto-recharge alike, with a link to each invoice page and its PDF. The same links are on each `TopUp`: Terminal window ```bash nodus get topup october-credits -o yaml ``` |Field|Links to| |-|-| |`status.receiptURL`|The Stripe-hosted invoice page, which shows the payment and the card used| |`status.invoicePDFURL`|The invoice as a PDF| The links appear a few seconds after the payment succeeds, once Stripe has finalized the invoice. ## The billing portal Terminal window ```bash nodus billing portal ``` This opens the Stripe billing portal for your org, where you can: * see and download every invoice and receipt, including Indra plan invoices; * add, replace or remove the card used for auto-recharge and the Indra plan; * change the name, address and other details printed on your invoices; * cancel the Indra plan. The portal link is valid for 5 minutes; run the command again for a new one. From the API, create a session with `POST /apis/nodus.dev/v1/billingaccounts/default/sessions` and `{"type": "Portal"}`. Nodus does not charge sales tax or VAT on top-ups. ## Refunds Refunds cover unspent purchased credit and are made by Nodus support. A refunded top-up shows the amount in `status.refundedUSD`, the credit leaves your balance when the refund is approved, and the refund appears on the top-up’s invoice page. Credit from grants and promo codes is not refundable. ## Questions about a charge Contact Nodus support before disputing a charge with your bank. While a dispute is open, new work that needs credit is refused with `402 PaymentDisputed`; running work is not stopped. When the dispute closes in your favor the credit returns to your balance. --- # Refunds > How to get unspent purchased credit back to your card, and what can be refunded. Source: https://nodus-platform-site.pages.dev/docs/guides/billing/refunds/ Build revision: 211ad9f836655b1c3a2668c4693e442471f28614 You can get **unspent purchased credit** back to the card that paid for it. Credit grants, including starter credit and promo codes, are never refunded. ## Ask for a refund Contact support with your org and the top-up you want refunded. Support checks the request and starts the refund; refunds above $500 are approved by a second person at Nodus. You do not need to stop your work first. The amount leaves your available balance as soon as the refund is approved, so it cannot be spent while the card refund is processing. The top-up shows the refund under **Usage & billing → Receipts & invoices**, and `nodus get transactions` shows a `RefundRequest` and then a `Refund`. Your card is usually credited within 5 to 10 business days. If the card refund fails, a `RefundFailed` transaction returns the amount to your balance. ## What can be refunded * At most what you paid on that top-up, less anything already refunded on it. * At most your unspent purchased credit at approval: credit already used for runs is not refunded. * One refund per top-up at a time, in whole cents. ## Disputes If you dispute a payment with your bank instead, the disputed amount is removed from your balance and new work is paused with `402 PaymentDisputed` until the dispute closes. Running work continues. Contacting support first is usually faster. --- # Usage and costs > See what each run cost, split by project, label, meter and segment, and export usage as CSV. Source: https://nodus-platform-site.pages.dev/docs/guides/billing/usage-and-costs/ Build revision: 211ad9f836655b1c3a2668c4693e442471f28614 Every charge Nodus makes is backed by usage records: one line per meter, per object, per window. This page shows how to read them, group them and export them. ## See what a run cost Each compute object shows its cost so far in `status.cost`: Terminal window ```bash nodus get job train-llama -o jsonpath='{.status.cost}' ``` ```json {"totalUSD": "4.182500", "heldUSD": "0.750000", "bySegment": {"bootUSD": "0.121000", "runningUSD": "3.980000", "teardownUSD": "0.081500"}} ``` `heldUSD` is reserved but not yet charged. The total becomes final once the capacity behind the run is confirmed deleted, which can be a minute or two after the run itself ends. When a run fails because of Nodus, the teardown after the failure and any of its start not yet billed are not charged: `bySegment.coveredByNodus` names those segments, and `nodus describe` shows them on the cost line, for example `$0.00 (covered by Nodus: boot, teardown)`. ## What each segment covers Compute usage from the moment the capacity starts billing until it is confirmed deleted is split into segments: |Segment|Covers| |-|-| |`Boot`|From the start of billing to the moment your command starts: boot, registration, readiness checks and pulling your image| |`Running`|Your command running, including reading inputs, lazy image fetches, checkpoint writes and the snapshot when the run stops| |`Restore`|For a run that resumes from a checkpoint or snapshot: from the start of billing to the moment your command starts again, including the restore. It replaces `Boot`| |`Teardown`|From the stop to confirmed deletion, plus the capacity’s billing increment (lines with `detail: IncrementRounding`)| Time between runs that reuse the same capacity is billed on the `warm_idle_seconds` meter and has no segment. When Nodus itself delays a deletion, that time is not charged: it shows as a zero-amount line with `detail: NodusBorne`. ## List and group usage Terminal window ```bash nodus get usage --since 2d nodus get usage --group-by project,meter nodus get usage --group-by member --since 30d nodus get usage --group-by label:team,day nodus get usage --group-by rank,segment --field-selector object.uid= ``` `--group-by` accepts `project`, `kind`, `member`, `meter`, `day`, `segment`, `rank` and `label:`. `member` is the person who started the work, whichever of their API keys they used. Labels are the ones the object carried when it was admitted, so label your work before you submit it: ```yaml metadata: name: train-llama labels: team: research ``` Grouped totals always add up to the ungrouped total: every line lands in exactly one group, and lines without the grouped value share an empty group. ## Export as CSV Terminal window ```bash nodus get usage --since 30d -o csv > usage.csv curl -H "Authorization: Bearer $NODUS_TOKEN" -H "Accept: text/csv" \ "https://api.nodus-compute.ai/v1/usagerecords?since=30d" ``` Amounts are in US dollars with six decimals. `quantity` is in the meter’s unit (seconds, tokens, GiB or characters), and `rate_micros` is the rate in micro-dollars per `rate_basis` units. ## Inference and Indra Inference requests are rolled up into one line per model, meter and hour. A request to `nodus/indra` (Indra) shows the model that served it and, beside it, the routing call’s input and output tokens on lines whose SKU ends in `:routing:input` and `:routing:output`. The request is charged once, rounded up to the micro-dollar over all of its lines together. ## Agents An Agent’s idle workers bill as warm idle on the Agent. When a run claims a worker, the worker’s time from that moment bills on the AgentRun until the run releases it, so each second of worker time appears once. Model calls a run makes with Nodus’s Claude are billed per request on the AgentRun, with the routing call beside the model that answered; calls made with your own Anthropic key carry no Nodus model charge. ## Storage and egress Retained storage (checkpoints, Volumes, images you build, and Job and Agent outputs) is sampled every hour per object. The first 10 GB across your organization are included and shared across your objects in proportion to their size; each object’s line shows only its billable part. The hours of a UTC day are charged together shortly after midnight UTC, as one `Storage` transaction. Egress from your containers and interactive sessions is counted per object per UTC day. The first 10 GiB a day across your organization are included, and the rest is charged the next morning as one `Egress` transaction, split across objects by bytes. If your balance cannot cover a daily storage or egress charge, the remainder becomes arrears. While arrears are outstanding, new runs and uploads are refused with `ArrearsOutstanding`; your next top-up pays them first. Storage left in arrears gets an email at 7, 21 and 28 days. At 30 days Nodus proposes deleting the stored data beyond the included 10 GB: finished Jobs’ checkpoints and outputs first, then older Volume revisions, then the latest revisions, oldest first. Nothing is deleted until two Nodus administrators approve the list, and paying your arrears before then cancels it. Deleting data does not clear the arrears. ## Meters reference `quantity` is in the meter’s unit. `rate` applies to `rateBasis` units of quantity, so a line’s amount is `quantity × rate ÷ rateBasis`, rounded down, except that the last line of a run rounds up to the capacity’s billing increment. |Meter|Billed for|Unit|Rate is per|`rateBasis`|SKU| |-|-|-|-|-|-| |`compute_seconds`|Dedicated capacity for Jobs, GPU Sandboxes, GPU Workspaces, Functions and training members, with a segment|seconds|hour|3 600|`rented:`| |`warm_idle_seconds`|Warm capacity kept between runs, idle Function and agent workers|seconds|hour|3 600|`rented:`| |`node_vcpu_seconds`|vCPU on shared nodes (Sandboxes, agent runs), with a segment|milli-vCPU seconds|vCPU-hour|3 600 000|`node:vcpu`| |`node_gib_seconds`|Memory on shared nodes, with a segment|MiB seconds|GiB-hour|3 686 400|`node:memory`| |`node_disk_gib_seconds`|Requested disk above 10 GiB per vCPU on shared nodes|GiB seconds|GiB-hour|3 600|`node:disk`| |`build_vcpu_seconds`|Image builds, with a segment|milli-vCPU seconds|vCPU-hour|3 600 000|`build:vcpu`| |`storage_gb_hours`|Retained storage above 10 GB per organization|MB hours|GB-month (30 days)|720 000|`storage:retained`| |`egress_gib`|Egress above 10 GiB per organization per UTC day; relayed training traffic from the first byte|MiB|GiB|1 024|`egress:gib`, `egress:mesh-relay`, `egress:supplier`| |`inference_input_tokens`|Input tokens|tokens|million tokens|1 000 000|`model::input`| |`inference_output_tokens`|Output tokens, reasoning included|tokens|million tokens|1 000 000|`model::output`| |`inference_cache_read_tokens`|Cached input read|tokens|million tokens|1 000 000|`model::cache_read`| |`inference_cache_write_tokens`|Cache writes, 5-minute or 1-hour|tokens|million tokens|1 000 000|`model::cache_write_5m`, `model::cache_write_1h`| |`inference_audio_seconds`|Transcription and translation, 10 s minimum per request|milliseconds|audio-hour|3 600 000|`model::audio`| |`inference_speech_characters`|Speech synthesis input|characters|million characters|1 000 000|`model::speech`| |`platform_device_hours`|Your own devices assigned to Nodus-scheduled work|device seconds|device-hour|3 600|`platform:device-hour`| |`platform_predict_seconds`|Predict on one of your pools|seconds|30-day month|2 592 000|`platform:predict`| Indra requests add a routing line beside the model’s lines, with SKU `:routing:input` or `:routing:output`. An `egress:supplier` line passes through an egress charge billed for your dedicated capacity at the same margin as the capacity itself. --- # What you pay for > Every kind of time and cost, who pays for it, and the usage segment it appears under. Source: https://nodus-platform-site.pages.dev/docs/guides/billing/what-you-pay-for/ Build revision: 211ad9f836655b1c3a2668c4693e442471f28614 You pay for every second a provider bills for a machine Nodus acquired for your work, from the moment billing starts until the machine is confirmed deleted. Nodus pays for everything it chose or caused. Your usage shows each machine’s time by segment, so you can see where every second went: * **Boot**: from billing start to your command starting. * **Restore**: a replacement machine’s time until your command starts again after a recovery, including the checkpoint restore. * **Running**: from your command starting to its stop. * **Teardown**: from stop to confirmed deletion, plus the provider’s billing increment, rounded once per machine. Run `nodus get usage --group-by segment` or open **Usage & billing → Usage** in the console to see the split. For a multi-node run, `--group-by rank,segment` itemizes each member. ## The table |What|Segment|Who pays| |-|-|-| |[]()Time from billing start to your command starting: boot, registration, readiness checks, image pull and checkpoint restore|Boot, Restore|You| |[]()A boot that fails on the provider’s side, until the machine is confirmed deleted|Boot|You| |[]()Spare machines Nodus starts to finish your work sooner, machines Nodus releases or replaces on its own decision, machines that fail Nodus’s checks, and failures Nodus causes|None: never on your usage|Nodus| |[]()From your command starting to its stop, including lazy image fetches, checkpoint writes, the snapshot on stop and work lost after a preemption|Running|You| |[]()Downloading inputs after your command starts, and the `initCommand` preflight|Running|You| |[]()Imports, exports and sink loads that run on your org’s capacity|Running|You| |[]()Disk above 10 GiB per vCPU on Nodus nodes|Running|You| |[]()A network partition your work tolerates, until it reconnects or until the old machine is fenced and confirmed deleted|Running, Teardown|You| |[]()The provider’s billing increment, rounded once per machine|Teardown|You| |[]()Warm idle time beyond an increment you already paid for, minimum workers, and idle Function and agent workers|Warm idle|You| |[]()The idle share of Nodus-operated capacity, built into its rates and never metered on its own|Included in rates|You| |[]()From stop to confirmed deletion|Teardown|You| |[]()Time between stop and the delete request beyond 60 seconds when Nodus caused the delay|None: never on your usage|Nodus| |[]()Any cost beyond your tightest limit: `maxCostUSD`, a Budget or your balance|None: never on your usage|Nodus| |[]()A model request whose outcome Nodus cannot confirm, and upstream charges beyond the usage observed on a cut-off stream|None: never on your usage|Nodus| |[]()Console assistant and command generation calls, within the daily cap|None|Nodus| |[]()Grading Sandboxes, evaluations, dataset previews, task manifests and model calls made from inside your containers, under your caps|Running|You| |[]()Mirroring a private image so it can run on hosted containers, and the mirror’s storage|None|Nodus| |[]()Nodus’s own test runs|None|Nodus| |[]()Image builds that fail|Build|You| |[]()Storage above 10 GB per org: Volumes, checkpoints, outputs, images and session state|Storage|You| |[]()Logs|None|Nodus| |[]()Egress within 10 GiB per org per day|None|Nodus| |[]()Egress beyond the included 10 GiB a day, up to your quota, and relayed traffic between multi-node members|Egress|You| |[]()Your own pool hosts and cloud accounts|None|Free| |[]()Pool devices running work Nodus schedules, Predict per pool, and capacity Nodus acquires for you|Platform|You| |[]()Differences between a provider’s invoice and what Nodus metered|None|Nodus| This table is checked against the billing reference model on every change, so the rows here are the rows Nodus charges by. ## Limits stop work before it overruns Every paid action holds funds before it starts, and work stops gracefully when a hold cannot be renewed. If a charge would still go past your tightest limit, Nodus absorbs the difference: your balance never pays more than the limit you set. See [How billing works](https://nodus-platform-site.pages.dev/docs/concepts/billing/) for holds, captures and the low-balance stop. --- # When money runs out > How Nodus warns you, stops work gracefully and resumes it when credits, a raised Budget or a raised cap return. Source: https://nodus-platform-site.pages.dev/docs/guides/billing/when-money-runs-out/ Build revision: 211ad9f836655b1c3a2668c4693e442471f28614 Credits are prepaid. Before paid work starts, Nodus places a funded hold on your balance, and it renews that hold every 5 minutes while the work runs. When a renewal cannot be funded, from your balance, a Budget or a `maxCostUSD` cap, the work stops gracefully inside time that is already paid for. Nothing runs past what you funded, and nothing is lost that the work saved. ## Before you start: fail fast A create that cannot be funded is refused at once with the amounts and the fix: ```text 402 InsufficientCredits job "train-a" needs a $3.20 hold to start (released when it ends); available $1.10. fix: nodus billing top-up 20, or lower spec.maxCostUSD ``` Other refusals are `BudgetExceeded` (a Budget or a cap has too little left), `ArrearsOutstanding` (unpaid charges) and `PaymentDisputed`. A distributed Job checks all of its nodes together: it starts with every node funded or not at all. ## Warnings When your available balance falls below $5, or below 20 % of what the next renewal of your running work needs, you get a `LowBalance` Event, a `billing.low_balance` webhook, at most one email a day and a console banner. Running work whose funds will run out soon still shows `Funded=True`, and the condition’s message gives the time it will stop. A top-up, a credit grant or an auto-recharge before that time keeps it running. When a charge is larger than what is left, the rest becomes unpaid charges. You get an `ArrearsPosted` Event, a `billing.arrears_posted` webhook and at most one email a day, and new work waits until a top-up or credit grant pays them. ## How each kind stops |Kind|What happens|State|Resumes| |-|-|-|-| |Job (checkpointed)|Takes an urgent checkpoint, then stops|`Suspended`, `Funded=False`|Automatically once funded, from the checkpoint| |Job (restartable or ephemeral)|Stops at the funded edge|`Suspended`, `Funded=False`|Automatically; ephemeral Jobs restart from the start| |Job at `maxCostUSD`|Checkpoints, then stops|`Suspended`, reason `MaxCostReached`|When you raise `maxCostUSD`| |Distributed Job|Every node checkpoints together, then all stop|`Suspended`, `Funded=False`|Automatically, with all nodes funded| |Sandbox|Snapshots its filesystem and state, then stops|`Stopped`, `stopReason: InsufficientCredits`; `spec.state` stays `Running`|On the next exec or connect once funded| |Workspace|Saves the home volume, then stops|`Stopped` with the money reason|On `nodus start`, SSH connect or the schedule once funded| |AgentRun|Finishes or interrupts the current step|`Waiting` for funds|Automatically| |Agent idle workers|Scale to zero|`Funded=False` on the Agent|Automatically| |Function|Stops taking calls, finishes in-flight calls, scales to zero|New calls queue with `Funded=False`|Automatically| |TrainingJob|Its Jobs suspend; grading Sandboxes are deleted|`Suspended`|Automatically| |Image build|The build stops|Image `Pending`, `Funded=False`|Automatically rebuilds| |Volume import or export|The transfer stops|`ImportFailed(InsufficientCredits)`|`nodus request reimport volume/`| |Inference|New requests return an OpenAI- or Anthropic-shaped `402`; in-flight requests finish|—|Immediately| Nodus never changes the `spec.state` you set. It records the stop in the object’s phase and `Funded` condition, emits `FundingLost`, and emits `FundingRestored` when it resumes. You get at most one email an hour listing stopped work. ## Getting going again Terminal window ```bash nodus billing top-up 20 nodus get jobs --watch ``` A top-up resumes waiting work oldest first, as each hold fits. Work stopped by a Budget resumes when you raise the Budget’s limit, switch it to `Notify`, delete it or the next month starts; work stopped at `maxCostUSD` resumes when you raise the cap.