Skip to content

Usage and billing: what your pipelines measured, what it cost, and your wallet

Two pages answer “what did this cost, and why”: Usage shows what your pipelines measured and what was charged for it, day by day and pipeline by pipeline; Billing shows your balance, how long it lasts, and your statement for each month. A pipeline’s own page has a Usage tab with its days this month.

Every charge on these pages is read from your ledger, never recomputed for display. The one figure that is computed is today’s, which is labelled an estimate: it is worked out by the same arithmetic that charges the day once it closes, and it is charged only then.

Every day is a UTC day (00:00 to 24:00 UTC), on both pages and in every export, because that is the day your usage is charged for. Money is shown in US dollars, and stored in cents.

Every person in your account (owners and members), and every API key (read or full), through GET /v1/usage/days, /v1/usage/hours, /v1/usage/months, GET /v1/wallet, /v1/wallet/entries and /v1/wallet/statements/{month}. Only an owner sees the saved card’s details on Billing (its hint, its region and when it was added); everyone else is told whether one is saved. The same rule holds on every row: a top-up’s row in the ledger and on the statement names the card it was paid with (its hint, never its number) for an owner, and carries no hint for a member or an API key.

Shown as What it is Charged
vCPU-hours the compute your pipeline’s work used yes, at the rate card in force that day
GB-hours the memory it held, in SI gigabytes (10^9 bytes) yes, at the rate card in force that day
rows rows delivered to your destination no: measured so you can see it
GB bytes moved, in SI gigabytes no: measured so you can see it

Each line also carries its class of work: ordinary syncing, a copy of a table’s existing rows, or a batch delivered again after a restart (the meter records that it was delivered before, not why it was delivered again). The rate card in force on that day decides what each class costs.

Every day of every pipeline on the Usage page says which of these it is in, and what its money columns mean:

State What it means
Today so far, estimated (open) Today, UTC. The amount is an estimate; the day is charged after it closes.
Not billed yet (pending, retrying) The day is still being measured, or has not been billed yet. Quantities only.
Not billed (pending, not retrying) The day was not finished within the last three days, which is as far back as billing retries, so it is not billed automatically.
Billed (billed) Every charged line has its charge in your ledger. A line that cost nothing says why (below).
Not billed yet: being retried / Not billed: we have been alerted (refused) Billing the day failed. While the day is within the last three days it is retried on its own; after that, we have been alerted and look at it.

You are never charged twice for a day. A day whose billing failed and is retried is charged once, when it succeeds. A day that is billed stays billed: a later problem billing the same day again does not un-charge or re-charge it.

Under the table, Usage lists every quantity your pipelines measured that you were not charged for, with the reason:

  • A run that ended in failure is not charged. Every run that failed on a closed day is told once in the month Usage shows, in the one sentence for where its charge stands, with how many runs and how much:

    • credited back: once its day is billed, what it was charged is credited back to your wallet;
    • still to be credited back: a run that fails AFTER its day was billed is charged, and the next billing pass credits it back, usually within the hour. The sentence says how much is still to come, and how much of these runs’ charge already was credited, if any; a run whose usage shares a line with such a run, and that is not yet credited for that line, is told here too until then, because that line is still charged. Once the credit is written the run moves to “credited back”, and the day says when it was updated. The billing pass credits your account in one go, so while any run of the account is in the next sentence, these credits wait for that correction too;
    • the charge stands until we correct it: the credit could not be worked out automatically;
    • nothing was charged: none of the run’s usage took a charge.

    A run that used resources on more than one day, as a continuous pipeline’s run does across midnight UTC, is one run: it is told once, in the sentence of its worst day (the charge standing, then still to be credited back, then credited back, then nothing charged), with its credits and what is still to come added over its days. A run still owed a credit for any of its usage is never also told “credited back”. On today’s line nothing is charged yet, so it says only that these runs will not be. A failed run’s rows and bytes are told with all the others: measured, and not priced. In the API, a closed day’s failed runs are the day’s failed_runs, one object per run (run_id), each with its refund state for the day, credited_minor and pending_minor.

  • A run asked to stop before it finished is not charged either. A pipeline that reads its source by queries delivers a run’s changes once, at its end, so pausing it, editing it, or our service restarting while it runs stops the run before it finished. Its usage is credited back exactly as a failed run’s, in the same four sentences with the same amounts, and it is told as a stop, never as a failure. In the API, a closed day’s stopped runs are the day’s stopped_runs, never in its failed_runs, and today’s are stopped_run entries of not_charged. The Credited back column, and Billing’s line for these credits, name both: runs that did not finish.

  • Copying begun again that you did not ask for is not charged: a repair we ran; a table copied again from its start because our upgrade or a change in our own service needed it (our restart of a copy, our repair of what we wrote); or a table copied again when you resume it after a change reached us without a value we needed: one its row filter needs, or one needed to write whole a row the destination did not hold yet (a row that had just entered the filter), which our stream cannot yet read in full; or, for a table with no primary key, one its change needed to tell which row it changed. A copy that was already due (a table’s first copy, an added table’s, a re-copy you asked for) stays that copy when something paused it before its first row and you resume it: another session holding a lock on the table, or the table’s two publications disagreeing. It is priced as that copy. A copy that follows a destination you made again, moved or restored is copy work, priced as a re-sync is, even where our words asked you to make it: a destination table dropped and created again, a dump restored into it, or a PostgreSQL destination database made again in UTF8 because a pipeline does not start on one in another encoding (the tables copied again when you resume them).

  • Windows in which no table of the pipeline was syncing: while every table is parked, the pipeline keeps running so your source’s log does not grow, and those windows are measured and not charged. A pipeline parked for a whole day still shows that day, so you can see what it measured.

  • Work the rate card in force that day prices at zero, named with that card’s price and date.

  • Rows and bytes are measured and not priced.

  • Charges under one cent a day are not taken. The page shows the fraction that was left, summed over the days shown.

  • Usage shows one month at a time (Previous month, Next month), with a chart of each day’s charges stacked by pipeline (the largest pipelines by name, the rest as “Other pipelines”) and a table of each pipeline’s charged, credited back and net amounts.
  • By hour: pick a day within the last 31 days to see its 24 hours, vCPU-hours and GB-hours. GET /v1/usage/hours?day= serves the same, and refuses an older day (422 hours_out_of_range).
  • By month: GET /v1/usage/months gives each month’s charged, refunded and net amounts by pipeline, up to 24 months at a time. A month holds what its days cost, whenever the charge was written.
  • GET /v1/usage/days serves up to 400 days in one request (422 range_too_large beyond), newest day first. A deleted pipeline keeps its days, marked deleted.

A pipeline’s own page, under Usage, shows By table: the rows and bytes each table moved this month, largest first, with what was synced (changes as they happened) apart from what was copied (a table’s existing rows). Each table’s figures are what your destination confirmed for that table, so across the tables they add up to the pipeline’s own rows and bytes. It is the same on every destination.

  • Rows and bytes are not priced, so this is a view of where the volume went, never a charge.
  • Compute is measured per pipeline, never by table. One sync’s vCPU and memory serve every table it writes at once, so dividing them by table would print a number nobody measured.
  • Per-table counts start on the day your pipeline first ran on a release that keeps them. Rows and bytes without a per-table count (measured before that, including earlier the same day, or by a release without them) are shown for the pipeline as a whole, and the page says how much, and from which day the per-table counts begin.
  • GET /v1/usage/tables?pipeline_id=&from=&to= serves the same for up to 400 days (422 range_too_large beyond, or past 2,000 tables): tables by name, each with its lines by dimension and class, split_since (the first day with per-table counts, or null) and not_split (what no table holds). 422 missing_field without a pipeline_id.

Export CSV on Usage downloads the month shown. Beside it, an account whose API keys are on is linked to the history export (Platform export), which copies every pipeline’s daily usage, and the rest of the account’s history, into a PostgreSQL database you own, once a day. GET /v1/usage/days.csv?from=&to= any range of at most 92 days and 250,000 rows (422 range_too_large names both limits). One row per day, pipeline, dimension and class, with its state, quantity, the reason it was not charged if it was not, and the money in cents and in dollars. UTF-8, a header row, \r\n line ends. A cell that begins with =, +, -, @, a tab or a carriage return is prefixed with ', so a spreadsheet never runs a pipeline name as a formula. If a download fails part way, or reaches the 250,000-row limit with rows still to send, it fails as a broken download, never as a shorter file that looks complete: download it again, or a shorter range.

Billing shows your balance; whether your account is out of credit, and since when; this month so far (charged, credited back, net, by the day the usage happened); what remains of your credit from top-ups and granted by Reyansh; and your auto-recharge setting (only a setting that charges your card says auto-recharge is on).

How long it lasts is your balance divided by your daily spend: the net charge of the last seven closed days averaged over the days that had spend, and the page names how many days that was (“at $2.00 a day: the average of the 2 days with spend in the last 7”). An account that spent on two of those days is not told it has seven times the runway it has. A day whose runs all did not finish, and were credited back, is not a day of spend. With no spend in the last seven days there is no runway to estimate, and the page says so.

Adding credit by card from this page is not available yet; the page says so while it is not.

When a prepaid balance reaches zero, your account is out of credit: no pipeline is started until credit brings the balance above zero (the exception below aside): scheduled runs wait, a start waits, and a pipeline that streams continuously stops at its next restart (a restart of the service, or a crash). A pipeline already running is not stopped, but one that is not running keeps its source’s change log until it runs again. Add credit soon. A run that did not finish is credited back in full, so it never empties your balance by itself.

A balance usually runs out below zero, by a day’s charges, so credit smaller than the amount below zero starts nothing: at -$60.00, $20.00 of credit leaves -$40.00, and your pipelines still wait until credit brings the balance above zero (the exception below aside). Every billing email sent while your account is out of credit names the balance, and Billing shows it.

One exception: an account that has never had a top-up, a credit grant or a paid invoice. A run that did not finish is credited back in full, and such a run never pauses a wallet, so such an account stops waiting for credit once refunds of runs that did not finish bring it back to zero, not above it. Every out-of-credit sentence that cannot read your ledger says so as a condition, and a billing email (which reads it) says it only to an account it is true of; the notice that it is over says that was what ended it. Any top-up, credit grant or paid invoice ends the exception for good: from then on, unless the account becomes invoiced monthly, the wait ends only once credit brings the balance above zero. So an account given credit by us is not one of these: at $0.00 it is still out of credit.

When a charge lands after the wait ended. When credit brings the balance above zero, the wait ends at once, and the hourly check works the pause out again from your ledger. If a day’s charges are billed between the two and take the balance back to zero or below, the notice that the wait is over names the balance and says the account is paused again at its next hourly check unless credit brings the balance above zero first (or, for an account that has never had a top-up, a credit grant or a paid invoice, unless refunds of runs that did not finish bring it back to zero); when that check pauses it, you are told again.

A test of a billing notice (the notification settings’ “Send a test email”, or a channel’s “Send a test”) shows what the notice looks like for an account in its state: the out-of-credit test shows a balance below zero, because that is where the pause holds. Its figures are samples, and nothing about your own account is implied by them.

Whether your account is paused is worked out again from your ledger every hour, for every account, so it is never left out by a restart. A pipeline waiting to start is started at once, and a scheduled pipeline runs at its next scheduled time, as soon as the pause lifts. The pause lifts at once, as the credit is added, when credit brings the balance above zero. Its other ends are found by that hourly check: for the exception above, refunds of runs that did not finish bringing the balance back to zero, and an account becoming invoiced monthly. One kind of run still waits: the scheduled runs of a month whose budget, set to stop new runs, is also reached wait for the budget too, and every notice and the Billing page say so.

Owners set these on the Billing page (or PUT /v1/wallet/alerts; an API key never can), and every owner is told, whatever their own notification settings say (the notice that one is over is a recovery, emailed only while recovery notifications are on for your account, and each notice says whether it will be):

  • Low balance (on by default): when your balance lasts fewer than 7 days at your spend over the last week (you can set 1 to 60), or is at or below an amount you choose. It ends once the balance lasts at least a quarter longer than that, and is above the amount, so a balance hovering at the line does not tell you twice.
  • A monthly budget for this UTC month’s billed charges (charges less what runs that did not finish were credited back, counted for the day they are for). You are told at 50% and 80%, once each, and only the highest when several pass at once. With Stop new runs, no step is told once the month reaches the budget: the budget-reached notice says so, once.
  • At 100%, the budget’s action decides. Tell owners tells every owner. Stop new runs also skips the scheduled runs of pipelines that run on a schedule, and refuses to start them (409 budget_reached), until the budget’s stop lifts: next month (UTC), an owner raising the budget above this month’s charges, an owner removing the budget or setting it to tell owners only, or refunds of runs that did not finish bringing this month’s charges back under it. An owner’s change takes effect in the same request, and each such pipeline then runs at its next scheduled time. Each such pipeline reads Budget reached on the pipeline list, its page and the overview (health: budget_reached), never “Behind schedule”, its alert says the budget holds it, and its history says “Not started: this month’s budget is reached”, once. If your account is also out of credit, scheduled runs wait for both credit and the budget: every notice and the Billing page list what ends each wait, and the start’s refusal names both and points to Billing. Such a scheduled pipeline reads Out of credit, and its history says “Not started: out of credit” first (the wallet’s check comes before the budget’s); it waits until credit brings the balance above zero (or, for an account that has never had a top-up, a credit grant or a paid invoice, until refunds of runs that did not finish bring it back to zero). Its scheduled runs wait for the budget too.
  • Which pipelines Stop new runs would stop is shown beside the setting (alerts.budget_stops_pipelines): only your running pipelines whose source runs on a schedule. When none of yours does, Stop new runs stops none of them.

Pipelines that stream continuously are never stopped by a budget, not while they run and not after a restart: they keep running and costing. The budget notice names each one it can tell streams, up to 20, with what it was charged this month. Past 20 the list ends “and more”, and when a running pipeline could not be told apart as one that streams, the list ends “(possibly others)”, or names none and says they keep running and costing. Stop them yourself if you need to. The budget is checked against billed days, so the month’s spend can pass it before its stop takes effect (by today’s spend so far, by a day still being measured, and by a run already going): a UTC day’s charges count once that day is billed, at the first hourly check after it ends, or later while its usage is still being measured, as each check retries the last three closed days. A scheduled pipeline whose runs the budget skips keeps its source’s change log until it runs again.

Billing shows a statement for each month (Previous month, Next month, Export CSV): the opening balance; each top-up, credit granted and adjustment, with its reason; one row per day of usage, and one per day of credits for runs that did not finish; and the closing balance. Every row carries the balance after it, and the rows add up to the closing balance.

A month’s statement closes three days after the month ends, and then it never changes. Three days is how long a day’s billing is retried. An entry written after that, a credit for a run that failed late, a payment whose notice arrived late, appears on the first statement that is still open, marked late, for the day it belongs to. So a closed statement you downloaded is the statement, for good. A month that is still open can still change: its CSV ends with balance_so_far, dated the day that balance is of, never with a closing balance.

A month before your account’s first statement has no statement (none), and says so. A month that ended in the last three days is still open even with nothing in it yet, because the billing of its last days can still be its first entry; it says it has no statement only once that billing is past.

If a closed statement’s rows ever stopped adding up to its balances, the page and the API refuse to show it (500 statement_unavailable) rather than show a statement that is wrong, and the refusal is logged for our operators. Please contact support if you see it.

GET /v1/wallet/entries is the ledger itself, newest first in the order the entries were written, each with the balance after it. Walk it with its cursor and every page carries the ledger’s own balances, and no entry is skipped, even while charges and credits are being written. A top-up’s card hint is shown to an owner; a member or an API key reads the same rows without it, as on the balance. A page filtered by kind, from or to leaves entries out, so it carries no balance after each row.

GET /v1/wallet returns the alerts and budget as alerts (with alerts.budget_reached while a budget that stops new runs is reached, and alerts.held_by: what holds your pipelines now, credit, budget, credit_and_budget or null, which the Billing page says in one sentence) and billing_mode, the mode in force today. PUT /v1/wallet/alerts takes every field (low_balance_days, low_balance_minor, monthly_budget_minor, budget_action); an amount is null for none, and the change is in the audit log as wallet.alerts_changed.

state, reason, classification, dimension and kind are open lists: a newer release may add a value, and a program should show one it does not know as itself rather than fail. The OpenAPI document (api/openapi.json) describes every route, its parameters and its response.