Fast, simple, and cost effective Postgres CDC

Replace clunky tools like Debezium by streaming data from Postgres to SQS, Kafka, and more.

Capture every insert, update, and delete

Bring your own (or any) Postgres database

Sink to streams and queues in real-time

Built in backfills, rewinds, and transforms

Open source, MIT license

Download Sequin

Read the docs →

YAML

CLI

Web Console

databases:
  - name: "sequin-playground"
    username: "postgres"
    password: "postgres"
    hostname: "sequin_postgres"
    database: "sequin_playground"
    port: 5432
    slot_name: "sequin_slot"
    publication_name: "sequin_pub"

sinks:
 - name: "kafka-sink"
    database: "sequin-playground"
    table_schema: "public"
    table_name: "accounts"
    destination:
      type: "kafka"
      hosts: "kafka1.example.com:9092,kafka2.example.com:9092"
      topic: "accounts-topic"
      username: "kafka-user"
      password: "kafka-password"

Guarantees

Capture & deliver every row

Sequin is a tool for change data capture (CDC) in Postgres. Sequin never misses an insert, update, or delete and delivers every (100%) change to your stream or queue.

Every change

Sequin uses logical replication to capture every change.

Learn more →

Every change

Sequin uses logical replication to capture every change.

Learn more →

Every change

Sequin uses logical replication to capture every change.

Learn more →

Strict ordering

Rows are delivered in a strict order based on PK or group ID.

Learn more →

Strict ordering

Rows are delivered in a strict order based on PK or group ID.

Learn more →

Strict ordering

Rows are delivered in a strict order based on PK or group ID.

Learn more →

100% Delivery

Every change in your database is delivered to your sink.

Learn more →

100% Delivery

Every change in your database is delivered to your sink.

Learn more →

100% Delivery

Every change in your database is delivered to your sink.

Learn more →

Key features

A new standard for CDC

Change data capture typically requires adding complicated dependencies, endless configuration, and blackbox runtimes. Sequin is tailored to Postgres to cut out the complexity and deliver helpful features.

SQL filters

Use WHERE clauses to route changes to your sinks.

function onRow(r) {
  switch (r.status) {
    case 'active': return JSON.stringify('running');
    case 'pending': return JSON.stringify('waiting');
    default: return JSON.stringify('unknown');
  }
}

function onRow(r) {
  switch (r.status) {
    case 'active': return JSON.stringify('running');
    case 'pending': return JSON.stringify('waiting');
    default: return JSON.stringify('unknown');
  }
}

Transforms

Transform messages with JS and Go

Rewind

Backfill and re-backfill at any time.

Observable

Trace every row from capture through to delivery

No infra needed

Built-in streaming

Out of the box, you can send database changes to a webhook sink or turn on a Sequin Stream. Both offer a durable, kafka-like stream with exactly-once processing guarantees with a simple HTTP interface.

//Sequin pushes rows to your HTTP endpoint

//Example lambda handler:

exports.order_handler = async (event) => {
  try {
    processOrder(event.data.action, event.data.record);
    return {
      //message will be ack'd
      statusCode: 200,
    };
  } catch (error) {
    console.error('Error:', error);
    return {
      //message will be nack'd & retried
      statusCode: 500,
    };
  }
};

Webhook sink

POST changes from your database to any HTTP endpoint. Built in retries and back-off.

Sequin Stream

Change Retention

Use cases

Streamline your use case

Sequin is designed to power every CDC use case. No need to master a new piece of infrastructure.

Create

Audit logs

Replicate

Tables

Maintain

Caches

// Automatically log all database changes with Sequin
async function logDatabaseChange(change) {
  await db.query(`
    INSERT INTO audit_logs (
      event_id,
      table_name,
      record_id,
      action,
      old_values,
      new_values
    ) VALUES ($1, $2, $3, $4, $5, $6)
  `, [
    change.id,
    change.metadata.table_name,
    change.record.id,
    change.action,
    JSON.stringify(change.changes),  // Previous values
    JSON.stringify(change.record)    // New values
  ]);
}

// Example: Capture an order status change
await logDatabaseChange({
  id: "evt_123",
  action: "update",
  metadata: { table_name: "orders" },
  record: { id: "order_123", status: "shipped" },
  changes: { status: "pending" }
});

Create an Audit Log

Track every change in your database with reliable, automated audit logs. Sequin captures the full history of modifications to your data, letting you meet compliance requirements, debug issues, and build powerful user features like activity feeds - all without modifying your application code.

Performance

Tuned to Postgres

Sequin uses logical replication to efficiently capture every change as it happens. If your database can handle the transaction, Sequin can deliver it with minimal overhead.

Messages / Second

P95 Latency (MS)

We're happy to host

Sequin Cloud

Fully managed service, we handle the infrastructure

Built to scale, tuned to support high message volume

Get started right away

Try Sequin Cloud

Widely supported

Works with your stack

Works with your framework

Sequin works with any Postgres database (version 12+) and supports a growing list of sinks to queues and streams. Sequin even supports native sinks (Webhooks and HTTP) so you can get started without any other infrastructure.