pgpipe PostgreSQL change-data-capture, built for controlled scale — with the operations layer native leaves to you.
pgpipe streams row changes from one PostgreSQL database to another with strict source ordering, crash-safe checkpoints, a built-in dashboard, a dead-letter queue, and evidence-backed backlog health. Built for analytics replicas, disaster recovery, and zero-downtime database moves.
Free to use. No registration, no email wall.
# PostgreSQL -> PostgreSQL CDC
┌────────────────────────────────────────────┬────────┬────────┐
│ │ pgpipe │ native │
├────────────────────────────────────────────┼────────┼────────┤
│ Guided setup + preflight checks │ ✓ │ ✕ │
│ Web dashboard + Prometheus metrics │ ✓ │ ✕ │
│ Dead-letter queue + replay │ ✓ │ ✕ │
│ Automatic destination schema setup │ ✓ │ ✕ │
│ Safe structured DDL replication │ ✓ │ ✕ │
│ Data masking + transformation │ ✓ │ ✕ │
│ Verification + targeted repair │ ✓ │ ✕ │
│ Scheduled verification + repair previews │ ✓ │ ✕ │
└────────────────────────────────────────────┴────────┴────────┘
→ ordered CDC, plus the operational
layer native logical replication lacks.Built for production. Free to use.
Everything PostgreSQL's native logical replication is missing — observability, automatic schema setup, error handling, and a UI — without giving up the ordering guarantees that matter.
Scalable ordered apply
Preserves source transaction order while safe grouped commits amortize destination commit overhead. An opt-in hybrid writer accelerates eligible large groups; direct mode remains the compatibility path.
Automatic schema setup
Introspects the source and creates matching tables and primary keys on first run. Structured DDL safely applies supported creates, renames, additive changes, bounded backfills, and approved destructive changes; unsupported shapes fail closed for review.
Web dashboard & setup wizard
Five-step first-run flow, live table management, real-time lag and error visibility — no YAML wrestling required.
Strict, grouped, or parallel
Use singleton strict commits, group ordered source transactions, or apply in parallel for analytics workloads. Choose per pipeline, with direct mode as the compatibility path.
Dead-letter queue
Failed events land in a DLQ with full context — inspect, fix, and replay via REST API. You never silently lose data.
Prometheus & Kubernetes-ready
Prometheus metrics, evidence-backed backlog health, liveness/readiness probes, JWT auth, TLS, and graceful shutdown. Drop into your existing platform.
A proper streaming pipeline.
pgpipe decodes the WAL via the pgoutput v2 protocol, snapshots tables in parallel on first run, then streams changes with batching, backpressure, and crash-safe checkpoints.
Source PG
Logical replication slot + publication. PostgreSQL 14+ (15+ for wildcard tables).
Decoder
pgoutput v2 with streaming. Handles long-running transactions.
Pipeline
Batch → backpressure → DLQ on failure. Transaction order preserved.
Applier
Strict-ordered SendBatch pipelining. Sliding-window checkpoint.
Destination PG
Tables and primary keys created for you on first run; schema remapping supported.
From zero to replicating in under a minute.
The fastest way to try pgpipe is with Docker Compose. The dashboard opens at http://localhost:8080 with a setup wizard.
Try it with Docker
# Bring up source + destination + pgpipe
docker compose up -d --build
# Get the auto-generated dashboard password (admin / <random>)
docker compose exec pgpipe cat /var/lib/pgpipe/pgpipe-admin.password
# Or grep the full first-run banner from the logs:
# docker compose logs pgpipe | grep -A 6 "FIRST RUN — DASHBOARD"
# Open the dashboard and log in as admin with the password above
open http://localhost:8080
# Insert a row in source — watch it land in dest
docker compose exec source-db psql -U postgres source_db \
-c "INSERT INTO public.greetings (message)
VALUES ('hello from pgpipe');"
docker compose exec dest-db psql -U postgres dest_db \
-c "SELECT * FROM public.greetings;"Or run the binary directly
source:
host: "source-db.example.com"
database: "myapp"
user: "pgpipe"
password: "secret"
tables:
- schema: "public"
name: "users"
destination:
host: "dest-db.example.com"
database: "myapp_replica"
user: "pgpipe"
password: "secret"
# Then: pgpipe start -c pgpipe.yamlAnywhere you need PostgreSQL changes somewhere else.
Analytics replicas
Keep a reporting database in sync without taxing the primary. The destination schema is created for you on first run.
Disaster recovery
Continuously replicated standby in another region or provider, ready for failover.
Zero-downtime moves
Migrate between providers, versions, or clouds with a strict-ordered cutover and verifiable consistency.
Multi-tenant isolation
Replicate to a different schema name on the destination — useful for blue-green and per-tenant warehouses.
Distributed coherence
Stream Postgres changes to keep caches, search indexes, or microservices in sync (sink your own consumer on the WAL).
Compliance archives
Continuous replication into a retention-only, append-friendly destination.
We built pgpipe — and we run it for clients.
If you'd rather not operate the pipeline yourself, PG Horizon can deploy, monitor, and support pgpipe in your environment as part of our managed services.