Onboard any customer's system with a config file, not a sprint.
You sell vertical B2B software, and every enterprise deal stalls on the same question — “can you pull data from our system?” Siphon turns each integration into a declarative connector spec, runs it on a durable engine, and drops a white-labeled widget into your app. Customers connect their own systems, and you ship integrations in days, not sprints — no data-engineering hire required.
14-day trial · no credit card · priced per connection
resources: - key: workorders canonicalEntity: WorkOrder fetch: method: POST path: /workorders/v1/query pagination: { strategy: offset } enrich: - id: asset, path: /assets/{{ record.assetId }} sync: { detectDeletions: true }
634 connectors in the catalog across 16 categories — or import any Airbyte manifest in one command
Integrations are where B2B roadmaps stall.
The industry default, not a Siphon claim — the point is that it's undifferentiated work every vertical SaaS team rebuilds.
A file in, a durable pipeline out.
Declare it, don't code it
Auth, pagination, an enrichment DAG, a JSONata transform, validation, and typed output — all YAML. Author it in the visual builder or draft it with AI from a sample response.
Journaled, resumable, isolated
Every sync runs on Restate: page-by-page journaling, crash-resume mid-backfill, retry + rate-limiting, SSRF-guarded egress, per-tenant isolation.
Observable to the request
Every HTTP request, response, retry, and transform — redacted and retained. Support answers 'why is this record missing' from a plain error list (or one-click AI Run Doctor), never a terminal.
634 connectors, one import away.
Browse a catalog mirrored from Airbyte + Sim across 16 categories — 7 live-verified, 139import-ready drafts, the rest scaffold on pick. Import any Airbyte manifest to a draft in one command, then land records in your customer's own warehouse.
Bring-your-own warehouse — no lock-in
Land typed, deduped records straight in your customer's Postgres or SQL Server (two-stage raw→final), or push a webhook. The data lives in their warehouse, not ours. Define a destination once, reuse it across every connection.
See exactly what maps where
A per-resource mapping view shows the typed columns Siphon writes, the transform that produces them, and the full-record data column — so you know the target schema up front.
One shape, not N vendor shapes
Map every source to a versioned Asset / WorkOrder model with a live conformance score, so downstream consumers get a single schema.
List endpoints return skeletons.
A real integration needs N follow-up calls per record — cached, dependency-ordered, and failure-isolated. Siphon's enrich DAG runs them concurrently within their level; a node that fails with onError: continue is observable, not silent.
Connectors break quietly. Siphon doesn't let them.
Every source eventually drifts, throttles, or drops records. Siphon turns silent data-quality decay into an alert and a diff — so you catch it before your customer files the ticket.
Source shape, watched
Siphon fingerprints each source's record shape every run and flags the moment a field is renamed, dropped, or retyped — with the exact added / removed / retyped diff in the app, not just an alert.
Gone at the source, gone downstream
On a complete fetch, a record that vanished is detected and tombstoned in the warehouse — with a completeness guard so a capped page never mass-deletes.
Is it working, right now?
See healthy / degraded / failing / overdue at a glance across your whole fleet — with change detection, auto-invalidation when a spec changes, and one-click backfill from any date.
Your customer connects their own system.
Drop a connection-scoped widget into your product with a short-lived token — it can only ever see its own connection. Set your logo and accent once, and every embed is yours. Your customers never see Siphon.
import { ConnectionWidget } from "@siphon/embed/react"
<ConnectionWidget
baseUrl="https://app.yourhost.com"
token={token}
/>Know it broke before your customer does.
Push to a channel
Post failures, schema drift, and expired auth to Slack via an Incoming Webhook — opted-in per event, so the channel stays signal, not noise.
Or into your own app
Eight signed event types (run.failed, records.deleted, schema.drift, connection.auth_expired, …) to your endpoint — every delivery logged and one-click redeliverable.
Built for the security questionnaire.
Enterprise buyers gate on this section — so it's built in, not bolted on. Answer the hard questions with controls that already ship.
Envelope encryption
Every per-connection credential is envelope-encrypted at rest; the plaintext never touches config.
SSRF egress control
Outbound targets are resolved and re-validated on every redirect hop; private and loopback ranges are refused.
Credential redaction
Secrets are redacted before any request or response is persisted to the call log.
Per-tenant isolation
Org-scoped at the service layer, with row-level-security policies and a non-superuser runtime role for defense in depth.
Audit trail
Every publish, connection change, credential rotation, and key issue/revoke is logged with the actor and timestamp — a per-org activity log for your reviews, with per-org data retention you control.
Roles & workspaces
Org owner / admin / member roles plus per-workspace admin/viewer grants scope who can publish connectors and manage which customers' connections.
Priced per connection, not per API call.
Deep enrichment shouldn't cost more. Start on a 14-day trial.
- ✓ 5 active connections
- ✓ 1 workspace
- ✓ Every connector feature
- ✓ Community support
- ✓ 25 active connections
- ✓ 3 workspaces
- ✓ Bring-your-own warehouse
- ✓ Email support
- ✓ 100 active connections
- ✓ 10 workspaces
- ✓ AI Run Doctor + Spec Assist
- ✓ Priority support
- ✓ Unlimited connections & workspaces
- ✓ SSO + audit log
- ✓ SLA + dedicated support
- ✓ Custom contract
Write a declarative spec — auth, pagination, enrich, transform, validate, output — in the visual builder, by importing an Airbyte manifest, or by drafting from a sample response with AI. Then lint it and publish.
Schema-drift detection fingerprints the source shape every run and alerts you the moment a field is renamed, dropped, or retyped — before your data quality degrades.
Every run is journaled per page on the durable engine, so a crash resumes from the last committed page rather than restarting the backfill.
In your customer's own Postgres or SQL Server warehouse (typed + deduped), or pushed to a webhook — define a destination once and reuse it.
Every per-connection secret is envelope-encrypted at rest and redacted from logs; the plaintext never touches config.
Org roles (owner / admin / member) plus per-workspace admin/viewer grants control who can publish connectors, manage connections, and rotate credentials — give teammates and customers exactly the access they need, no more.
Yes — publishes, connection changes, credential rotations, and key issue/revoke are recorded with the actor and timestamp in a per-org activity log, and you set data retention per org.
Stop losing deals to “does it connect to X?”
Author a connector once, onboard every customer on it, and turn integration backlog into a config file. Production-grade from day one — durable runs, schema-drift alerts, and security-questionnaire-ready controls.