Estuary

A managed data-movement platform that captures changes from databases and SaaS sources into collections kept as JSON files in your own bucket, then keeps warehouses and other systems in sync, in real time or on a schedule.

What it is: ETL & ELT pipelines,Event streams
Type: Commercial product
Made by: Estuary Technologies, Inc.
License: Proprietary hosted service. The Flow runtime source (estuary/flow) is under the Business Source License 1.1 (since November 2020), which converts to Apache 2.0 on its change date (2029-11-20 in the current text) and bans offering it as a data processing service to third parties; only go/protocols is also available under Apache 2.0. Most connectors are BSL too, and the Gazette broker underneath is MIT
Facts checked: 6 October 2026

What it is

An Estuary pipeline has three kinds of task, each a connector packaged as a Docker image. A capture reads a source: the transaction log of PostgreSQL, MySQL or MongoDB (change data capture), or incremental pulls and webhooks for APIs and SaaS apps. It writes JSON documents into a collection, which has a key and a JSON schema every document must match. Collections are Gazette journals: just-written documents sit in a replicated broker buffer that readers can tail within milliseconds, then get flushed as ordinary compressed JSON files under the collection’s prefix in your S3, GCS or Azure bucket. A materialization reads one or more collections and keeps tables in a destination up to date. A new reader fetches history straight from the files and then switches to the live tail, so adding a destination never re-reads the source database. On the way, the runtime combines documents with the same key (last write wins by default; schema annotations can sum or merge fields), so the destination receives fewer rows. Each destination has its own sync schedule, from continuous to batched.

Derivations are collections built continuously from other collections, written as SQL (run in SQLite), TypeScript or Python, with internal state for joins and aggregates. Dekaf lets Kafka clients read collections as if they were topics. Estuary sells a hosted control plane with public data planes, plus private and bring-your-own-cloud data planes on annual contracts. As of October 2026 list pricing is $0.50 per GB moved into or out of Estuary, plus $100 a month for each of the first six connector instances and $50 for each one after that, charged by the hour. The free plan covers two connectors and 10 GB a month.

Why teams pick it

Capture once, deliver many times: new destinations and backfills read history from your bucket, not from the production database
Collections are plain JSON files in a bucket you own, so Spark, Snowflake or pandas can read them directly, and leaving Estuary doesn’t strand the data
Streaming and batch in one pipeline: each destination chooses continuous or scheduled delivery without a second tool
Transforms in flight in SQL or TypeScript, including stateful joins and aggregations, and Kafka-protocol access through Dekaf
Published per-GB and per-connector list prices that are easy to estimate

Watch out for

Data is billed on the way in and again on the way out: the pricing calculator’s default of 800 GB with two connectors comes to $1,000 a month, which is 1,600 GB at $0.50 plus $200 in connector fees
Source-available, not open source: the BSL bans offering it as a service to third parties, and the supported ways to run it are Estuary’s cloud or a private or BYOC deployment on an annual contract
You manage the storage: the trial bucket deletes collection data after 20 days, and in your own bucket a lifecycle rule that touches the recovery/ logs can break tasks for good
Postgres CDC needs care: an unbounded replication slot can fill the disk with WAL, and if max_slot_wal_keep_size invalidates the slot, every table has to be backfilled again
Python derivations run only on private and BYOC data planes

Alternatives

What all etl & elt pipelines have in common →

AirbyteCommercialAn ELT platform you can host yourself: hundreds of connectors, each a Docker image speaking one JSON protocol, scheduled by services on Kubernetes.

Apache NiFiOpen sourceA Java dataflow server you program by drawing a graph of processors in a web UI, with buffered queues, back pressure and a record of where every piece of data went.

ArtieCommercialA managed change data capture service that copies every insert, update and delete from production databases into a warehouse, aiming for under a minute of delay.

BruinOpen sourceOne Go command-line tool that ingests data, runs SQL and Python transformations and checks the results, with each step a file in your repo.

DagsterOpen sourceA Python data orchestrator built around assets: you declare the tables, files and models that should exist, and Dagster works out what to run.

dbtOpen sourceSQL `select` statements in git, built into warehouse tables in dependency order, with tests and docs alongside.

FivetranCommercialManaged connectors that copy data from SaaS apps, databases and files into your warehouse or lake, billed by the rows that change each month.

MeltanoOpen sourceA command-line ELT tool that runs Singer taps and targets from a `meltano.yml` project kept in git.

OLakeOpen sourceAn open-source tool in Go that copies databases, Kafka topics and S3 files into Apache Iceberg tables (or plain Parquet), with full loads, incremental syncs and CDC, and no Kafka, Debezium, Spark or Flink in between.

How it fits with other technologies

What Estuary uses

What uses Estuary

Artiecompetes for real-time CDC withEstuaryETL & ELT pipelines

Postgres CDC, a SQL derivation and a Snowflake table in one catalog file · yaml

# flow.yaml; publish with:  flowctl catalog publish --source flow.yaml
captures:
  acmeCo/shop/postgres:
    endpoint:
      connector:
        image: ghcr.io/estuary/source-postgres:v3
        config:
          address: db.internal.example.com:5432
          database: shop
          user: flow_capture
          credentials:
            auth_type: UserPassword
            password: secret
    bindings:
      # discovery also generates the acmeCo/shop/orders collection and its schema
      - resource: { namespace: public, stream: orders }
        target: acmeCo/shop/orders

collections:
  # a derivation: kept up to date as new orders arrive
  acmeCo/shop/large-orders:
    schema:
      type: object
      properties:
        id: { type: integer }
        customer_id: { type: integer }
        total: { type: number }
      required: [id]
    key: [/id]
    derive:
      using:
        sqlite: {}
      transforms:
        - name: fromOrders
          source: acmeCo/shop/orders
          shuffle: any
          lambda: |
            select $id as id, $customer_id as customer_id, $total as total
            where $total >= 1000;

materializations:
  acmeCo/shop/snowflake:
    endpoint:
      connector:
        image: ghcr.io/estuary/materialize-snowflake:v4
        config:
          host: myorg-analytics.snowflakecomputing.com
          database: ANALYTICS
          schema: SHOP
          warehouse: COMPUTE_WH
          credentials:
            auth_type: jwt
            user: ESTUARY
            private_key: |
              -----BEGIN PRIVATE KEY-----
              ...
              -----END PRIVATE KEY-----
    bindings:
      - resource: { table: large_orders }
        source: acmeCo/shop/large-orders

Free, Cloud and Enterprise#

List prices from estuary.dev/pricing and the pricing docs, checked 6 October 2026.

	Free	Cloud	Enterprise
Data	Up to 10 GB a month	$0.50 per GB moved in or out	Volume discounts by contract
Connector instances	Up to 2	$100 a month each for the first 6, then $50 each (billed per task hour: $0.14, then $0.07)	By contract
Where it runs	Estuary’s public data planes	Estuary’s public data planes (US and EU)	Adds private and BYOC data planes (annual contract only)
Collection storage	Estuary’s trial bucket (20-day retention) or your own	Your own bucket, or the trial bucket	Your own bucket
SSO, PrivateLink, SOC 2 and HIPAA reports	No	No	Yes

Going over the free limits starts a 30-day trial of the Cloud plan; no credit card is needed.
For materializations, volume is what Estuary reads in, before reductions, so the bytes landing in the destination can be fewer than the bytes billed.

See it in a real stack

No architecture uses Estuary yet. Drop it into the playground and wire it up yourself.Open playground →

Where it came from2014–2025

David Yaffe and Johnny Graettinger had already built ad-tech infrastructure together at Invite Media, a demand-side platform later bought by Google. At their next startup, Arbor, founded in 2014 as a marketplace for people-based data, they kept hitting the same problem: data spread over many systems whose pipelines disagreed with each other and took a lot of staff to keep in line.

To fix it they built Gazette, a streaming broker that stores its data as regular files in cloud storage. A new application could backfill petabytes by reading files instead of hammering production brokers, and one hands-off engineer ran a service averaging 7 GB a second. LiveRamp bought Arbor in 2016, and Gazette was open-sourced afterwards, but it stayed a tool for experts.

In 2019 they founded Estuary to turn Gazette into a managed platform that, unlike the batch-oriented “modern data stack”, handled real-time and historical data in one pipeline. The hosted product launched in 2023, and an M13-led $17M Series A followed in October 2025.

Why it’s built this way

Journals stored as files in the customer’s bucket: Gazette’s founding idea: history serves from cheap object storage, so backfills never threaten live brokers, disks never run out, and any tool that reads files can read the data.
JSON documents with a key and a JSON schema: Databases, APIs and pub/sub messages all map onto documents, and a key plus reduction annotations let the runtime merge many updates to one entity before writing them.
Connectors as Docker images: Each image wraps the details of one external system and runs in isolation. The runtime speaks both the Airbyte connector specification and Estuary’s own low-latency gRPC protocols, whose definitions in go/protocols are the one part of the repository also offered under Apache 2.0.
Business Source License instead of an open-source licence: Anyone may read and run the code, but no one may sell it as a hosted data processing service before each version’s change date, which protects the managed product.

Timeline

2014
Gazette starts inside Arbor as an internal streaming framework
2016
LiveRamp acquires Arbor
2019
Yaffe and Graettinger found Estuary to build a platform on Gazette
2020
The Flow repository adopts the Business Source License in November
2021
FirstMark invests $7M
2023
Hosted, self-service product launches
2025
$17M Series A led by M13 in October

Sources26 · facts checked 6 October 2026

Improve this page on GitHub