Catch, reshape, and route any webagent{ }hook — without the glue code.
Hookport is a programmable webhook relay. Point any sender at a durable URL, transform the payload with a pipeline, then forward it, sink it straight to a database, drop it in an inbox — or push it to your phone. Your agents and alerts get the same port: notifications with answers, and runbooks that fix things.
# any sender POSTs to your hook URL
curl https://hookport.com/h/pay_9x2k \
-d '{"event":"payment.succeeded","amount":4200}'
# pipeline: normalize → forward → trace
{
"amount": "42.00",
"currency": "USD",
"large": false
}Everything between "webhook received" and "job done".
Stop writing throwaway relay services. Hookport gives you the whole pipeline as configuration.
Catch any webhook
Every hook gets a durable URL. Sync or async delivery, redirect-following, retries, and full request/response history you can replay.
Transform, no deploys
Chain steps in a live editor: JMESPath, jq, Liquid, sandboxed JavaScript, or bring-your-own LLM. Preview against real payloads before you ship.
Sinks & databases
Skip forwarding entirely: write rows straight to ClickHouse (or your DB) through a pluggable adapter, with Rails-style migrations per connection.
Ready-made receivers
Normalize Sentry, Airbrake and OpenTelemetry (traces, metrics, logs) into clean, flat shapes with one-click sample pipelines.
Self-observability
Emit an OpenTelemetry trace of every hook — receive → transform → deliver, with timing and status — to your own OTLP collector.
Email → webhook
Point an address at a hook and inbound email becomes a JSON payload your pipeline can parse, route, and turn into structured documents.
Webhook → iPhone
Any pipeline (or a bare curl) becomes a source-branded phone notification with its own name, avatar and tap-through — delivered by the HookPort app.
Pipelines are just steps you can read.
A pipeline is an ordered chain of transformations. Each step reshapes the payload and passes it on — filter with a condition, compute in JavaScript, extract with jq or JMESPath, template with Liquid, or hand it to an LLM. The last step can forward the result, insert it into a database, or emit tags that route the document to another inbox.
- Live preview against sample payloads
- Sandboxed JavaScript with hard timeouts
- ReDoS-guarded regex helpers
- Reusable, composable pipelines
export default (payload) => ({
amount: (payload.amount / 100).toFixed(2),
currency: "USD",
large: payload.amount >= 10000,
tags: ["finance"],
})19:53:02 alert ollama fell back to CPU
19:53:03 push "bouncing the service now" → 📱
19:53:04 runbook stop → wait → start → wait
19:58:16 status running:healthy
19:58:17 push "back on the GPU" → 📱The port between your agents and your pocket.
Anything that can send an HTTP request can reach your phone — a coding agent finishing a task, a cron job, a monitoring alert. And it doesn't stop at notifying: wire an alert into a runbook pipeline that remediates the problem itself, then pushes you the outcome instead of the incident.
- Source-branded pushes — each sender gets its own name and avatar
- Runbooks: alert → remediation step → outcome push, all as pipeline config
- Conditions per step — notify only on failure, act only on real alerts
- Native iOS app with an agent inbox, built on the same hooks
Live in three steps.
Create a hook
You get a durable receive URL instantly. Pick sync or async, or make it a sink that only stores what it receives.
Attach a pipeline
Build the transformation chain in the editor and preview it against a sample payload. Choose a target, a database, or an inbox.
Point your sender
Paste the URL into Stripe, GitHub, Sentry — anything. Watch deliveries, response codes and timings, and trace them in your own tools.
Tame your webhooks.
One durable URL, a pipeline you can read, and a delivery log you can trust.