pgpipe PostgreSQL change-data-capture, at native speed — with everything native is missing.
pgpipe streams row changes from one PostgreSQL database to another in real time — with strict transaction ordering, a built-in web dashboard, a dead-letter queue, and Prometheus metrics. Built for analytics replicas, disaster recovery, and zero-downtime database moves.
Free to use for everyone in v1. No registration, no email wall.
# PostgreSQL -> PostgreSQL CDC
┌────────────────────────────────────────────┐
│ pgpipe native │
├────────────────────────────────────────────┤
Apply throughput on par ✓
Strict tx ordering ✓ ✓
Web dashboard + wizard ✓ ✗
Dead-letter queue + replay ✓ ✗
Prometheus metrics ✓ ✗
Auto schema setup on dest ✓ ✗
└────────────────────────────────────────────┘
→ native-speed CDC, plus the operational
layer native logical replication lacks.Built for production. Free in v1.
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.
Native-speed throughput
Matches native PostgreSQL logical replication on apply throughput, with strict per-transaction ordering and the same consistency guarantees — plus batching, backpressure, and crash-safe checkpoints.
Automatic schema setup
Introspects the source and creates matching tables (with primary keys) on the destination on first run — no manual pg_dump --schema-only. Runtime DDL replication (ALTER/CREATE/DROP) is on the roadmap, not yet shipped.
Web dashboard & setup wizard
Five-step first-run flow, live table management, real-time lag and error visibility — no YAML wrestling required.
Strict or parallel modes
Single-writer strict ordering for financial workloads, or parallel apply for analytics throughput. Pick per pipeline.
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
15 metrics out of the box, liveness/readiness probes, JWT auth, TLS, 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.