Connect any org
OAuth into Salesforce and subscribe to Change Data Capture - tokens encrypted at rest, refreshed automatically.
SFHooks streams Change Data Capture events and pushes them to your endpoints - HMAC-signed, retried until they land, and observable to the millisecond. No polling. No glue code.
14-day free trial · $0 today, card required · cancel anytime
The hard parts of event delivery - reliability, trust, and visibility - handled for you, so a missed Salesforce change never becomes a 2am incident.
At-least-once delivery with jittered retries up to 31 attempts. When an endpoint is down, events wait in a dead-letter queue - replay them in one click once it's back.
Every payload is HMAC-SHA256 signed. Verify it in four lines, reject anything that doesn't match, and rotate signing secrets with zero dropped deliveries.
Live success rate, p95 latency, and per-webhook health. Every event keeps its full delivery history - payload, attempts, and response codes - for fast debugging.
SFHooks sends a timestamp and an X-SFHooks-Signature header with each request. Recompute the HMAC over the raw body and compare in constant time - that's the whole integration.
See a real payload and compute the signature live in the playground →
import crypto from "node:crypto" // verify BEFORE JSON.parse - sign the exact bytes you got function verify(rawBody, headers, secret) { const ts = headers["x-sfhooks-timestamp"] const sig = headers["x-sfhooks-signature"] // t=…,v1=… const expected = crypto .createHmac("sha256", secret) .update(`${ts}.${rawBody}`) .digest("hex") // any v1 may match during a secret rotation return sig.split(",") .filter(p => p.startsWith("v1=")) .some(p => crypto.timingSafeEqual( Buffer.from(p.slice(3)), Buffer.from(expected))) }
Connect a Salesforce org, point a webhook at your endpoint, and you're streaming. Reach for the advanced controls when you need them.
OAuth into Salesforce and subscribe to Change Data Capture - tokens encrypted at rest, refreshed automatically.
Deliver only what matters - by changed field, or by value with eq/gt/lt operators and AND/OR logic.
Attach auth tokens or tenant ids to every delivery. Reserved signing headers stay protected.
Endpoints escalate healthy → degraded → failing → paused so one bad receiver can't drown your queue.
Invite your team with owner, admin, member, and read-only roles. Read-only means read-only.
Inspect terminally-failed events and re-deliver one - or all - once your endpoint recovers.
We're a young product, so you won't see a wall of logos here. You'll see the mechanism instead - every claim below is documented, and testable from your first trial delivery.
Every delivery carries a timestamp and an HMAC-SHA256 signature over the exact bytes. Recompute, compare in constant time, reject anything stale.
Rotate signing secrets with an overlap window - old and new sign side by side until you finish cutting over. Nothing drops.
At-least-once delivery with jittered backoff, up to 31 attempts per event. A flaky endpoint gets time to recover, not a dropped payload.
Events that exhaust every retry wait in the DLQ. Replay one - or all of them - once your endpoint is healthy again.
Webhooks move through explicit health states instead of failing silently - owners and admins are emailed before an endpoint is paused.
OAuth tokens and secrets are encrypted at rest, data is org-scoped, and an egress guard blocks deliveries to private networks.
Throughput, latency, and delivery health at a glance - then drill into any event's payload and attempts.
| 14:02:55.214 | Account | updated | 200 OK | 41 ms |
| 14:02:54.881 | Invoice__c | created | 200 OK | 52 ms |
| 14:02:54.503 | Opportunity | updated | retry 2 | — |
The Pub/Sub API is excellent - SFHooks is built on it. The question is whether the subscription lifecycle, retry infrastructure, and observability around it is code your team wants to own.
Category-level comparison - not claims about any specific vendor. Want the long version? Every option for getting webhooks out of Salesforce, compared · the full build-vs-buy checklist · vs Outbound Messages.
Every plan includes signed delivery, automatic retries, and the full dashboard. Card required to start - you won't be charged until day 15, and you can cancel in one click.
Get production webhooks off the ground.
$0 today · then $49/mo unless you cancel
For teams shipping real integrations.
$0 today · then $149/mo unless you cancel
High-volume orgs that can't be capped.
$0 today · then $399/mo unless you cancel
Questions about billing, trials, or limits? Read the FAQ
Straight answers on billing, trials, and how delivery behaves when things break.
Yes. Starting the 14-day trial opens a Stripe checkout that collects a card, but nothing is charged until the trial ends. Cancel any time from the dashboard and you'll never be billed.
Your subscription starts on the plan you picked. Upgrade or downgrade with prorated billing, or cancel in-app at any point - no email required.
No managed package and no Apex. You OAuth into your org and SFHooks subscribes to Change Data Capture over the Pub/Sub API. You need a Salesforce edition with API access, and CDC enabled for the objects you care about - the dashboard shows which objects are ready.
You can - you'll own the gRPC subscription lifecycle, replay-id persistence, reconnect and backoff logic, HMAC signing, retry queues, dead-lettering, and the monitoring dashboards on top. SFHooks is that infrastructure, maintained for you. Your side of the integration is one HTTPS endpoint and four lines of verification code.
Those are general-purpose integration platforms: task-based pricing, transformations in their UI, and rarely signed raw payloads. SFHooks does one thing - CDC events delivered to your code as signed webhooks in near real time - with delivery guarantees and per-event observability.
Deliveries retry with jittered backoff, up to 31 attempts per event. Events that exhaust retries wait in a dead-letter queue for replay. Meanwhile the endpoint escalates healthy → degraded → failing → paused, with email to owners and admins along the way, so one dead receiver can't flood your queue.
Every request carries X-SFHooks-Timestamp and an HMAC-SHA256 X-SFHooks-Signature computed over the exact bytes. Verify in constant time and reject stale timestamps. Secret rotation runs both secrets in an overlap window, so nothing drops mid-rotation.
OAuth tokens and signing secrets are encrypted at rest, and everything is scoped to your organization. Outbound deliveries pass an egress guard that blocks private and internal addresses. Event data older than your plan's retention window is pruned automatically.
Each Salesforce change delivered to a webhook is one event. Limits are soft, fair-use allowances - the dashboard warns you as you approach them, and nothing is cut off mid-month without warning.
Yes. Upgrades and downgrades are prorated and take effect immediately, from the dashboard - you'll see the exact charge or credit before you confirm.
Talk to us about higher event volumes, multiple Salesforce orgs, SSO/SAML, custom retention windows, SLAs, and dedicated support - we'll tailor a plan to your throughput.
Connect Salesforce, point a webhook at your endpoint, and watch the first delivery land. Most teams are live in under ten minutes.