The fastest Postgres change data capture
(that's actually correct)
Stream data from Postgres directly to Kafka, Redis, and more. Replace complex tools like Debezium and consolidate workflows.
Capture every insert, update, and delete
Works with any Postgres database:
Real-time sink to streams, queues, and more:
Built-in backfills, filters, and transforms
Open source, MIT license
YAML
CLI
API
databases:
- name: "sequin-playground"
username: "postgres"
password: "postgres"
hostname: "sequin_postgres"
database: "sequin_playground"
port: 5432
slot_name: "sequin_slot"
publication_name: "sequin_pub"
tables:
- table_name: "accounts"
table_schema: "public"
sort_column_name: "updated_at"
sinks:
- name: "kafka-sink"
database: "sequin-playground"
table: "public.accounts"
destination:
type: "kafka"
hosts: "kafka1.example.com:9092"
topic: "accounts-topic"
username: "kafka-user"
password: "kafka-password"
sasl_mechanism: "plain"
# 1. Install the CLI using Homebrew
$ brew install sequin
# 2. Apply the YAML config file
$ sequin config apply
Applying changes...
✓ Created database connection: sequin-playground
✓ Added table tracking for public.accounts
✓ Created Kafka sink: kafka-sink
Apply complete! Resources: 2 added, 0 changed, 0 destroyed.
# 3. Check the health of the kafka sink
$ sequin sink health kafka-sink
Sink: kafka-sink
Status: Healthy
Messages processed (24h): 5,127,394,342
Average latency: 41ms
curl -X POST
https://api.sequinstream.com/v1/sinks
-H "Content-Type: application/json"
-H "Authorization: Bearer YOUR_API_TOKEN"
-d '{
"name": "kafka-sink",
"database": "sequin-playground",
"table": "public.accounts",
"destination": {
"type": "kafka",
"hosts": "kafka1.example.com:9092",
"topic": "accounts-topic",
"username": "kafka-user",
"password": "kafka-password",
"sasl_mechanism": "plain"
}
}'
Performance
Industry-leading performance
Sequin is tuned to Postgres to provide industry-leading performance. If your database can handle the transaction, Sequin will deliver it with minimal overhead. Read more on our benchmarking page →
40,000+
messages per second
40+ MB/s
bandwidth throughput
55ms
average latency
Real-time CDC
Postgres to Kafka
Latency at 10,000 operations / second
6.8x
Sequin · 55 ms
AWS MSK Debezium · 253 ms
Fivetran · 5 min
AirByte · 1+ hours
Guarantees
Capture & deliver
every change
Simplify your architecture by building on strong guarantees. Sequin never misses an insert, update, or delete and delivers every (100%) change to your stream or queue.
Use cases
Streamline your use case
Sequin is designed to power every change data capture use case. No need to master a new piece of infrastructure.
Trigger
Workflows
Create
Audit logs
Sync
Search
Replicate
Tables
Send
Webhooks
Maintain
Caches
// Handle order events and trigger workflows
async function handleOrderWorkflow(change) {
// Log the change
await logDatabaseChange(change);
// Only process new orders
if (change.metadata.table_name === 'orders' && change.action === 'insert') {
const order = change.record;
// Update inventory for each item
for (const item of order.items) {
await updateInventory(item.product_id, -item.quantity);
}
}
}
// Update inventory levels and check thresholds
async function updateInventory(productId, quantityChange) {
const { rows } = await db.query(
'UPDATE inventory SET quantity = quantity + $1 WHERE product_id = $2 RETURNING quantity',
[quantityChange, productId]
);
// Trigger alert if inventory is low
if (rows[0].quantity <= 10) {
await db.query(
'INSERT INTO inventory_alerts (product_id, current_quantity) VALUES ($1, $2)',
[productId, rows[0].quantity]
);
}
}Trigger code when Postgres rows change
Build automated workflows from database changes. Sequin captures and delivers every change in your database so you can break monolithic processes into automated, event-driven workflows.
// 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
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.
// Replicate tables across databases with Sequin
async function replicateChange(change) {
// Handle inserts, updates, and initial data
if (change.action !== 'delete') {
await db.query(`
INSERT INTO products_replica (
id,
name,
price,
updated_at
) VALUES ($1, $2, $3, $4)
ON CONFLICT (id) DO UPDATE SET
name = EXCLUDED.name,
price = EXCLUDED.price,
updated_at = EXCLUDED.updated_at
`, [
change.record.id,
change.record.name,
change.record.price,
new Date()
]);
} else {
// Handle deletes
await db.query('DELETE FROM products_replica WHERE id = $1', [change.record.id]);
}
}
// Example: Replicate a product update
await replicateChange({
action: "update",
record: { id: "prod_123", name: "Coffee Maker", price: 99.99 }
});Replicate Tables
Seamlessly replicate data between databases in real-time. Sequin handles the complex parts of database replication - like race conditions, schema transformations, and failure recovery - so you can sync your data with just a few lines of code.
// Keep Redis cache in sync with your database
async function updateCache(change) {
const cacheKey = `products:${change.record.id}`;
if (change.action !== 'delete') {
// Update cache for inserts/updates
await redis.set(cacheKey, JSON.stringify({
...change.record,
cached_at: new Date()
}));
} else {
// Remove deleted items from cache
await redis.del(cacheKey);
}
}
// Example: Cache product update
await updateCache({
action: "update",
record: { id: "prod_123", name: "Coffee Maker", price: 99.99 }
});Maintain Cache
Keep your caches in sync with your database. Sequin streams changes directly to Redis, Memcached, or your caching layer of choice - eliminating cache inconsistencies and the complexity of manual cache invalidation.
async function createWebhookSubscription(userId, webhookUrl) {
// 1. Create HTTP endpoint
const endpointResp = await axios.post(
`${SEQUIN_API_BASE}/destinations/http_endpoints`,
{
name: endpointName,
url: webhookUrl,
},
);
// 2. Create webhook sink for the notifications table
const sinkResp = await axios.post(
`${SEQUIN_API_BASE}/sinks`,
{
database: "postgres",
table: "public.notifications",
filters: [
{ column_name: "user_id", operator: "=", comparison_value: userId.toString() },
],
destination: { type: "webhook", http_endpoint: endpointName },
actions: ["insert", "update", "delete"],
},
);
}Send User's Webhooks
Use the Sequin Management API and Webhook Sink to power user-facing webhooks. Sequin will deliver every change, handle errors, retries, and comes with built in monitoring.
databases:
- name: "prod-db"
username: "postgres"
password: "postgres"
hostname: "my-database-instance.abcd1234wxyz.us-east-1.rds.amazonaws.com"
database: "prod"
port: 5432
slot_name: "sequin_slot"
publication_name: "sequin_pub"
sinks:
- name: "typesense-sink"
database: "prod-db"
table: "public.products"
destination:
type: "typesense"
endpoint_url: "https://your-typesense-server:8108"
collection_name: "products"
api_key: "your-api-key"
batch_size: 1000
timeout_seconds: 5Sync Search Indexes
Replicate your database changes to full-text search platforms like ElasticSearch, TypeSense, Algolia, and more. Sequin will ensure every change is delivered - including deletes.
Features
Setting a higher standard
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.
def transform(action, record, changes, metadata) do
first_name = record["first_name"]
last_name = record["last_name"]
full_name = first_name <> " " <> last_name
%{ full_name: full_name }
endTransforms
Transform messages.
Web Console
A rich web console to easily manage and observe sinks as you build.
Backfill
Backfill at any time.
Observable
Trace every row from capture through to delivery.
Prometheus Metrics + Grafana Dashboard
Plug Sequin into your monitoring and metrics.
Integrations
Drop into your stack
Sequin works with any Postgres database (version 14+) 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.
AnyPostgres
Stream & Queues
Caches & Search
Testimonials
Loved by developers
"Sequin was incredibly easy to setup and allowed us to quickly establish our real-time knowledge base pipeline. It just works - letting our engineers focus on building features instead of maintaining complicated data infrastructure."
Jinyuan L.
Lead AI Engineer
"Sequin solved our activity feed scaling challenges. Its use of logical replication means our application commits changes faster, as it no longer waits for synchronous audit log writes. With features like transaction annotations, we're able to capture rich context like exactly who made each change. I love what these guys are doing!"
Yahya J.
Lead Developer
"Sequin allows us to capture millions of product changes in our database and replicate them to Typesense, ensuring perfectly accurate user searches. Set it up once and forget it—highly recommend!"
Matheus L.
CTO
"Sequin has become our central event source, reliably streaming database changes to power our Slack alerts, Resend emails, and in-app notifications. Having one dependable source has streamlined our entire architecture."
Johannes K.
CTO
"Sequin’s deliverability guarantees provide an abstraction of an entire class of problems for us. If there’s been an insert, update, or delete - we know our dependent services will get the event."
Mathew N.
Technical Lead
Read more…
Pricing
Plans and pricing
Sequin itself is built on Postgres to provide the most efficient, cost effective change data capture on the market.
Free
For individuals and hobby projects
$0
/mo
Self-host Sequin on your infra with community support
The fastest CDC from Postgres to streams and queues
Docker container to run Sequin
Full-featured with transforms, backfills, CLI, and web console
Community Discord support
Cloud
For teams scaling Sequin
Starting at
$30
/mo
Get started right away with a perfectly tuned deployment. Pay-as-you-grow.
Includes 2 GB / month throughput, then pay-as-you-go.
High-availability with autoscaling
Organization with multi-region accounts
Dedicated support channels
Managed
For enterprise and mission critical
Tailored
A single-tenant deployment of Sequin within your cloud with full support & SLAs.
A custom plan tailored to your requirements
White-glove implementation support
SAML, SSO, and compliance
24 x 7 production support with SLAs
Join the community
Open source, in production
Sequin makes change data capture easier than ever. See what developers are saying and join the community to get started.
Community
Join our Discord server or Slack community to get support, and discuss your use case.
GitHub
Stay up to date with our project, see what's in our latest release, and track what's coming next.
Subscribe to our changelog!
No spam, guaranteed.
©️ 2025 Sequin Labs, Inc. All rights reserved.