Skip to content

Changelog: August 2026

2026-08-19 (IST) — ?run_id= on /observations: open a run and see everything that happened in it

Section titled “2026-08-19 (IST) — ?run_id= on /observations: open a run and see everything that happened in it”

New query parameter. GET /v1/pipelines/{id}/observations?run_id=<id> narrows the raw event feed to one run or session — the drill-down from a row of GET /v1/pipelines/{id}/runs. Take the run_id off a run entry, put it on this feed, and you get that run’s events, newest first, with the cursor and limit you already use.

The one thing worth knowing: you get events that carry no run id of their own. When the supervisor gives up on a pipeline it writes the event from outside any run, so that event has no run_id — and it is the event that says how the run ended. Filtering on the id alone would drop it, and you would see a run reported as partial — restart intensity exhausted next to a feed containing no such thing. This filter returns it, so the two views agree.

A run_id we cannot place is 404 run_not_found, never an empty page. “No such run” and “that run has no events” are different answers and we will not spell them the same way. Run history is derived over a bounded window, so a run older than that window cannot be filtered for — its events are still there in the unfiltered feed, which is not bounded.

Nothing changes for a request that does not send run_id. Same response, same paging, same cost.


2026-08-19 (IST) — run history in the console, with the outcome strip and a drill-down

Section titled “2026-08-19 (IST) — run history in the console, with the outcome strip and a drill-down”

Your pipeline page now shows what it has done, not only what it is doing. Above the event feed there is a run history: one row per run, newest first, with when it started, how it ended, and how many rows and bytes it moved. Paging works the same way the event feed’s does.

A row of recent outcomes sits above it — the last eight, at a glance. Each mark is coloured and sized by outcome, so it reads without relying on colour, and clicking one jumps straight to that run.

Clicking a run narrows the event feed to it, so “what happened in that run” is one click rather than a scroll through everything the pipeline has ever done. A banner says the feed is narrowed, with a button to show everything again.

⚠ A run that began before the 30-day window shows “Started before the window” and “Not known” — never a 0. The totals we hold for such a run are summed over part of it, so a figure would be an undercount, and an undercount on the screen where you reconcile against your own numbers is worse than no figure. A run that genuinely moved nothing still shows a real 0, and the two are deliberately different on screen.

A continuously-streaming source shows sessions, and no outcome word anywhere. Not a neutral one, not “running”. A session shows when it connected, when it last confirmed a write, what it has moved, how many times it restarted, and what the source says about its log — facts, each of which is true or absent. A green “sync finished” over a dropped connection is exactly the reassuring lie this refuses to tell.

When something ended badly, you get the worker’s or supervisor’s own words, verbatim and formatted as written — including any SQL you need to run. Nothing rewrites them.

2026-08-18 (IST) — GET /v1/pipelines/{id}/runs: a pipeline’s history, folded into runs

Section titled “2026-08-18 (IST) — GET /v1/pipelines/{id}/runs: a pipeline’s history, folded into runs”

New endpoint. GET /v1/pipelines/{id}/runs serves a pipeline’s history newest first, cursor-paginated. Where GET /v1/pipelines/{id}/observations gives you every raw event, this gives you the shape you actually want to render: one entry per run, with what it moved and how it ended.

Read shape before you read data. It is a top-level field with three values, and it tells you which vocabulary the items use:

shape what the items are
runs Your source syncs and stops, so each item carries an outcome: succeeded, partial, failed or running.
sessions Your source streams continuously. Items carry facts and no outcome key at all — a connection that is still up has not succeeded or failed, and we will not put a tick over one.
unfolded We do not derive a history for this source kind. data is empty and that is not a statement about your pipeline — use /observations.

partial is its own answer and not a softer failed. It means the run moved real data and then stopped, which answers the first question anyone asks — did anything land? — that a flat failed answers with silence.

Filters: outcome, since and until (RFC 3339). An outcome filter against a continuous source is refused with 422 outcome_not_applicable rather than answered with an empty page, because an empty page would say your pipeline had no successful runs, which is a claim about your data rather than about your query.

⚠ rows, bytes and started_at can be null, and null is not zero. A run that began before the window has been summed over only part of itself, so the total we hold is an undercount. We report it as absent rather than as a figure you might reconcile against your own. Render a dash, not a 0.

The window is 30 days, uniform, and is not a plan feature. It bounds run history only: /observations is not bounded by it, so you may see events there that are older than the oldest run listed here.

2026-08-16 (IST) — bonus credits on larger bundles, and a $25 minimum top-up

Section titled “2026-08-16 (IST) — bonus credits on larger bundles, and a $25 minimum top-up”

Bigger bundles now carry bonus credits, and the figures are published:

you load you receive
$1,000 $1,050 — a 5% bonus
$5,000 $5,500 — a 10% bonus

The bonus is credited alongside the money you paid, in the same wallet, and it spends exactly the same way. POST /v1/wallet/top-ups returns bonus_minor on the response, and it is the number that will be credited when your payment settles.

⚠ The bonus is fixed at the moment you are charged, not when the payment settles. If we change the ladder while your payment is still in flight — and an India-issued card can sit in its bank’s processing state for up to 26 hours — you receive the bundle you agreed to, not the one that happens to be published when the money lands. The same is true in the other direction: a better ladder published after your charge does not retroactively improve it.

A top-up must now be at least 2500 minor units ($25). A smaller request is refused with 422 and the error code below_minimum, and the message states the minimum. No charge is made — your card is not touched, and there is nothing to reverse.

{
"error": {
"code": "below_minimum",
"message": "A top-up must be at least 2500 minor units; this request asked for 2499.",
"fault": "customer",
"request_id": "req_..."
}
}

Nothing else about the endpoint changes: the Idempotency-Key header is still required, a successful charge still comes back pending because the wallet is credited when your processor settles, and an instrument needing an extra authentication step still returns requires_customer_action with a link.

2026-08-15 (IST) — you can load your wallet: POST /v1/wallet/top-ups

Section titled “2026-08-15 (IST) — you can load your wallet: POST /v1/wallet/top-ups”

There is now an endpoint that takes money. It charges the payment method you saved and, when your bank and our processor have settled it, loads the proceeds into your wallet.

An Idempotency-Key header is required, as on every mutating endpoint. On this one it is the difference between one charge and two: retry the same request with the same key and you get the original answer back, with Idempotent-Replay: true, and nothing is charged again.

The top-up comes back pending, even when the charge succeeded. Two fields, because they are two different facts:

  • outcome is what the processor said about the charge — succeeded, requires_customer_action, or unknown;
  • status is what your wallet knows, and it stays pending until the processor tells us the money has actually settled.

We could have collapsed them and reported settled on a successful charge. That would be a better-looking response and a false one: your balance would not have moved yet, and nothing would ever correct the claim.

requires_customer_action is a success, not a decline. If your bank needs you to authenticate the payment, the response is 201 with an action object carrying the link to complete and the deadline it expires at. If your card was issued in India this is the normal path at any bundle size worth buying — RBI’s rules require you to be present for a card charge above ₹15,000, and that is a rule about your bank rather than about your card being good. So we do not report it as a failure, because it is not one.

Declines are told apart rather than flattened into one message. An instrument that cannot be charged again (402 instrument_unusable) asks you for a different one; a decline that may work later (402 charge_declined) does not; and our processor being unable to act (429 provider_unavailable, with Retry-After) is attributed to them, not to you — nothing about your card is known from it.

Bonus credits are 0 for now, and the field is there so you can see that. The bundle ladder is not published yet. What is decided is when it is priced: the bonus is fixed at the moment you agree to the charge and recorded then, so a change to the ladder while your charge is still settling cannot alter the bundle you bought.

Settlement arrives on a signed callback from the processor, and the wallet is credited from that — not from the endpoint’s own response. A redelivered callback is a no-op: one payment credits your wallet exactly once, whatever the processor sends us and however often.


2026-08-15 (IST) — you can revoke a saved payment method, and revoking does not erase the history

Section titled “2026-08-15 (IST) — you can revoke a saved payment method, and revoking does not erase the history”

Still nothing in the product takes money — there is no endpoint yet — so this changes no API surface today. It is recorded because it is a decision about your data rather than an implementation detail.

Permission to charge is a record with a beginning and an end. When you save a payment method for auto-recharge we store an opaque token, a mask you would recognise (visa ****4242 12/29), and the date you granted it. You can revoke it at any time, and revoking writes an end date rather than deleting the row.

That is deliberate: if a charge is ever queried, “this was authorised on the 3rd and revoked on the 11th” is an answer, and a deleted row is not. What is kept is the permission’s own history — when it started, when it ended, and which masked instrument it referred to. The card number is not part of that, because we never had it.

One live permission per account at a time, and changing it is two deliberate steps. Saving a payment method while one is already live is refused rather than silently overwriting it. Replacing an instrument means revoking the old permission and then granting a new one — two acts, because it is two, and because “the card you thought you replaced is still the one being charged” is not a discovery anyone should make from a statement.


2026-08-15 (IST) — top-ups have a payment processor, and an India-issued card is a different product

Section titled “2026-08-15 (IST) — top-ups have a payment processor, and an India-issued card is a different product”

Nothing in the product takes money yet — there is no endpoint and no wallet writer — so this changes no API surface today. It is recorded because it fixes two things a customer will notice the moment top-ups open, and both are decisions rather than implementation details.

Auto-recharge on an India-issued card is not silent, and we will not call it automatic. The RBI e-mandate framework treats any merchant-initiated charge as in scope, and above ₹15,000 the customer must complete an additional factor every time. Our bundle sizes start at $1,000 — five to thirty times that ceiling. So for an India-issued instrument, a top-up at any size worth buying involves you: you get a message, you click once, and the money lands in seconds. The alternative — a stored mandate that charges silently in the code and asks you for 3DS 26 hours later anyway — is the promise broken in the fine print, and we are not shipping it under the word “auto”.

Rest-of-world cards are unchanged: a stored instrument is charged and settles in seconds.

A failed top-up will never become dunning. A top-up is a one-off charge and never a subscription object, which means a decline does nothing at all — no automatic retry schedule, no chasing emails, no “unpaid” state. If a recharge fails, your pipelines pause gracefully and you are told why.

We never hold your card. Card details are entered on the processor’s own page and never touch our servers; what we store is an opaque token plus a mask you would recognise, like visa ****4242 12/29.


2026-08-14 (IST) — a schema stop is its own observation, instead of a generic refusal

Section titled “2026-08-14 (IST) — a schema stop is its own observation, instead of a generic refusal”

When your source drops a column, changes a column’s type, or alters a table’s replica identity, the pipeline stops and waits for you rather than guessing what the destination should do with the existing values. That behaviour is unchanged and has been in place for a while.

What changes is what you see. Until now that stop arrived in a pipeline’s observation feed as a worker_refused — the same kind we emit when the destination is unreachable or a credential is wrong. Two very different situations, one entry, and only the free text told them apart.

It now arrives as schema_stop_raised, carrying:

  • stream — the stream whose schema moved, the same identifier checkpoint_advanced uses, so the two line up in one feed.
  • detail — what changed and what the decision is between, in the same words the pipeline would have shown you anyway. A dropped column and a column removed from a publication’s column list look identical from a replication stream and mean different things, and the text says so.

If you filter or alert on observation kinds, this is the one to watch for “somebody needs to make a decision” — as distinct from worker_refused, which now means what it always should have: something is wrong and wants investigating. Nothing you already filter on changes meaning, and no existing kind was removed.


2026-08-14 (IST) — the OpenAPI document defines Credential, so generated clients build

Section titled “2026-08-14 (IST) — the OpenAPI document defines Credential, so generated clients build”

Three credential operations — POST /v1/credentials, GET /v1/credentials/{ref} and POST /v1/credentials/{ref}/rotate — declared a Credential response and the document never defined that schema. A $ref with no target is not cosmetic: an OpenAPI generator resolves references, so openapi-generator and its peers failed on our document rather than producing a client with a vague type.

If you tried to generate a client and gave up, this was why. Nothing about the API’s behaviour changed — the responses were always this shape — only the published description of it.

The schema says what the endpoints have always returned, and says plainly what they do not:

  • ref — the reference id, the only form of a credential that a pipeline definition, a response, a log line or a webhook ever carries.
  • hint — ****last4. It identifies, it does not date: rotating a password does not change the database you connect to, so this is usually identical before and after a real rotation.
  • updated_at — the rotation evidence. This is the field that moves.
  • notice — present only when there is something you could not otherwise know.

There is no field for the secret, and there never will be. The API accepts one on create and rotate; nothing reads one back.


2026-08-14 (IST) — GET /v1/usage: what your account has used today

Section titled “2026-08-14 (IST) — GET /v1/usage: what your account has used today”

A new endpoint returning this account’s metered usage for the current UTC day.

{
"day": "2026-08-14",
"totals": [
{ "dimension": "cpu", "classification": "historical_load", "unit": "microseconds", "value": 900 },
{ "dimension": "cpu", "classification": "normal", "unit": "microseconds", "value": 40 },
{ "dimension": "rows_delivered", "classification": "normal", "unit": "rows", "value": 7 }
]
}

What to know before you integrate against it:

  • It is live, not a daily rollup. The current day is computed from the underlying measurements on every request, so a figure you read reflects work that finished seconds ago. That matters because billing is prepaid: a meter that lagged by a day would be an account running past zero without knowing it.
  • Totals are split by classification, and we do not sum them for you. normal is ordinary syncing; historical_load is your pipeline’s initial copy; replay is work redone after a fault on our side. If you want one number, add them. We report them apart so that “your backfill was free” is a statement you can see the size of rather than one you have to take on trust.
  • value is a measurement, not a charge. What each class costs is the wallet’s rule and is not stated here. Nothing on this endpoint is named cost or amount for that reason.
  • unit is on every row so you never hard-code it per dimension — cpu is microseconds, not seconds.
  • Integers throughout. Fractions accumulate rounding into a figure an invoice is computed from, so there are none.
  • Not paginated, and it will not become so: the response is bounded by how many dimensions and classifications exist.
  • A day with no usage returns "totals": [], never null.

egress_internet and storage are declared in the schema and are not produced yet — you will not see rows for them. Egress in particular needs a fact about where your destination sits relative to the worker, since same-region traffic is not billable egress at all, and we would rather report nothing than report your whole volume as though it were.


2026-08-12 (IST) — notification email is actually sent now

Section titled “2026-08-12 (IST) — notification email is actually sent now”

The settings below have been savable for a while and nothing was delivering on them. The control plane now runs the notification dispatcher, so an account with an address saved in PUT /v1/notification-settings receives the “syncing is blocked” email after the second consecutive failure of a pipeline.

What to expect:

  • One email per episode, not one per failure. A pipeline that fails for a week sends one. The Alerts page and the pipeline’s health chip are the ongoing signal; mail is for the transition.
  • The email names the pipeline and links to its page, and carries nothing else — no error text, no payload. Whatever went wrong is on that page, behind your own login.
  • Delivery is at-least-once. A duplicate is possible after a control-plane restart at exactly the wrong moment and is suppressed at the provider where their idempotency window allows. A missing email is the failure we designed against; a rare duplicate is not.
  • An empty email_to still means off, and a delivery already owed when you clear it is left waiting rather than thrown away — turn the address back on and it goes out.

Self-hosted deployments: this needs a mail provider configured. Without one the control plane starts exactly as before and says notification email: OFF in its boot log.


2026-08-12 (IST) — you can say where notifications go, and which ones you want

Section titled “2026-08-12 (IST) — you can say where notifications go, and which ones you want”

New: GET and PUT /v1/notification-settings.

Two settings per account, and one address:

  • email_to — where notifications go. An empty address turns the email channel off. There is deliberately no separate enabled switch: one value, so nothing can disagree with it.
  • errors — mail for alerts that block syncing. On unless you turn it off. This is the mail you would be angry to have not received.
  • warnings — mail for alerts that do not block syncing. Off unless you turn it on, because warnings-by-default is how a customer learns to filter our mail — which is exactly what makes the message that matters invisible.

They are severities, not a checkbox per alert type. That is the same split the Alerts page already shows, and it means a new kind of alert arrives under a subscription you have already made rather than switched off and waiting to be discovered.

This endpoint replaces your settings, so {"email_to": "ops@example.com"} on its own is refused with 422 invalid_field rather than read as “and turn both subscriptions off”. If we accepted it you would have unsubscribed from error mail, received a 200, and found out the next time a pipeline broke.

Send all three fields, and "email_to": "" to turn email off.

updated_at tells “you chose this” from “nobody has chosen”

Section titled “updated_at tells “you chose this” from “nobody has chosen””

A brand-new account has no stored settings, and GET reports the defaults — errors on, warnings off, no address — with no updated_at. Those values are byte-identical to an account that saved exactly the defaults, so the absent timestamp is the only thing that tells them apart. It is also the only proof a save landed, since a PUT echoes back the values you just sent.

Nothing sends this mail yet: this is where the preference is kept, and the delivery half follows.

2026-08-12 (IST) — a new endpoint: what is currently wrong with a pipeline

Section titled “2026-08-12 (IST) — a new endpoint: what is currently wrong with a pipeline”

New: GET /v1/pipelines/{id}/alerts.

An alert says what is wrong with a pipeline right now and whether it is stopping your data moving. Each one carries:

  • kind — gave_up, awaiting_historical_load, historical_load_running or sync_delayed.
  • severity — error or warning.
  • blocks — whether syncing is stopped. An error blocks; a warning does not, and the two fields are two readings of one rule rather than two things we keep in step.
  • pipeline_id — present even though you named the pipeline in the path, so a client merging this with the account-wide feed that follows never has to reconstruct it from a URL.
  • lifetime — optional: first_raised_at, last_raised_at and occurrences, the history of the current episode. See below for when it is absent.

⚠ An alert exists exactly as long as its cause does

Section titled “⚠ An alert exists exactly as long as its cause does”

These are derived per request from the same facts that produce a pipeline’s health, not rows we maintain. A pipeline that recovers stops alerting on the very next request, with no sweep to wait for and nothing to acknowledge — and a pipeline reported healthy cannot also appear here, because both answers come from one computation.

The practical consequence: lifetime may be absent, and the alert is still real. It answers “since when”, which is the one thing a derivation cannot know; when we have no record of an episode, the field is omitted rather than guessed. It is one object, so it is present in full or not at all.

A pipeline warrants at most one alert per kind, so this collection cannot outgrow a page and there is no cursor to follow. 404 for a pipeline that does not exist and for one that is not yours — the same answer, deliberately, so the API is not an oracle for ids in other accounts.

The account-wide feed (GET /v1/alerts) follows in its own release.

2026-08-12 (IST) — everything wrong across the account, in one feed

Section titled “2026-08-12 (IST) — everything wrong across the account, in one feed”

New: GET /v1/alerts. The same alert shape as GET /v1/pipelines/{id}/alerts (see the entry above for the fields and for why lifetime may be absent), for every pipeline in your account at once. Healthy pipelines contribute nothing, and a paused pipeline raises nothing at all: you already told us to stop it.

Ordered newest pipeline first — the same order and the same cursor as GET /v1/pipelines, so the two lists agree about what “next page” means. pipeline_id is on every alert, so you never have to reconstruct it.

Paging works the way it does everywhere else in this API

Section titled “Paging works the way it does everywhere else in this API”

Worth saying out loud, because this is the one endpoint where it could plausibly have gone otherwise. limit (default 50, max 200) counts alerts, not pipelines, and an empty data means you have reached the end of the feed — we never hand back an empty page with a next_cursor pointing past it, so the usual “keep going until data is empty” loop is correct here. We skip past accounts’ worth of healthy pipelines server-side rather than making you page through them.

One deliberate detail: a page is cut on a pipeline boundary, so one pipeline’s alerts are never split across two pages and a page may carry up to three more alerts than limit asked for. That is what keeps limit=1 able to make progress against a pipeline raising four.

2026-08-12 (IST) — the pipeline list shows what needs attention

Section titled “2026-08-12 (IST) — the pipeline list shows what needs attention”

The app now renders a pipeline’s health beside its state, on both the list and the detail page: Behind schedule, Still catching up, Needs attention or Paused.

A healthy pipeline shows nothing, deliberately. A badge on every row is noise on exactly the rows you are not looking for, and it trains the eye to skip the column — which is the moment the one that matters appears. So a chip means look at this one.

It sits beside the existing state rather than replacing it, because the two say different things: Running · Behind schedule is a worker that is up while the data is late, and neither half can say that alone.

2026-08-11 (IST) — a pipeline’s history names every event, and says when runs were skipped

Section titled “2026-08-11 (IST) — a pipeline’s history names every event, and says when runs were skipped”

Changed: the History on a pipeline reads two more event kinds by name, shows scheduled times in your own locale, and states plainly when scheduled runs were skipped.

Three things were missing, all of them in what you actually see:

  • “Run finished” and “Next sync scheduled” had no names. Both events were already being recorded and shown — as the raw internal identifiers run_completed and sync_scheduled. They now read as English (and are translatable like every other string).
  • The next sync time was shown as stored, not as you read it. next_due_at arrived as 2026-08-11T23:45:00Z. It is the one value in the history naming a moment you might plan around, and it is now rendered in your locale like the timestamp beside it. Row and byte counts are grouped for your locale too.
  • Skipped runs were a number nobody would notice. When a run overruns its interval, the runs it overran are coalesced into one — which is correct, and was reported only as missed=3 among the raw fields. The history now says “3 scheduled runs were skipped” in words, together with why nothing was lost: a run resumes from its checkpoint, so the one that follows covers the whole period.

No API change — GET /v1/pipelines/{id}/observations is unchanged, and every field described here was already in its response.

2026-08-11 (IST) — every pipeline says whether it is OK, in one word

Section titled “2026-08-11 (IST) — every pipeline says whether it is OK, in one word”

Added: health on every pipeline — healthy, paused, broken, incomplete or delayed. It is on GET /v1/pipelines, GET /v1/pipelines/{id}, and on every endpoint that returns a pipeline (create, start, stop, and the schedule update).

It is not a rename of status, and both fields stay. status is what the machinery is doing (running, stopped, gave_up); health is whether that is fine. A pipeline can be status: "running" and health: "delayed" at the same time — a worker is up and the data is late — and that pair is the case worth seeing.

What each word means:

  • paused — you stopped it. This wins over everything else: a pipeline you switched off is not something to alarm you about.
  • broken — it stopped and will not resume without you.
  • incomplete — it is running and the destination does not hold everything yet: a historical load is copying, or nobody has answered whether to run one.
  • delayed — a scheduled run is overdue against this pipeline’s own schedule, with fifteen minutes of grace. A six-hourly pipeline that ran an hour ago is healthy, not late, because it is between runs rather than behind.
  • healthy — nothing to say.

Two consequences worth stating, because both are cases where an obvious reading would be wrong. A source that streams continuously (Postgres, MySQL) is never delayed: its stream does not end, so it is never between runs. And a pipeline is only incomplete for an unanswered historical load while it is genuinely waiting — a source with nothing to copy is never asked, and one that has already run was asked long ago.

health is computed when you ask for it and never stored, so it cannot go stale.

Additive: an existing integration that ignores the field is unaffected.

2026-08-11 (IST) — a connector card says what its first run does

Section titled “2026-08-11 (IST) — a connector card says what its first run does”

Added: first_run on every source in GET /v1/connectors — "copy_then_replay" or "stream_only". Destinations do not carry it.

It answers whether a source has rows that predate the pipeline and therefore has to copy them before it starts streaming. A Postgres source does (a replication slot carries only what happened after it was created); a Stripe source does not, because reading the feed from its beginning is its history.

This is the fact behind whether Reyansh asks you about your existing rows on a pipeline’s first run, so the card now tells you before you set one up rather than at the point the pipeline stops to ask.

Additive: an existing integration that ignores the field is unaffected.

2026-08-11 (IST) — a quiet pipeline keeps releasing your database’s write-ahead log

Section titled “2026-08-11 (IST) — a quiet pipeline keeps releasing your database’s write-ahead log”

Fixed: an idle Postgres pipeline could stop releasing WAL on your source, and hold it for as long as the pipeline kept running.

While a pipeline is caught up and your database is quiet, Reyansh periodically tells your server it may discard the log it is holding on our behalf. If that step failed once — a momentary blip talking to our metadata store, or a lost connection at the wrong instant — it never ran again for that pipeline, until something restarted it.

Nothing looked wrong. The pipeline was healthy, its checkpoint was durable, and it was fully caught up. The only symptom was on your side: pg_wal growing on the source database, with a replication slot pinned where the pipeline last restarted. On a busy server that fills a disk in hours.

Who was affected. Postgres sources, only while the pipeline was quiet and only after a transient failure — so it was intermittent rather than constant, which is why it presented as a rare, hard-to-place disk-space problem rather than an obvious fault. MySQL and Stripe sources were never affected: neither holds a log on our behalf this way.

What to check. If you have seen unexplained WAL growth on a source database, restarting that pipeline released it, and it will not recur. There is nothing to change on your side.

2026-08-11 (IST) — cron schedules, on every plan

Section titled “2026-08-11 (IST) — cron schedules, on every plan”

A pipeline’s sync frequency can now be a cron expression with a timezone, not just a fixed interval. On every plan — Fivetran gates its shortest syncs behind Enterprise, and “custom cron instead of fixed intervals” is a documented complaint about them.

PUT /v1/pipelines/{id}/schedule
{"kind": "cron", "cron": "0 3 * * MON", "timezone": "Europe/London"}

POST /v1/pipelines accepts the same schedule object at create time.

The response tells you when it will actually run. A next_runs array carries the next three due times, and they are computed by the same code the scheduler wakes on — not by a separate preview that can drift out of step with what really happens.

Five fields, and one deliberate incompatibility. minute hour day-of-month month day-of-week. If you restrict both the day-of-month and day-of-week fields — 0 3 13 * FRI — we refuse rather than run it. Standard cron reads that as “the 13th or every Friday”, about five times more often than the “Friday the 13th” almost everyone means, and you would find out from a bill. The error names the three things you might have meant and gives a working expression for each.

Also refused, each with an explanation rather than a parser error: a timezone written inside the expression (CRON_TZ=… — put it in the timezone field, so there is one), ? (write *), a six-field expression with seconds, and 7 for Sunday (write 0 or SUN).

Timezones are IANA names — Europe/London, America/New_York — never a fixed offset like UTC+5:30, because an offset cannot describe a daylight-saving change. Leave it out and it is UTC.

⚠ Daylight saving is decided, not inherited. Standard cron silently skips a nightly job when the clock jumps forward, and runs it twice when the clock goes back. Neither is what anyone wants from something that costs money per run, so:

  • Clocks go forward (your 02:30 does not exist that day) — the sync runs at 03:00, as soon as it can. It does not vanish for a day.
  • Clocks go back (your 01:30 happens twice) — the sync runs once, on the first.

Fixed intervals are unchanged and still the default. An interval has no daylight-saving question at all: “every 6 hours” is six actual hours, whatever the clocks do.

Database pipelines (Postgres, MySQL) are unaffected — change capture streams continuously rather than in runs, so there is nothing to schedule.

2026-08-11 (IST) — your sync schedule is now what actually runs your pipeline

Section titled “2026-08-11 (IST) — your sync schedule is now what actually runs your pipeline”

The frequency you set is no longer just recorded — it is what drives the pipeline.

Until now a batch pipeline (Stripe) re-ran on whatever our supervisor’s restart backoff happened to be: a curve designed to space out failures, drawing a random wait between half a second and a minute. Now a finished sync waits until its next scheduled time and runs then.

  • Your pipeline’s history gains a sync_scheduled event after each run, carrying next_due_at — so “when does this sync next” is a question the API can answer.
  • A run that overruns its interval does not queue up a backlog. If a sync takes longer than the gap to the next one, the skipped runs are coalesced into one rather than replayed — for a change-capture pipeline they would move exactly the same data. The event carries missed so a skip is visible rather than silent.
  • Succeeding can no longer look like failing. Our supervisor gives up after repeated restarts; a completed sync is not a restart and never counts toward that. A frequent schedule previously risked being declared broken for working.
  • Manual pipelines stop after each run, which is what “manual” means: nothing is due until you ask.

Database pipelines (Postgres, MySQL) are unaffected — change capture streams continuously rather than in runs, so there is nothing to schedule.

2026-08-11 (IST) — a finished sync now says so in your pipeline’s history

Section titled “2026-08-11 (IST) — a finished sync now says so in your pipeline’s history”

A pipeline whose source is a batch connector — Stripe today — finishes: it reads its pages, delivers them, and the run is over. Your pipeline’s history recorded a run_started for each of those runs and nothing marking the end, so the only way to see where one sync finished was to notice the next one beginning. That cannot tell a completed sync from a worker that died and was restarted.

GET /v1/pipelines/{id}/observations now returns a run_completed event at the end of each such run. Everything between a run_started and its run_completed belongs to that sync, which is what makes a sync-history view possible.

It carries no row or byte counts, on purpose. A sync’s totals are the batch_applied events inside its brackets, summed — one number, from what your destination actually confirmed. A second total on the completion event would be a rival figure with nothing behind it.

Database pipelines (Postgres, MySQL) do not emit it, and that is not an omission. A change-capture stream does not end, so those runs do not complete — they stop, or they fail. Closing a bracket every time a replication connection dropped would put a finished sync in your history over an outage.

2026-08-11 (IST) — you can say how often a pipeline syncs

Section titled “2026-08-11 (IST) — you can say how often a pipeline syncs”

Pipelines whose source is a batch connector (Stripe today) now have a sync frequency you set, instead of one that emerged from how our supervisor happened to restart them.

  • POST /v1/pipelines accepts an optional schedule: {"kind": "interval", "interval": "6h"} or {"kind": "manual"}.
  • PUT /v1/pipelines/{id}/schedule changes it later.
  • GET /v1/pipelines and GET /v1/pipelines/{id} return it on every pipeline.

The interval is one of eight values — 15m, 30m, 1h, 2h, 3h, 6h, 12h, 24h — and anything else is refused rather than rounded to the nearest one. manual means nothing is ever due: runs happen when you ask for one.

Leaving schedule out means every 6 hours. That is the default across this market and it is trivially changeable afterwards, so unlike historical_load it is not a question we stop and ask.

⚠ If you already have a Stripe pipeline, its frequency changes. It has been re-syncing far more often than anyone chose — our restart backoff was accidentally acting as a sync interval — and it now syncs every 6 hours unless you say otherwise. That is the fix rather than a regression, but it is a real change to how often your destination is updated.

Database pipelines (Postgres, MySQL) are unaffected. Change capture streams continuously rather than in runs, so there is no interval to set — the field is reported on those pipelines for consistency and nothing reads it. Pausing and resuming remains how you control them.

A change takes effect when the pipeline next restarts, and the response says so. A running worker holds the definition it started with, exactly as for every other edit.

Cron schedules are not here yet. They are coming, and deliberately not rushed: which cron dialect we accept cannot be changed afterwards without silently re-timing everybody’s pipelines.

2026-08-11 (IST) — a database error now says what the database said

Section titled “2026-08-11 (IST) — a database error now says what the database said”

When a pipeline could not read or write something, the reason we showed you was often the four words “db error” — no code, no table, no explanation. That was our error rendering throwing away what PostgreSQL told us.

It now carries the server’s own words: the SQLSTATE and the message, and the hint when there is one. A first run that cannot read your source table used to say “the initial copy could not be started: db error”; it now says “42501: permission denied for table orders”.

Row values are still never included. PostgreSQL attaches a DETAIL to some errors that quotes the offending row — Key (email)=(a@b.com) already exists — and that is your data. It is deliberately left out, because these messages reach logs, your pipeline’s history feed and API responses.

2026-08-10 (IST) — a first run stops and asks before copying rows that predate it

Section titled “2026-08-10 (IST) — a first run stops and asks before copying rows that predate it”

Starting a pipeline for the first time no longer guesses about what to do with the rows already sitting in your table.

  • If that has not been decided, the pipeline stops before it touches your destination and tells you, by name, what to choose: copy the existing rows first, or sync only the changes made from now on. Nothing is written to your destination while it is waiting.
  • A recorded refusal is honoured, not treated as “no answer.” Choosing not to copy means only changes made from this point forward are synced — the rows that predate the pipeline will not appear later.
  • Sources whose feed already is their own history are never asked. If what you are syncing is itself a complete record of everything that happened — a change feed like Stripe’s, rather than a database table — there is nothing to copy, so this question never reaches you.

2026-08-10 (IST) — the create form asks about your existing rows, and prices the answer

Section titled “2026-08-10 (IST) — the create form asks about your existing rows, and prices the answer”

Creating a pipeline now asks one more question: what should happen to the rows your source already holds?

  • Copy my existing rows first — they are copied across before change capture takes over, so your destination starts complete.
  • Sync only changes from now on — rows that predate the pipeline are not copied, and will not appear later.

Neither is pre-selected, and Create stays disabled until you choose. A pre-ticked box is an answer you did not give, and both possible defaults are wrong in a way that is easy to miss.

The copy states its size. When your source can estimate it, the option reads “copies about 2,400,000 rows to your destination” — the same sentence over four hundred rows and four hundred million is not much of a choice. Some tables have no estimate (one that has never been analysed); those say so in words rather than showing a misleading number, and one unmeasured table makes the whole figure unknown rather than quietly reporting a smaller one.

POST /v1/connections/test now returns an optional rows on each discovered stream, which is where that estimate comes from. It is an estimate from the source’s own catalogue, never a COUNT(*), and it is absent rather than zero when the source does not have one.

2026-08-10 (IST) — historical_load on a pipeline: your existing rows are asked about

Section titled “2026-08-10 (IST) — historical_load on a pipeline: your existing rows are asked about”

POST /v1/pipelines accepts an optional historical_load: "requested" or "declined".

  • requested — the rows already in your table are copied across before change capture takes over, so your destination starts complete rather than from the moment you pressed Start.
  • declined — only changes made from now on are synced. Rows that predate the pipeline are not copied, and will not appear later.
  • Omit it if you have not decided. A first run that needs those rows stops and asks rather than guessing — it will neither copy your table uninvited nor quietly skip it.

Only some sources have anything to copy. A Stripe feed read from its beginning already is its whole history, so the field does not apply there and is never asked about.

A re-run of the historical load is asked for again, never inherited from the first answer. Reloading history is a large write into your warehouse, and it is not something a pipeline decides for you.

A misspelling is refused with 422 invalid_field rather than being interpreted — there is no reading of "yes" that is safe to guess at.

2026-08-09 (IST) — Stripe is a source you can actually run

Section titled “2026-08-09 (IST) — Stripe is a source you can actually run”

The Stripe card in the connector catalogue is now live. You can create a Stripe source, press Test, pick a stream, and run a pipeline into Postgres.

  • Authenticate with a RESTRICTED key (rk_...) carrying read scopes. A full-access sk_... key is not required and not wanted: reading invoices should not come with the ability to move your money.
  • POST /v1/connections/test answers for Stripe. It makes exactly one read-only request and creates, changes and deletes nothing — pressing Test is safe to repeat. The streams it offers come from the connector itself, so the picker is the same whether or not your account has any invoices yet.
  • A pipeline syncs one stream. events is the one to choose if you want updates and deletions as well as creations — it is Stripe’s own change feed.
  • Stripe guarantees events for 30 days. If a pipeline is paused longer than that, Reyansh stops and asks rather than silently skipping the gap or re-reading your whole history. Both options are offered with what each costs.

With this, every card in the catalogue is a runnable pipeline — Postgres source, Postgres destination, MySQL source, Stripe source.

2026-08-07 (IST) — POST /v1/pipelines composes from a Source and a Destination

Section titled “2026-08-07 (IST) — POST /v1/pipelines composes from a Source and a Destination”

New, and preferred. A pipeline can now name the connector objects you configured rather than repeating credential references:

POST /v1/pipelines
{"id":"orders","source_id":"src_prod","destination_id":"dst_warehouse","streams":["orders"]}

The credential for each end comes from the object, so you set it once and every pipeline using that Source picks it up. source_id and destination_id are now on every pipeline in GET /v1/pipelines and GET /v1/pipelines/{id}.

Nothing breaks. The older form still works:

{"id":"orders","source":"cred_prod","destination":"cred_wh","streams":["orders"]}

…and it now creates the Source and Destination for you, marked as derived rather than configured. You will see them in GET /v1/sources and GET /v1/destinations, and you can rename them. That is deliberate: a pipeline needs those objects for us to know which kind of connector each end is, so a pipeline created the old way is not a second-class one.

Two refusals worth knowing about, both 422:

  • ambiguous_pipeline_ends — sending both forms at once. We will not pick one for you: if source_id and source disagree, either answer is a pipeline reading from a database you did not mean.
  • unknown_connector — naming a Source or Destination that does not exist in your account. Create it with POST /v1/sources first.

If you use the API directly, nothing needs to change today. The object form is the one that will carry new connector kinds as they arrive, because it is where the kind is recorded — so it is the one to move to when convenient.

2026-08-07 (IST) — a pipeline whose checkpoint cannot be read now stops instead of re-syncing

Section titled “2026-08-07 (IST) — a pipeline whose checkpoint cannot be read now stops instead of re-syncing”

Behaviour change, and it is one you would rather have. If a pipeline’s stored resume position cannot be read back, the pipeline now stops and tells you why on its own event feed. Before, it treated an unreadable position as “this pipeline has never synced” and started a fresh full read of the table.

That is the difference between a pipeline that halts with a message and one that quietly re-copies your source into your destination — with the sync reporting healthy the whole time, and both databases doing the work.

You will see the pipeline in gave_up, and a worker_refused entry naming the stream and what could not be read:

a checkpoint is stored for stream 'orders' and this worker cannot read it: <reason>.
The worker refuses to treat it as a first run, because that would re-read the whole table.

What to do: this means the stored position is damaged, which in practice follows a partial restore of our metadata database or a hand-edit during an incident. It is not something a restart fixes, so the pipeline is deliberately not retried. Contact us — the position can be repaired, and the alternative (a full re-read) should be your decision, not a side effect.

Nothing changes for a pipeline that has never run. No stored position still means a first run, exactly as before.


2026-08-06 (IST) — GET /v1/connectors: what we support, and what we do not yet

Section titled “2026-08-06 (IST) — GET /v1/connectors: what we support, and what we do not yet”

New. A single endpoint listing every connector in the catalogue, so you can see what a source or a destination may be set to without reading our docs and hoping they are current.

GET /v1/connectors
{"data":[{"kind":"postgres","role":"source","status":"live","name_key":"…","blurb_key":"…"}],
"next_cursor":null}

Two things about it are deliberate and worth knowing:

  • status is live or planned, and planned means you cannot select it yet. A planned connector is one we have built and tested and have not yet wired into a pipeline the platform can run. We would rather show you it is coming than hide it — and much rather than let you fill in a setup form, hand us a production credential, and discover at the end that nothing can run. Today MySQL and Stripe are planned; Postgres is live at both ends.
  • name_key and blurb_key are message keys, not text. Display strings are translated; the API returns the key so your own interface can render it in your language rather than ours.

next_cursor is always null today: the catalogue is small enough to arrive in one page. The shape will not change when it is not.


2026-08-05 (IST) — a wrong password now says so, and is not retried

Section titled “2026-08-05 (IST) — a wrong password now says so, and is not retried”

Fixed, and it was the least helpful thing we did. A pipeline whose credential had the wrong password produced five restarts and then “stopped after 5 restarts in 60s” — a description of our reaction, not of your problem — with the word db error in the log and nothing else. The password was never mentioned.

Two things were wrong. The driver’s own error text for anything the server reports is the literal string db error; and a rejected password was treated as a temporary failure, so it was retried, and the mechanism that puts a diagnosis on your pipeline’s page only speaks for permanent ones.

Now a rejected password, a database that does not exist, a pg_hba.conf rule that refuses your host, and a missing privilege are all treated as configuration faults:

  • not retried — restarting cannot fix them, and five pointless attempts only delay the message;
  • shown on the pipeline’s page, with the server’s own words, its SQLSTATE, which end refused (source or destination), and what to do about it;
  • and POST /v1/connections/test says retryable: false for them, instead of inviting you to try the same credential again.

A genuinely temporary failure — a refused connection, an unresolvable host, a database mid-reboot — is unchanged: still retried, because it still works afterwards. An unfamiliar error from the server is also still retried, deliberately, and now carries its SQLSTATE so it can be identified.

2026-08-05 (IST) — self-hosted: connection tests can reach your private network

Section titled “2026-08-05 (IST) — self-hosted: connection tests can reach your private network”

For self-hosted deployments only. Connection tests reach public addresses; on a box running Reyansh beside its own database, that means they cannot reach it. An operator can now name the private ranges this deployment may test against:

REYANSH_ALLOWED_PRIVATE_CIDRS=10.4.0.0/16,192.168.0.0/16
  • Empty by default. A deployment that says nothing reaches nothing private, and the hosted service leaves it empty.
  • Deployment configuration only. There is no API for it and there will not be — this is a statement about the operator’s own network, not something an account can widen.
  • It cannot reach loopback, link-local, multicast or the machine’s own addresses, whatever you write there. 0.0.0.0/0 gets you every private range and still not 127.0.0.1.
  • A malformed entry stops the control plane from starting, on purpose: a guard narrower than you believe is worse than one that refuses to boot, because the first is silent.
  • The active ranges are printed at boot, and so is their absence.

Nothing changes for the hosted service.


2026-08-05 (IST) — you can create a pipeline even where we cannot test the connection

Section titled “2026-08-05 (IST) — you can create a pipeline even where we cannot test the connection”

Fixed, and it was our mistake. Connection tests only reach public addresses, and the create form disabled Create until a test passed. Put together, that meant a Reyansh running beside its own database — the way self-hosting is meant to work — could not create a pipeline at all.

Now, when we refuse a host on policy, the form says so in one line, explains that the limitation is ours and not your credentials, and lets you create the pipeline anyway. The stream names are typed in that case, since there is no list to pick from — table names only, and we still refuse a schema-qualified one before the round trip.

New field: connection_tested on every pipeline, in POST /v1/pipelines (optional, defaults to false) and in every response (always present). It records whether a connection test gated the creation.

⚠ It is a report, not a proof. Nothing binds a test call to a create call, so read it as “a test was claimed”, not “a test happened”. It is false for every pipeline created before the test endpoint existed, which is accurate rather than cautious.

A pipeline created without a test says so on its own page. If a first sync fails on a credential, that is the first thing worth knowing.


2026-08-05 (IST) — pick your streams instead of typing them

Section titled “2026-08-05 (IST) — pick your streams instead of typing them”

The create-pipeline form tests before it stores, and the test fills the streams field.

Press Test connection and we connect to both databases and list what your source publishes. Nothing is stored by that press. The streams field is then a list you tick, not a box you type into — which removes a whole class of mistake rather than validating it: a stream name is a table name and we supply the schema, so typing public.orders used to fail deep in the pipeline with invalid_stream_name.

A refusal appears beside the field it is about, not at the top of the page — the source box, the destination box, or the streams list — carrying the exact diagnosis, including any statement you need to run.

Editing either connection string clears the test. The discovered streams belong to the database that was tested, and keeping them after you change the URL would let you pick a table from one database and build a pipeline against another.

Create is unavailable until you have tested and picked at least one stream. That is the same ordering as the API: nothing is stored that has not connected.


2026-08-05 (IST) — test a connection before you store it, and get the stream list back

Section titled “2026-08-05 (IST) — test a connection before you store it, and get the stream list back”

New: POST /v1/connections/test. Give it a source and a destination connection string; it tells you whether they work — and nothing is stored either way.

The test is productive, not a green tick. When the pair is usable it returns streams — every table the source’s publication covers — so you pick a stream from a list instead of typing a table name that has to be spelled correctly. That is the field that produced a real refusal before now (public.orders gave invalid_stream_name): a stream name is a table name and we supply the schema, so store name alone.

A refusal names which input is at fault. refusal.subject is source, destination or stream, so your interface can put the message beside the field rather than at the top of the page, and refusal.detail is the worker’s own diagnosis verbatim — including any statement you need to run.

destination_checked tells you how deep the answer goes. Without a stream there is no table to check the destination against, so the answer covers reachability and discovery only. With one, the full preflight runs — including the refusal that catches a destination inside the source’s own publication, which would otherwise be an infinite loop discovered long after the pipeline started.

What it will not do:

  • Public hosts only. A loopback, private, link-local or carrier-NAT address is refused with 422 host_not_allowed. If you need us to reach a private endpoint, tell us — that is a peering conversation, not a bug.
  • Rate limited, per account, with Retry-After on the 429. It opens real outbound connections on request.
  • Bounded. A pair that has not answered within 15 seconds returns 504 check_timed_out. That usually means a firewall is dropping the connection rather than refusing it.

A refusal from the check itself is a 200 with usable: false, not an HTTP error: the test ran and the answer is no. HTTP status codes are reserved for “we could not test”.


2026-08-05 (IST) — a pipeline that gave up can now be started from its own page

Section titled “2026-08-05 (IST) — a pipeline that gave up can now be started from its own page”

Fixed. A pipeline in the gave_up state showed the notice “start it again once the cause is fixed” — and the Start button was disabled. The page named the recovery and would not let you perform it.

The cause: giving up leaves desired_state at running (it is the record of what you asked for, and it is deliberately not rewound), and the button was disabled whenever the desired state was already running. So the one state where Start does something was the one state where it could not be pressed.

The workaround, if you are on an older build: press Stop, then Start. That always worked, and nothing said so.

Nothing about the API changed — POST /v1/pipelines/{id}/start was always the only thing that clears a give-up, and it always accepted the request.


2026-08-05 (IST) — a pipeline that refuses to start now tells you what is wrong

Section titled “2026-08-05 (IST) — a pipeline that refuses to start now tells you what is wrong”

New observation kind: worker_refused. It appears in GET /v1/pipelines/{id}/observations and on the pipeline’s page, and it carries a detail field holding the worker’s own diagnosis — verbatim.

Until now, a pipeline that could not start told you two things, both true and neither actionable: the state gave_up, and the supervisor’s summary “the worker reported a configuration fault (exit 2)”. The actual answer — which replication slot is missing, the exact SELECT pg_create_logical_replication_slot(…) that creates it, and the attribute the role needs — existed the whole time and went to a log file on the machine running the worker. If that machine is ours, you could not read it.

Now it reaches you.

It is written only for faults a restart cannot fix, which is the class that needs a person. A momentary failure to reach a database is not announced: it is usually gone by the time you would read it, and a feed full of blips is one you stop reading before the entry that matters arrives.

Nothing was removed. supervisor_gave_up still records that we stopped trying and how many times we retried first; worker_refused records what is actually wrong. They answer different questions and you get both.

2026-08-05 (IST) — observed_detail on a pipeline, and the give-up notice stops saying “repeated failures”

Section titled “2026-08-05 (IST) — observed_detail on a pipeline, and the give-up notice stops saying “repeated failures””

New field: observed_detail on GET /v1/pipelines/{id}, GET /v1/pipelines and the start/stop endpoints. Present only for gave_up, absent otherwise.

notice and observed_detail answer different questions and you get both. The notice says what to do; this says what is wrong. On the single-pipeline endpoint it is the worker’s own diagnosis, verbatim — including the exact statement you need to run — falling back to the supervisor’s summary when the worker did not get far enough to have one.

It is free text meant for a person, and it is pre-formatted: real newlines, with any SQL on its own line. Do not parse it and do not collapse its whitespace.

⚠ Fixed: the give-up notice claimed something untrue half the time. It read “stopped after repeated failures”. There are two ways to give up and only one repeats — exhausting the restart budget is five failures in a minute, but a configuration fault is never retried at all, because retrying cannot fix one. So a pipeline that failed exactly once was described as having failed repeatedly, which sends you looking for a flaky network when the problem is a missing replication slot.

It now reads “this pipeline stopped and will not restart on its own; start it again once the cause is fixed” — true for both causes — and observed_detail says which one you have.

status: "gave_up" is unchanged, and its description in the OpenAPI document has been corrected the same way.

In the web interface, a given-up pipeline’s page now shows the diagnosis under its state, in a monospace block that preserves the formatting so the statement can be copied.


2026-08-05 (IST) — creating a pipeline now refuses an unknown credential reference

Section titled “2026-08-05 (IST) — creating a pipeline now refuses an unknown credential reference”

POST /v1/pipelines names its source and destination by credential reference, and it used to accept any string. A reference you had not created returned 201, the pipeline appeared as stopped, and pressing start failed later — in a different process, with the reason a long way from the mistake.

It now answers 422 unknown_credential, naming the reference, saying which end of the pipeline it belongs to, and pointing at POST /v1/credentials to create it. Nothing is stored when it refuses.

A reference is scoped to your account. Another account’s reference reads as unknown here, which is what stops a pipeline being pointed at a credential that is not yours.

If you are creating pipelines today: create the credential first, then the pipeline. That was already the only order that worked; the difference is that the product now says so at the point where you can still act on it.

2026-08-04 (IST) — a pipeline’s history, in the API and on its page

Section titled “2026-08-04 (IST) — a pipeline’s history, in the API and on its page”

New: GET /v1/pipelines/{id}/observations — what has happened to a pipeline, newest first, cursor-paginated like every other collection. It appears on the pipeline’s page in the web interface too.

Each entry carries a sequence number that advances by exactly one, so you can tell a gap from a quiet period without trusting timestamps; a kind (batch_applied, supervisor_gave_up, schema_stop_raised, and the rest); when it happened; and a detail object with the event’s own fields.

⚠ detail carries only fields we have explicitly published. Anything else a producer writes is dropped before it reaches you. That is deliberate — it means a new internal field cannot appear in your feed by accident — and the practical consequence is that a field you expect and cannot see is one we have not published yet. Tell us and we will.

A pipeline that does not exist and one belonging to another account both return the same 404, as everywhere else.


2026-08-03 (IST) — updated_at on a new credential is now the stored value

Section titled “2026-08-03 (IST) — updated_at on a new credential is now the stored value”

Fixed. POST /v1/credentials reported an updated_at taken from the control plane’s own clock rather than the one the database wrote. Rotation always returned the stored value, so the two came from different clocks — and since updated_at is the only evidence that a rotation took effect (the masked hint is identical across an ordinary rotation, which is why the response says so), a genuine rotation could report a timestamp that appeared to go backwards.

Both endpoints now return what the database stored. If you recorded an updated_at from a create response before today, it may be off by however far the two clocks were apart — re-read the credential to get the stored value.


2026-08-03 (IST) — pipelines in the web interface

Section titled “2026-08-03 (IST) — pipelines in the web interface”

New: list your pipelines, create one, and start or stop it — all from the browser, at the same address as the API.

The list pages with a “Load more” button rather than numbered pages, and it adds to what is already on screen rather than replacing it, so nothing you were just looking at disappears. Under the hood it uses the same cursor pagination the API offers, which means a pipeline created while you are reading cannot push another one out of sight unseen.

⚠ Creating a pipeline still does not start it, and the interface now makes that obvious: you land on the new pipeline’s own page, where its state and the Start button are together. Press Start and you will see “Running” requested while the state still reads “Stopped” — that is correct, not a glitch. The pipeline begins within one reconciliation interval, and the notice on the page says so in words.

Start and Stop are safe to double-click. Every change the interface makes carries an idempotency key, so a second press cannot create a second effect.

When something fails you get the reference id, the same one the API returns. Quote it and we can find the exact request.


2026-08-03 (IST) — there is a web application, and it ships in the binary

Section titled “2026-08-03 (IST) — there is a web application, and it ships in the binary”

New: the control plane now serves a web interface at /, alongside the /v1 API it already served. It is one binary and one deployment — there is no second service to run, no Node process, and nothing extra to configure.

This first slice is the sign-in screen. Pipeline pages follow.

It is dark by default, and every colour, font and spacing value comes from the same brand configuration the rest of the product uses.

⚠ A build without the web interface says so. If the binary was compiled without the front end, / answers 503 with a message naming the build step rather than a blank page — and the startup log says the same thing. /v1 is completely unaffected in that state.

For self-hosted deployments: nothing to set. The interface is served from the same origin as the API, so there is no URL to configure and no CORS to open.


2026-08-03 (IST) — sign in, and the API is reachable

Section titled “2026-08-03 (IST) — sign in, and the API is reachable”

New: POST /v1/auth/link, POST /v1/auth/session, POST /v1/auth/logout. These are the only endpoints that do not require a session, and until now there was no way to obtain one — every /v1 route existed and nothing could reach it.

How signing in works. POST /v1/auth/link with {"email": "..."} mails a single-use link. Following it gives your client a token, which POST /v1/auth/session exchanges for a session cookie. From then on every /v1 request is scoped to your account automatically; there is no tenant header, and there deliberately is not one — the account comes from the session, never from a value the caller can set.

POST /v1/auth/link always answers 202, whether or not the address has an account. Anything else would let anyone with a list of addresses learn which ones have accounts here. The one exception is a malformed address (422 invalid_email), which says nothing about whether any account exists.

A sign-in link works exactly once, and expired, replayed and wrong links are one answer (401 link_invalid). Telling them apart hands an attacker a progress meter.

Two refusals that are worth handling separately. 403 no_account means you proved you hold the address and it is not a member of any account. 409 account_ambiguous means it belongs to more than one, and choosing between them is not supported yet — a single sign-in link cannot tell us which account you meant, and we would rather say so than seat you in one and scope everything you do afterwards to the wrong company.

POST /v1/auth/logout revokes the session server-side and clears the cookie — both, which is why sessions are stored rather than signed. A signed cookie would make “sign out” a button that clears your browser’s copy and leaves a stolen one working until it expired. It answers 204 whether or not you were signed in.

⚠ Sign-in email is not yet delivered by a real provider. The control plane logs a loud warning at startup while the development mailer is in use: links are recorded in memory, not sent. This is the blocker for customer sign-in and is called out here rather than left for somebody to discover.

The session cookie is __Host--prefixed, HttpOnly, Secure and SameSite=Lax, from config/security-headers.json — one policy, one implementation.


2026-08-03 (IST) — store and rotate a credential

Section titled “2026-08-03 (IST) — store and rotate a credential”

New: POST /v1/credentials, GET /v1/credentials/{ref}, and POST /v1/credentials/{ref}/rotate. Like every mutating endpoint, the two POSTs require an Idempotency-Key.

You give a credential a reference when you store it, and you never get the value back. A GET returns the reference, a masked hint (****last4) and updated_at — there is no field in the response that could carry the value, on any of the three endpoints.

Creating does not overwrite. Reusing a reference is 409 credential_exists, not a silent replacement, because the credential a reference names is the one every running pipeline resolves. Replacing one is /rotate, deliberately a different call.

⚠ Two things about rotation that are easy to get wrong, so the response says both.

  • It takes effect at the next worker restart, not immediately. A running worker received its credential in its environment when it started, and a process’s environment cannot be changed from outside. Your old credential keeps working until you revoke it at the provider — which is exactly the situation in which it is easy to believe you have rotated and have not.
  • The masked hint will usually not change, so do not use it to check. ****last4 is the last four characters, and rotating a password does not change the database you connect to: postgres://svc:old@db/orders and postgres://svc:new@db/orders have the same hint. updated_at is the field that tells you the rotation landed. The response says so in its notice.

A reference that does not exist and one belonging to another account both return the same 404. That is deliberate — distinguishing them would confirm which references exist elsewhere.


2026-08-03 (IST) — start and stop a pipeline

Section titled “2026-08-03 (IST) — start and stop a pipeline”

New: POST /v1/pipelines/{id}/start and POST /v1/pipelines/{id}/stop. Like every mutating endpoint they require an Idempotency-Key.

New fields on a pipeline: desired_state and notice, alongside the existing status.

desired_state is what you asked for — running or stopped. status is what is actually happening — stopped, running, or gave_up. They are two fields on purpose. When they differ, something is in progress; when they agree, your pipeline is where you want it. A single combined field could not express “you asked for this and it is not true yet”, which is most of what you want to know while a change is taking effect.

So a successful /start returns desired_state: "running" with status: "stopped", and that is not a bug. notice explains it in words:

  • starting — it begins within one reconciliation interval, not instantly.
  • stopping — the worker finishes the batch it is in the middle of first, so your destination is never left with half a batch.
  • the definition changed — a running worker reads its configuration once when it starts, so an edit takes effect at the next restart. We would rather tell you than let you infer it from a 200.
  • gave up — the pipeline stopped after repeated failures and will not restart on its own. This is deliberate: something is wrong that retrying will not fix, and restarting forever would hide it while moving no data. Fix the cause, then call /start again — which is also the only thing that clears this state.

notice is absent when there is nothing to say, so a notice you do see is worth reading.

Fixed: the OpenAPI document referenced a Pipeline schema it never defined, which broke client generators that resolve $refs. The schema is now there.


2026-08-02 (IST) — pipeline names are yours alone

Section titled “2026-08-02 (IST) — pipeline names are yours alone”

Fixed: a pipeline id now only has to be unique within your account. Previously it had to be unique across every account, so creating a pipeline called orders could return 409 pipeline_exists because someone else — with no relationship to you — had used that name. Nothing about their account was ever revealed, but the name was unusable and we could not tell you why.

Within your own account a duplicate id is still a 409, which is the conflict that should happen.

2026-08-02 (IST) — pipelines: create, list, fetch

Section titled “2026-08-02 (IST) — pipelines: create, list, fetch”

The first endpoints. All under /v1, all tenant-scoped.

  • POST /v1/pipelines — store a definition. Requires an Idempotency-Key.
  • GET /v1/pipelines — cursor page, newest first. ?limit= is clamped, not refused.
  • GET /v1/pipelines/{id} — one pipeline, with its streams in the order you gave them.

⚠ Creating a pipeline does not start it. The response carries "status": "stopped", and it will keep saying so until the lifecycle endpoints land. This is stated rather than implied because the alternative — discovering it by watching an empty destination — is the worst possible way to find out.

A pipeline id must be unique across the whole system, not just within your account. Creating one whose id another account already uses returns 409 pipeline_exists. That is a limitation of the current schema rather than a deliberate design, and it is safe: you are told plainly, nothing is overwritten, and no information about the other account is revealed. It is expected to change.

Fetching a pipeline that belongs to someone else returns 404, not 403 — telling the two apart would confirm that an id exists in another account.

2026-08-02 (IST) — the API surface is published

Section titled “2026-08-02 (IST) — the API surface is published”

Pre-release. Nothing here is callable yet — no business endpoints exist. What is published is the shape a client can start coding against, and it is now generated from the code rather than described by hand.

  • api/openapi.json is generated and committed, and CI fails if it drifts from the code. The registry in the control plane is the single place an operation is declared.
  • The error envelope is fixed (standards/api-design.md §4): one shape for every status, carrying a stable code, a human message, the fault attribution, the request_id, and a docs link.
  • ⚠ fault has FOUR values, not three: customer, upstream, ours, and undetermined. If you are switching on this field, handle the fourth. undetermined means the evidence cannot attribute the failure and a human is looking — it is not an “unknown, treat as error” bucket, and it is deliberately never folded into one of its neighbours, because attributing a fault we cannot prove is wrong in both directions.
  • Every response carries X-Request-Id, and an inbound one is propagated rather than replaced. Quote it in a support request and we can find your trace.
  • Mutating requests require an Idempotency-Key. A retry with the same key replays the original response verbatim and does not re-execute; the same key with a different body is refused 422 rather than answered with the first request’s result.
  • Pagination is cursor-only. Cursors are opaque and signed — do not construct or parse them. limit is clamped server-side rather than refused.