Webhooks your AI agents can wait on.
Give your agent a callback URL it creates, waits on, and verifies — over MCP. Signature-checked, retried, never missed. Stop polling for async results — await them.
Works with any webhook provider
hooksense.com/w/stripe-prod2 requests| content-type | application/json |
| user-agent | Stripe/1.0 |
| x-request-id | req_00000 |
| stripe-signature | t=1772657923,v1=5257a86... |
Features
Built for agents that wait on webhooks.
Create, await, and verify — all over MCP.
Await the result — never poll for it.
Your agent calls wait_for_callback and blocks until the webhook lands — signature-verified and decrypted. No polling loops, no burned context, no missed events.
The only MCP-native webhook tool that does this.
Callbacks the instant they land
Sub-50ms delivery to your waiting agent. No polling, no refresh.
Retried until delivered
Failed deliveries back off and retry — never silently dropped.
Verify signatures
Timing-safe HMAC — Stripe, GitHub, Shopify.
Know the event
Auto-detects the provider + event type.
Full history & search
Every callback, searchable across headers and body.
Readable URLs
/w/agent-callbacks, not /w/x7f2k9.
For agents
Drop it into your agent.
Six MCP tools, one npx line.
Add to Claude Desktop / Cursor
{
"mcpServers": {
"hooksense": {
"command": "npx",
"args": ["-y", "@hooksense/mcp"],
"env": { "HOOKSENSE_TOKEN": "hsk_..." }
}
}
}create_callback_endpointOpen a callback URL for the agent.
wait_for_callbackBlock until the result lands — no polling.
get_callback_payloadRead the decrypted body + headers.
verify_signatureTiming-safe HMAC before the agent acts.
list_callbacksBrowse what's arrived, newest first.
replay_callbackRe-drive a payload to any URL.
In production
Visibility doesn't stop
when you ship.
The callback endpoint your agent created keeps watching in production — success and fail rates, latency, and full history. The moment callbacks stop arriving or errors spike, you'll know.
- Live health dashboard — success rate, volume and latency at a glance
- Full searchable history on a URL that never expires
- Alerts when webhooks stop, fail rate spikes, or latency climbs
/w/stripe-prod· last 24hSuccess
99.2%
Requests
1,284
p95
142ms
Pricing
Simple, honest pricing.
Start free — no card. One flat fee per tier, no per-event metering. Pro & Scale are in early access.
Free
Wire up agent callbacks and try it
Free forever
- wait_for_callback — await results, no polling
- 3 callback endpoints
- 300 callbacks / day
- 14-day retention
- Permanent URL — never expires
- MCP server + full tool surface
Pro
Reliable callbacks for your agents
Per month
- Everything in Free, plus
- 15 callback endpoints
- 5,000 callbacks / day
- Signature verification (timing-safe HMAC)
- Automatic retries + dead-letterSoon
- 30-day retention
- Up to 3 team members
- Custom URLs
Scale
High volume, teams, longer retention
Per month
- Everything in Pro, plus
- Unlimited callback endpoints
- 50,000 callbacks / day
- 90-day retention
- Up to 10 team members
- Custom domains
- Uptime SLA & priority supportSoon
Need something custom? See full comparison →
Start free today. Paid plans are opening to an early-access list while we harden reliability — request access to lock in early-adopter pricing when Pro & Scale go live.
FAQ
Everything you might ask.
The agent creates a HookSense endpoint over MCP, hands that URL to the long-running job as its callback, then calls wait_for_callback. HookSense blocks until the webhook arrives, verifies its signature, decrypts the body, and returns it to the agent — so the agent gets the result the moment it lands instead of polling or holding context open.
An MCP tool that blocks until the next webhook hits your endpoint, then returns the request (signature-verified and decrypted). Pass a timeout to control how long to wait, and an `after` cursor so a callback that arrived between calls is returned immediately rather than missed. It's the core of HookSense's agent-native model: await results, don't poll for them.
No. You get a callback URL instantly — no signup, no email, no credit card. Create an account later for an API token, custom URLs, longer retention, or more endpoints.
Polling burns the agent's context window and budget on repeated checks and still adds latency. With wait_for_callback the agent makes one call and is woken the instant the webhook arrives — sub-50ms after it lands — with the payload already verified and decrypted.
Any MCP-compatible client — Claude Desktop, Claude Code, Cursor, Continue, and custom agents built on LangGraph, CrewAI, or the MCP SDK. Drop the HookSense MCP server into your config and the create_endpoint and wait_for_callback tools are available to the agent.
Yes. Drop in the provider's secret and HookSense verifies the HMAC with a timing-safe comparison — Stripe, GitHub, Shopify, and more — so your agent only acts on authentic, untampered callbacks.
Callback payloads are encrypted at rest with AES-256-GCM and auto-deleted based on your plan's retention period. We never share, sell, or analyze your data.
Any service that sends HTTP webhooks — Stripe, GitHub, Shopify, Slack, Twilio, SendGrid, Clerk, Lemon Squeezy, and hundreds more — plus your own backend jobs and other agents. We auto-detect major providers and highlight the event type.
Yes, no contracts or commitments. Downgrade to free whenever you want — your endpoints stay active, just with free-tier limits.
Callbacks reach the waiting agent in under 50ms after they arrive, over the same WebSocket/Redis path that powers the live dashboard. No polling intervals, no wasted round-trips.
Ready when you are.
Get a callback URL in under a second — no signup. Or join the Pro early-access list: retries, dead-letter, longer retention, and team endpoints.
Built solo in Istanbul by a developer who uses HookSense every day — and reads every email. Tell me what would make it better. — Ozer, founder