84 providers · 1 signed envelope · 1 normalized caller

The verified integration fabric for regulated, high-trust software.

NexusBridge unifies 84 builders, runtimes, hosts, DevOps, observability, iPaaS, and compliance systems behind one signed webhook envelope and one normalized outbound caller. Encrypted credentials, row-level isolation, deterministic execution, scheduled triggers, full audit logs, replayable runs, and a flow engine you can run on Cloudflare Workers or your own VPC.

Open the console Read the quickstart API reference

AES-256-GCM at rest
HMAC-SHA256 in transit
Postgres RLS
WCAG 2.1 AA UI
Self-host on your VPC

~/nexus · trigger.sh● live

$ TS=$(date +%s)
$ BODY='{"email":"ceo@acme.gov","plan":"enterprise"}'
$ SIG=$(printf "%s.%s" "$TS" "$BODY" \
    | openssl dgst -sha256 -hmac "$NEXUS_LOVABLE_WEBHOOK_SECRET" \
    | awk '{print $2}')

$ curl -sS -X POST \
    https://nexusbridge.app/api/public/hooks/universal/lovable/$FLOW \
    -H "content-type: application/json" \
    -H "x-nexus-timestamp: $TS" \
    -H "x-nexus-signature: sha256=$SIG" \
    -d "$BODY"

{ "run_id":   "f2a8c1…",
  "status":   "success",
  "verified": true,
  "duration_ms": 412,
  "provider": "lovable",
  "steps": [
    { "type": "bubble",         "ms": 118, "attempts": 1 },
    { "type": "provider_relay", "ms": 244, "attempts": 1, "target": "replit" },
    { "type": "provider_relay", "ms":  46, "attempts": 1, "target": "netlify" }
  ] }

84
verified providers
builders · runtimes · devops · ops · iPaaS · GRC
< 90 ms
median outbound latency
us-east-1 → vercel/iad1
99.98%
30-day execution success
non-user-error
0
plaintext secrets at rest
AES-256-GCM, key off-bundle

PLATFORM

One control plane for every backend you ship from a prompt

Universal connectors

Bearer, header API-key, Basic, query-string, deploy hooks, signed callbacks — one config shape, every provider.

Visual flow builder

Drag steps, map fields with mustache paths, branch on condition, transform JSON inline, test any step in isolation.

Deterministic engine

Sequential executor, exponential backoff, per-step error policy, idempotent retries, per-run trace.

Full observability

Every run is a row. Inputs, per-step outputs, attempts, durations, status — searchable, exportable, retryable.

Scheduled triggers

pg_cron pings an internal scheduler every minute. Run every N minutes, hourly, daily — with manual override.

Zero-trust webhooks

HMAC-SHA256 of <ts>.<body>, timing-safe compare, ±5 min replay window, per-provider secret rotation.

Provider relay

A single step type calls any connection. Swap Vercel for Netlify by changing one field — mappings keep working.

Deploy anywhere

Runs on Cloudflare Workers out of the box. Self-host on your own Postgres + edge runtime in under an hour.

OPERATE

Ship, verify, and replay every webhook you receive

The operations console gives your team the same signals we use to run the platform — live traffic, verification outcomes, and one-click replays — so incidents get diagnosed instead of guessed.

Live webhook activity

Dashboard widget with calls, failures, dedup hits, average and p95 latency per provider and per flow. Auto-refreshes every 30 s.

Open dashboard

Webhook log viewer

Filter by provider, status, and flow. Every verified inbound is a row with payload size, status, and duration.

Open logs

Replay verified payloads

Open any prior run and re-execute with the original body, or edit the JSON before replaying to reproduce a bug in seconds.

Replay a run

Send test webhook

Fire a signed sample request for any provider from the console. See verification, dedup, and step-by-step execution inline.

Send a test

Per-provider secret status

Settings page shows which providers are configured. Rotate secrets in place — old ciphertext is unrecoverable after commit.

Open settings

Auto-generated .env template

Help & Docs renders a live .env template from the provider registry: FLOW_WEBHOOK_SECRET, NEXUS_ENCRYPTION_KEY, and every NEXUS_*_WEBHOOK_SECRET.

View template

Command palette

⌘K inside the console to jump between flows, connections, runs, and settings. Every action reachable from the keyboard.

Launch console

Alerts & retries

One-click retry on failed runs. Route failures to Slack, PagerDuty, or incident.io through a flow — no separate alerting stack.

Open run logs

Audit trail

Append-only log of every connection create, update, rotation, flow edit, and manual run — keyed by user and workspace.

View activity

PROVIDERS

84 first-class peers, grouped by purpose

Every provider speaks the same signature scheme — HMAC-SHA256 of <timestamp>.<raw-body> with a ±5 minute replay window. Add a new one by dropping a route file; the console picks it up on next deploy.

BUILDERS

Builders & AI coding agents

Vibe coders, agentic IDEs, and no-code app platforms.

31 providers

Bubble.iobubble
Lovable.devlovable
Emergent.shemergent
Base44base44
Bolt.newbolt
Cursorcursor
Windsurfwindsurf
Softrsoftr
Blink.newblink
Taskade Genesistaskade
Totalumtotalum
8080.aieightyeighty
Clinecline
Claude Codeclaudecode
Grok Buildgrokbuild
Gemini CLIgeminicli
Codexcodex
GitHub Copilotgithubcopilot
Factoryfactory
Devindevin
Charliecharlie
cto.newctonew
Julesjules
ChatGPTchatgpt
Claudeclaude
v0 by Vercelv0
Zedzed
Codex MCPcodexmcp
Builder.iobuilderio
Figma Makefigmamake
Gemini Enterprisegeminienterprise

RUNTIME

Runtimes & hosting

Edge runtimes, PaaS, and container hosts.

13 providers

Replitreplit
Vercelvercel
Netlifynetlify
Renderrender
Railwayrailway
Cloudflare Workerscloudflare
Coolifycoolify
Dokploydokploy
DigitalOcean App Platformdigitalocean
Supabasesupabase
Bunbun
Deno 2.xdeno
Node.jsnodejs

DEVOPS

Source & DevOps

Repos, code review, CI, and release tooling.

7 providers

CodeRabbitcoderabbit
Qodoqodo
Tusktusk
GitHubgithub
GitLabgitlab
Trigger.devtriggerdev
Graphitegraphite

OBSERVABILITY

Observability & incident

Errors, metrics, on-call, product analytics.

7 providers

PagerDutypagerduty
Sentrysentry
Datadogdatadog
incident.ioincidentio
PostHogposthog
Honeybadgerhoneybadger
LangSmithlangsmith

AUTOMATION

Automation & work systems

iPaaS, workflow builders, and system-of-record apps.

16 providers

ClickUpclickup
Linearlinear
Snowflakesnowflake
Zapierzapier
Jirajira
Makemake
n8n (webhook)n8nhook
Fivetranfivetran
Google Calendargooglecalendar
IFTTTifttt
Pipedreampipedream
Latenodelatenode
Relay.apprelayapp
viaSocketviasocket
Integratelyintegrately
SureTriggerssuretriggers

GOVERNANCE

Security, compliance & time

Continuous compliance, cloud security, time tracking.

10 providers

Tactiqtactiq
Reclaim.aireclaimai
Vantavanta
Dratadrata
Aikido Securityaikido
Orca Securityorcasecurity
Kawach AIkawachai
Harvestharvest
Everhoureverhour
Jellyfishjellyfish

Universal inbound: POST /api/public/hooks/universal/<provider>/<flow_id> · per-provider legacy routes remain for native signature schemes.

ARCHITECTURE

One hub, two transports, zero plaintext on the wire


                  ┌─────────────────────────────────────────┐
                  │            Inbound webhook              │
                  │  POST /api/public/hooks/universal/...   │
                  │  x-nexus-signature  x-nexus-timestamp   │
                  └────────────────────┬────────────────────┘
                                       ▼
   ┌─────────────────────────────────────────────────────────────────┐
   │                          NexusBridge hub                        │
   │  ┌────────────┐  ┌────────────┐  ┌────────────┐  ┌───────────┐  │
   │  │  Verify    │─▶│  Load flow │─▶│  Executor  │─▶│  Logger   │  │
   │  │  HMAC + ts │  │  + creds   │  │  + retries │  │ flow_runs │  │
   │  └────────────┘  └─────┬──────┘  └─────┬──────┘  └─────┬─────┘  │
   │       ▲                │                │               │       │
   │       │           ┌────▼──────┐    ┌────▼─────┐    ┌────▼─────┐ │
   │       │           │ AES-256   │    │ provider │    │ Postgres │ │
   │       │           │   GCM     │    │  relay   │    │  + RLS   │ │
   │       │           └───────────┘    └────┬─────┘    └──────────┘ │
   │       │                                 │                       │
   │  ┌────┴────┐                            ▼                       │
   │  │ pg_cron │                ┌────────────────────────┐          │
   │  │ ticker  │                │ Outbound: 84 providers │          │
   │  └─────────┘                │  Bearer · Header · ... │          │
   │                             └────────────────────────┘          │
   └─────────────────────────────────────────────────────────────────┘

The hub is a stateless TanStack Start app. Every inbound request is verified against a per-provider secret before any database read. The executor loads the flow definition, decrypts only the credentials the run needs, and runs steps sequentially with deterministic retry semantics.

Outbound calls go through a single callProvider() helper that normalizes Bearer, header, Basic, and query-string auth, then maps response bodies into the run context so the next step can reference them.

Credentials never leave the server. Browser sees masked previews only.
±5 min replay window on every inbound webhook.
pg_cron hits an internal scheduler endpoint every minute.
Every run writes input, per-step output, retries, and duration to flow_runs.
provider_relay step type makes any connection callable from any flow.

FLOW ENGINE

Deterministic executor, no surprises

Sequential executor. Condition steps gate the next step (stop_success / stop_failure / skip_next).
Per-step error policy: stop, continue, or retry with exponential backoff (500 ms × 2ⁿ).
provider_relay calls any connection — Bubble → Lovable → Netlify in three rows.
Mustache templating across the run context: {{trigger.x}}, {{steps.step_N.body.y}}.
Test any step in isolation with a sample payload before saving.
Optional delegation to a self-hosted n8n instance per flow (n8n Mode).

step types

max retries

60 s

timeout / call

500 ms

backoff base

±300 s

replay window

60 s

schedule tick

{
  "name": "Lovable signup → enrich → fan-out",
  "steps": [
    { "type": "bubble", "config": {
        "connection_id": "bub_…", "data_type": "user",
        "operation": "search",
        "mappings": [{ "target": "email", "expression": "{{trigger.email}}" }] }},
    { "type": "provider_relay", "config": {
        "connection_id": "ep_replit_ai",
        "method": "POST", "path": "/enrich",
        "use_mappings": true,
        "mappings": [
          { "target": "email",       "expression": "{{trigger.email}}" },
          { "target": "bubble_user", "expression": "{{steps.step_1.body.results.0}}" } ],
        "error_policy": { "on_error": "retry", "retries": 3 } }},
    { "type": "condition", "config": {
        "expression": "{{steps.step_2.body.score}}",
        "operator":   ">",
        "value":      "0.8",
        "true_action":  "next",
        "false_action": "stop_success" }},
    { "type": "provider_relay", "config": {
        "connection_id": "ep_netlify_notify",
        "method": "POST", "path": "/build_hooks/abc",
        "body": "{ \"trigger_title\": \"score={{steps.step_2.body.score}}\" }" }}
  ]
}

SECURITY

Encrypted at rest, signed in transit, scoped by RLS

AES-256-GCM at rest

All secrets pass through crypto.server.ts. Wire format: iv ‖ tag ‖ ciphertext. Key lives in NEXUS_ENCRYPTION_KEY — never bundled, never logged, never sent to the browser.

Signed webhooks

Every inbound request carries x-nexus-signature + x-nexus-timestamp. We HMAC-SHA256 <ts>.<rawBody>, timing-safe compare, reject anything outside ±5 min.

Row-Level Security

flows, flow_runs, connections, and audit tables carry owner-scoped policies. Even with a stolen token, you only see your own data.

Secret rotation

rotate*Secret server functions re-encrypt the new value and overwrite ciphertext atomically. Old plaintext is unrecoverable from that point forward.

Append-only audit log

Every connection create, update, rotation, flow edit, and manual run is written to an immutable audit trail keyed by user and workspace.

Dedup & replay defense

Delivery IDs are stored per provider with per-flow TTL. Duplicate deliveries return the original run’s outcome without side effects.

COMPLIANCE

Aligned with the controls your auditors already ask for

SOC 2 Type IIOn roadmap

Controls mapped; observability, access reviews, and change management in place.

HIPAAReady posture

BAA-eligible on your VPC with your own KMS. PHI never leaves your tenant.

GDPRAligned

Data export + delete server functions; EU-residency self-host option.

FedRAMPAligned controls

Least-privilege keys, signed transport, audit trail, RBAC — mapped to NIST 800-53 Moderate.

WCAG 2.1 AAVerified UI

Keyboard navigable, screen-reader labelled, AAA contrast on body copy, motion-reduced by default.

AI-UDIT · GOVERNANCE TELEMETRY

Stream every step to Ai-udit for policy enforcement and evidence

Turn on Ai-udit in Settings and NexusBridge fans every flow run and step execution to your Ai-udit tenant over a signed, non-blocking webhook. Deliveries survive circuit trips, honor field-level redaction, and land in your audit console with a per-attempt trail.

HMAC-signed delivery

HMAC-SHA256(<ts>.<body>) using your Ai-udit signing secret, timing-safe verified on Ai-udit's side.

Retries + backoff

Up to 5 attempts with exponential backoff (2ⁿ × 500 ms, capped at 5 min). Every attempt logged.

Circuit breaker

20 consecutive failures trip the breaker for 10 min. Dashboard banner surfaces the trip; reset from Settings.

Idempotent

x-aiudit-event-id = deterministic UUID per event. Safe to replay.

Event envelope

Every event uses the same JSON envelope. event_type distinguishes flow-level and step-level events; the payload is scoped to the event.

flow.run.started · flow.run.completed · flow.run.failed
step.completed · step.failed · step.retried
Payloads > 256 KB are replaced with a reference + summary — never truncated silently.
Redaction: toggle redact_inputs, redact_outputs, redact_headers; custom PII regexes applied before signing.

POST https://<your-tenant>.ai-udit.app/ingest
content-type:        application/json
x-aiudit-timestamp:  1720893412
x-aiudit-event-id:   e7f2c8a1-6b4d-4e0a-9f11-c3d5a9b04e11
x-aiudit-signature:  sha256=9c2f1a…

{
  "event_type": "step.completed",
  "occurred_at": "2026-07-13T02:16:52.041Z",
  "tenant": { "workspace_id": "ws_…", "environment": "prod" },
  "flow":   { "id": "flw_…", "name": "Lovable signup → enrich" },
  "run":    { "id": "run_…", "trigger_provider": "lovable" },
  "step":   { "index": 2, "type": "provider_relay",
              "target_connection": "ep_replit_ai",
              "attempts": 1, "duration_ms": 244,
              "status": "success" },
  "payload": {
    "input":  { "email": "[REDACTED:email]" },
    "output": { "score": 0.86, "segment": "smb" }
  },
  "governance": { "redacted_fields": ["input.email"],
                  "payload_bytes":   612 }
}

HTTP headers on every outbound Ai-udit delivery
Header	Value	Purpose
x-aiudit-timestamp	unix seconds	Signed alongside body; ±5 min replay window on Ai-udit side
x-aiudit-signature	sha256=<hex>	HMAC-SHA256 of <ts>.<raw-body> with your signing secret
x-aiudit-event-id	uuid v4 (deterministic)	Idempotency key — Ai-udit deduplicates on this
x-aiudit-attempt	1..5	Which retry attempt this delivery represents
x-aiudit-schema	nexusbridge.telemetry/v1	Envelope version; bump on breaking change
authorization	Bearer <api-token>	Optional bearer token when your tenant requires auth

state machine (aiudit_events)

  queued ──▶ sent            (2xx from Ai-udit)
     │
     ├────▶ failed  ──▶ retry (attempts < 5, backoff)
     │                    │
     │                    └──▶ dead (attempts = 5)
     │
     └────▶ dead     (payload rejected / redaction impossible)

state machine (circuit breaker, per workspace)

  closed ──▶ open       (20 consecutive failures)
     ▲         │
     │         ▼
     └── half_open  ──▶ closed   (next 3 succeed)
                    ──▶ open     (any fail)   [cooldown 10 min]

Operator controls

Dashboard widget: 24 h delivery volume, success rate, breaker state, dead-letter count.
Explorer at /app/aiudit — filter by state, drill into per-attempt timeline, requeue, mark dead.
Bulk actions: retry all failed in last 24 h, purge sent, reset circuit.
Hourly purge (pg_cron) enforces per-workspace retention_days.
Append-only aiudit_delivery_log — every attempt keeps response status, body, duration, timestamp.
Signing secret + API token encrypted with the same AES-256-GCM path as connection credentials.

max attempts

500 ms

backoff base

5 min

backoff cap

20 fails

breaker threshold

10 min

breaker cooldown

256 KB

payload guard

aiudit_settings

Per-workspace destination + policy: webhook_url, api_token, signing_secret, retention_days, redact_*, pii_patterns, circuit_state.

aiudit_events

Outbound queue: event_type, payload, state (queued/sent/failed/dead), attempts, next_attempt_at, idempotency_key, response_status.

aiudit_delivery_log

Append-only per-attempt trail: attempt_number, response_status, response_body, duration_ms, attempted_at.

All three tables are RLS-scoped to the owning workspace. Ai-udit itself never sees other tenants' rows, and NexusBridge never persists Ai-udit responses beyond the audit trail.

OBSERVABILITY

Every byte of every run is a row

Searchable run log: full-text over input/output JSON, filterable by status, flow, provider, time range.
Built-in charts: runs/day, success-rate trend, slowest steps, retry density.
One-click retry on failed runs — re-executes with the original input payload.
Per-step trace: attempts, transport status, latency, mapping diff.
CSV / JSON export for compliance, BI, or back-pressure replay.
Dashboard widgets: 24 h volume, p50 / p95 / p99 latency, error rate by provider.

SELECT
  provider,
  date_trunc('hour', started_at) AS bucket,
  count(*)                        AS runs,
  count(*) FILTER (WHERE status = 'success') AS ok,
  percentile_cont(0.50) WITHIN GROUP (ORDER BY duration_ms) AS p50,
  percentile_cont(0.95) WITHIN GROUP (ORDER BY duration_ms) AS p95,
  percentile_cont(0.99) WITHIN GROUP (ORDER BY duration_ms) AS p99
FROM flow_runs
WHERE owner_id = auth.uid()
  AND started_at > now() - interval '24 hours'
GROUP BY provider, bucket
ORDER BY bucket DESC;

ENTERPRISE

Built for teams shipping in production

SSO & SCIM-ready

Google, GitHub, and OIDC providers today. SAML + SCIM provisioning on the enterprise plan.

Workspaces & roles

Per-workspace connections, flows, and audit log. Owner / admin / operator / viewer roles enforced via RLS.

Bring your own cloud

Self-host the hub on Cloudflare, Fly.io, or any edge runtime. Point at your own Postgres + KMS.

SLA & dedicated support

99.95% uptime SLA, 1-hour response on Sev-1, named Slack channel, quarterly architecture reviews.

Custom providers

Need an internal API? The connector schema is open — ship a new provider in an afternoon.

Public-sector ready

Data residency pinning, FedRAMP-aligned controls, and an audit trail your GRC team can subpoena directly from Postgres.

Talk to sales See it in 60 seconds

QUICKSTART

Trigger a flow from anything in one curl

# 1. Mint the signature
TS=$(date +%s)
BODY='{"email":"hello@example.com","plan":"pro"}'
SIG=$(printf "%s.%s" "$TS" "$BODY" | openssl dgst -sha256 -hmac "$NEXUS_LOVABLE_WEBHOOK_SECRET" -hex | awk '{print $2}')

# 2. POST to the universal endpoint — provider chosen by URL segment
curl -sS -X POST "https://nexusbridge.app/api/public/hooks/universal/lovable/$FLOW_ID" \
  -H "content-type: application/json" \
  -H "x-nexus-timestamp: $TS" \
  -H "x-nexus-signature: sha256=$SIG" \
  -d "$BODY"

# →  { "run_id": "…", "status": "success", "verified": true, "duration_ms": 412, "provider": "lovable" }

Same envelope for every provider — swap the URL segment and the secret. Per-provider legacy routes still accept native signature schemes for back-compat.

API SURFACE

The whole platform in a dozen endpoints

Public HTTP endpoints exposed by NexusBridge
Method	Path	Purpose
POST	/api/public/hooks/universal/:provider/:flow_id	Signed inbound trigger (any provider)
POST	/api/public/hooks/:provider	Native per-provider webhook
POST	/api/public/hooks/flow-scheduler	Internal pg_cron tick
POST	/connections	Create encrypted connection
POST	/connections/:id/test	Round-trip credential test
POST	/connections/:id/rotate	Atomic secret rotation
POST	/flows	Create flow definition
POST	/flows/:id/run	Manual execution with input payload
POST	/flows/:id/steps/:n/test	Run a single step in isolation
GET	/flow_runs?status=&flow_id=&q=	Query run history with full-text search
POST	/flow_runs/:id/retry	Replay verified payload through the flow
GET	/analytics/webhooks	Roll-up metrics powering the dashboard widget

CHANGELOG

Recent releases

v1.9

Jul 2026

17 new providers land — automation (IFTTT, Pipedream, Latenode, Relay.app, viaSocket, Integrately, SureTriggers, Tactiq, Reclaim.ai), security & compliance (Vanta, Drata, Aikido, Orca, Kawach AI), and time tracking (Harvest, Everhour, Jellyfish). NexusBridge now unifies 84 first-class peers.

v1.8

Jul 2026

Webhook log viewer + one-click replay of verified payloads. Send-test-webhook from the console. Dashboard webhook activity widget with per-provider and per-flow rollups.

v1.7

Jun 2026

Settings page for per-provider secret status. Auto-generated .env template in Help & Docs, driven from the provider registry.

v1.6

Jun 2026

Command palette (⌘K). Onboarding tour. Fine-grained roles enforced via RLS.

v1.5

Jun 2026

Supabase added as a first-class provider. Direct Data API, Auth Admin, and Edge Function calls from any flow.

v1.4

Jun 2026

Universal inbound webhook envelope. Bolt.new, Cursor, Windsurf, Softr added.

v1.0

Apr 2026

Initial release: Bubble, Replit, Lovable, Emergent. AES-256-GCM, RLS, flow_runs.

ACCESSIBILITY

Federal accessibility standards, honored by default

WCAG 2.1 AA verified

Body copy exceeds AAA contrast on the deep-navy surface. Interactive controls stay above 4.5:1 in every state.

Full keyboard operability

Visible focus rings, logical tab order, a skip-to-content link, and a command palette for zero-mouse operation.

Screen-reader labelled

Semantic landmarks, single <main>, `aria-label` on every icon-only control, and `aria-live` on status changes.

Ship the integration layer your auditors will actually approve.

Connect a provider, draw a flow, paste a curl. Be in production by lunch — with the paper trail to prove it.

Open the console Talk to sales