PostgreSQL Fast and reliable Postgres change data capture

Stream data from Postgres directly to Kafka, Redis, and more. Replace complex tools like Debezium or pipelines like Flink.

Sequin ensures 100% delivery of database changes to sinks with strict ordering and exactly-once processing.

GitHub - Try now Slack Join Slack Discord Join Discord

Trusted by

Goldsky Scentbird Aviron Beeldi GoVisa Camper Mate

Killer features

Bring your database Sequin is not an extension. It works with any Postgres database version 12+.
Never miss a change Sequin ensures 100% delivery of database changes to sinks with strict ordering.
Exactly-once processing Sequin ensures exactly-once processing of database changes using idempotency keys.
Backfills Backfill sinks at any point in time. Run partial backfills to only replay specific rows.
Observability Sequin exposes a metrics endpoint using Prometheus and comes with a Grafana dashboard.

How it works

Sequin is a Docker image you can run next to your Postgres database. Sequin itself is built on Postgres and uses Postgres to store sink state. You'll configure sinks for one or more tables in your database, and Sequin will stream changes to your chosen destinations. 

┌───────────┐   WAL    ┌─────────┐     Exactly-once      ┌───────┐
│ Postgres  │ ═══════► │ Sequin  │ ═══════════════════►  │ Sink  │
└───────────┘          └─────────┘     processing        └───────┘

Supported destinations

Sequin supports streaming to a range of destinations including streaming platforms, queues, search indexes, and webhooks:

Streams & queues

  • Kafka
  • AWS SQS
  • GCP Pub/Sub
  • Redis Streams
  • NATS

Search & APIs

  • Elasticsearch
  • Typesense
  • Meilisearch
  • Webhooks
  • Redis Strings

Advanced processing pipeline

Transform and route your data with powerful processing capabilities: 

╔══════════════╗
║   Postgres   ║
╚══════════════╝
       │
       │   WAL
       ▼
╔════════════════════════════════════╗
║              Sequin                ║
║    ┌──────────┐   ┌──────────┐     ║
║    │  Enrich  │   │  Filter  │     ║
║    └──────────┘   └──────────┘     ║
║    ┌──────────┐   ┌──────────┐     ║
║    │Transform │   │  Route   │     ║
║    └──────────┘   └──────────┘     ║
╚════════════════════════════════════╝
       │
       │
       ▼
╔══════════════╗
║     Sink     ║
╚══════════════╝
Enrich Enrich changes by joining back to data in Postgres
Filters Write custom filters to include or exclude changes from Postgres
Transform Write custom code to shape messages to your desire
Routing Route messages to specific topics, endpoints, or indexes

Key use cases

Sequin works great for CDC use cases that require real-time data streaming and processing.

Audit logging Track, enrich, and record every change in your database for compliance or feature development.
Managing caches Keep application caches in sync with your database by streaming changes to Redis compliant caches.
Search indexing End-to-end tooling to warm search indexes like Typesense and Elasticsearch and keep them in sync with sub-second latency.
Streaming events Stream database changes as events for other services to consume using Kafka, SQS, Pub/Sub and more.

Why Sequin?

We all know Postgres is great for storing and querying data. But what about when you need to stream changes to other systems?

Postgres has limited support for change streaming. While Postgres supports logical replication, it's ephemeral and doesn't support features developers need like exactly-once processing, backfills, or delivery tracking.

Existing tools aren't much better. Debezium is complicated to setup, requires Kafka, and doesn't scale well. ETL tools like Fivetran have limited support for operational destinations and write changes in batches, not in real-time.

Sequin provides the fastest, simplest experience for streaming data from Postgres. It streams changes in real-time and doesn't require complex infrastructure to operate.

Sequin vs Debezium

Sequin

  • • Single Docker container
  • • No Kafka needed
  • • Built-in web console
  • • Operational simplicity
  • • Simple configuration

Debezium

  • • Complex setup with Kafka
  • • No built-in UI
  • • Vertical scale limits
  • • Complex configuration

Platform features

Start with the Sequin console, then use the CLI, sequin.yml and API to manage your sinks with end-to-end tooling.

Reliability & guarantees

  • 100% delivery guarantee with automatic retries and exponential backoff
  • Exactly-once processing
  • Strict ordering maintains database transaction order
  • Backfill from the beginning of the table or a specific point

Developer experience

  • Web console for sink management and monitoring
  • CLI and API for programmatic configuration
  • Configuration as code with sequin.yml files
  • Observability with a Prometheus endpoint