VectorLive demo, free and Pro.
The first three sections run the real @sweberdev/vector build in your browser: signing and verification, the sender with its retry schedule and delivery log, and the SSRF guard. The receivers in the delivery simulator are simulated, nothing is sent over the network.
Nothing you type leaves your browser. Secrets are generated with Web Crypto on this page and are gone when you reload it.
Sign and verify
Three headers, one HMACStandard Webhooks, Svix compatible.
Vector signs the message id, the timestamp and the body with HMAC-SHA256 and sends the result in webhook-id, webhook-timestamp and webhook-signature. Any Standard Webhooks or Svix library can verify it. Change the body, the secret or the clock on the receiving side and watch verification fail with the error code your handler would see.
Loading Vector…
Delivery simulator
Retries you can watchReal sender, simulated receivers, fake clock.
This is createVector with a memory store, three endpoints of the tenant acme and a fetch that answers the way you set each receiver. The clock only moves when you move it, and after every step the worker runs one process() pass, so you can follow each attempt, the backoff and the automatic disabling of a dead endpoint.
Loading Vector…
SSRF guard
Customer URLs never reach your networkChecked on create and before every attempt.
Endpoint URLs come from your customers. Vector refuses localhost, private and link-local networks (including the cloud metadata address 169.254.169.254), plain http and credentials in the URL, unless you allow them. On Node.js it also resolves the host name and checks every address, so a DNS record pointing inside your network is caught too.
Loading Vector…
Browsers have no DNS lookup, so in this demo host names are resolved from a small table: intranet.acme.example points to 10.0.0.12, every other name to a public address.
Examples
Pro
The portal, the catalog and the night shiftVector Pro.
The free package sends, retries and logs. Vector Pro adds the parts you would otherwise build next: an embeddable portal where your customers manage their own endpoints, a typed event catalog that validates payloads and generates docs, and operations tooling for alerts, recovery after outages, metrics, SLO alert rules and retention. Since 2.0 your customers can also replay a time range from the portal, and inbound sources cover Slack and Twilio. The snippets show how it plugs in.
Customer portal: one route handler, scoped to the tenant
// app/api/webhooks/[...path]/route.ts
import { createPortalHandler } from "@weber-development/vector-portal"
import { vector } from "@/lib/vector"
import { getSession } from "@/lib/auth"
const handler = createPortalHandler(vector, {
basePath: "/api/webhooks",
// Every route is scoped to the tenant you return here.
authorize: async (request) => {
const session = await getSession(request)
return session ? { tenant: session.organisationId } : null
},
eventTypes: [
{ type: "invoice.paid", description: "An invoice was paid in full." },
{ type: "customer.updated", description: "Customer details changed." },
],
})
export { handler as GET, handler as POST, handler as PATCH, handler as DELETE }And the React components on your settings page
// app/settings/webhooks/page.tsx
"use client"
import { WebhookPortal } from "@weber-development/vector-portal/react"
import "@weber-development/vector-portal/styles.css"
export default function WebhooksSettings() {
return <WebhookPortal apiBase="/api/webhooks" />
}The handler serves endpoints, secrets, the message log, retries and test events for exactly one tenant, the one your authorize function returns. The components talk to it and bring their own styles.
Event catalog
import { z } from "zod"
import { defineCatalog } from "@weber-development/vector-catalog"
export const catalog = defineCatalog({
"invoice.paid": {
description: "An invoice was paid in full.",
schema: z.object({ invoiceId: z.string(), amount: z.number().int() }),
example: { invoiceId: "inv_123", amount: 4200 },
},
})
// Typed and validated before Vector stores the message
await catalog.send(vector, "invoice.paid", { invoiceId: "inv_123", amount: 4200 }, { tenant: "acme" })
// Docs for your customers
catalog.toMarkdown()
catalog.toAsyncAPI({ title: "Acme webhooks", version: "1.0.0" })
catalog.toTypeScript()Every event type gets a schema (Zod, Valibot, ArkType or any Standard Schema library). Payloads are checked before they are sent, and the same catalog generates Markdown docs, an AsyncAPI 3 file and TypeScript types for your customers.
vector-ops sends alerts to Slack, email or a webhook when an endpoint keeps failing, replays everything that failed during an outage in one command, writes a health report, exposes Prometheus metrics and deletes old log data on a schedule.
Free 2.0
Ordering, filters and replayVector, free.
Vector 2.0 adds ordered delivery per key, payload filters, replay and pruning to the MIT package, plus a versioned database schema. It needs Node.js 22 and a one-time store.migrate().
Ordered delivery per key
Give related messages the same orderingKey and each endpoint receives them in send order, one after the other. Other keys are not held back.
Send with an ordering key
await vector.send({ eventType: "order.created", payload, orderingKey: order.id });
await vector.send({ eventType: "order.paid", payload, orderingKey: order.id });Received order (real run, fake receiver, three events, one key)
ordered: order.created -> order.paid -> order.shippedPayload filters on endpoints
An endpoint can limit itself to messages whose payload matches a condition, on top of its event types. Customers only get the events they care about.
Create an endpoint with a filter
await vector.endpoints.create({
url: "https://example.com/webhooks",
tenant: "acme",
eventTypes: ["invoice.*"],
filter: {
and: [
{ path: "amount", op: "gte", value: 1000 },
{ path: "customer.country", op: "in", value: ["CH", "DE"] },
],
},
});Four invoices sent, two delivered (real run, fake receiver)
filter: 4 sent, delivered:
invoice.paid {"amount":1200,"customer":{"country":"CH"}}
invoice.paid {"amount":2500,"customer":{"country":"DE"}}Replay a time range
After an outage or for a new endpoint, send stored messages of a time range again, oldest first, as new deliveries. It respects event types and filters.
Replay history
const { messages, deliveries, truncated } = await vector.replay({
tenant: "acme",
from: new Date("2026-10-01T00:00:00Z"),
endpointId: endpoint.id, // optional
eventTypes: ["invoice.*"], // optional, exact types
limit: 1000, // default 1000, at most 10000
});Replay of the last hour (real run; deliveries shown as a count)
replay: { messages: 3, deliveries: 3, truncated: false }
replayed in order: order.created -> order.paid -> order.shippedPrune old messages
Delete old messages with their deliveries and attempts in batches, on every store. Messages with a pending delivery are kept. Call it from a nightly job.
Nightly cleanup
await vector.prune({ olderThan: new Date(Date.now() - 30 * 24 * 3600 * 1000) });Result (real run, olderThan set in the future to delete all three test messages)
prune: 3Versioned database schema
Upgrading from 1.x is one call. migrate() adds what is missing and schemaVersion() tells you where the database stands.
Migrate and check the version
const store = createSqliteStore({ database: new DatabaseSync("webhooks.db") });
await store.migrate();
await store.schemaVersion(); // 2Fresh in-memory SQLite database (real run)
before migrate: 0
after migrate: 2 SCHEMA_VERSION = 2Outputs come from a real run of @sweberdev/vector 2.0.0 with a fake receiver in memory. Not verified: ordered delivery on MySQL. Test receiver and Drizzle export are planned for 2.1.
Read the docsPro 2.1.0
Run it as a serviceVector Pro.
Pro 2.1.0 adds a standalone server, so apps in PHP, Python, Go or any other language can send webhooks through Vector over HTTP. It also adds outgoing regions with fixed IPs and delivery limits per tenant.
Standalone server in Docker
Run Vector as its own process with a REST API, a built-in delivery worker and an admin page. Your database holds everything, no Redis needed.
Start the container
docker run -d -p 3000:3000 \
-e VECTOR_API_KEY="$(openssl rand -hex 24)" \
-e DATABASE_URL="postgres://user:password@db:5432/vector" \
ghcr.io/weber-development/vector-server:latestSend events from any language
Create an endpoint and post a message with plain HTTP. The receiver gets a signed Standard Webhooks request with retries.
Create an endpoint and send an event
curl -X POST http://localhost:3000/v1/endpoints \
-H "authorization: Bearer $VECTOR_API_KEY" -H "content-type: application/json" \
-d '{"url":"https://customer.example.com/hooks","tenant":"acme","eventTypes":["invoice.*"]}'
curl -X POST http://localhost:3000/v1/messages \
-H "authorization: Bearer $VECTOR_API_KEY" -H "content-type: application/json" \
-d '{"eventType":"invoice.paid","tenant":"acme","payload":{"id":"inv_1","amount":1200},"idempotencyKey":"inv_1"}'Regions with a fixed outgoing IPBeta
Send an endpoint's requests through a proxy with a fixed IP, so customers who allow-list your address get the region that matches. A region is an outgoing route, your data stays in one database.
Server configuration
VECTOR_REGIONS='{"eu":{"proxy":"http://proxy-eu.internal:3128","description":"Frankfurt"},"us":{"proxy":"http://proxy-us.internal:3128"}}'
VECTOR_DEFAULT_REGION=eu
VECTOR_TENANT_REGIONS='{"globex":"us"}'Limits per tenant and endpoint
Stop one busy tenant from using all of a worker's capacity. Deliveries over the limit wait and are not counted as failed attempts.
Server configuration
VECTOR_LIMITS='{"default":{"perSecond":20,"maxConcurrent":10},"tenants":{"acme":{"perSecond":100,"perDay":500000}}}'Use the same controls in your own Node app
Already embedding Vector? createDeliveryControls gives you regions and limits as options for createVector, without the server.
vector-ops
import { ProxyAgent, fetch as undiciFetch } from "undici";
import { createDeliveryControls } from "@weber-development/vector-ops";
const dispatcher = new ProxyAgent("http://proxy-eu.internal:3128");
const controls = createDeliveryControls({
fetch: undiciFetch as typeof fetch,
regions: { eu: { dispatcher } },
defaultRegion: "eu",
limits: { default: { perSecond: 20, maxConcurrent: 10 } },
});
const vector = createVector({ store, ...controls.options });The demo cannot show this: the server needs your own host, database and proxies. Limit counters live in the memory of each process.
Read the docsNext
Send your first webhookMIT, free.
Install @sweberdev/vector, create an endpoint for a customer, call send() and start the worker. The getting started guide covers PostgreSQL, serverless and the receiving side.