Connectors
140+ maintained destinations — warehouses, queues, CRMs, plain webhooks. Auth, pagination and rate limits are our code, not yours.
Relay is the delivery layer between your product and everything it talks to. One POST hands an event to us; retries, ordering, transforms, and replay are our problem from that millisecond on.
# One call. Every destination you've connected.
curl https://api.relay.dev/v1/events \
-H "Authorization: Bearer sk_live_9fK3…" \
-H "Idempotency-Key: ord_58213" \
-d '{
"type": "order.created",
"destination": "crm.sync",
"payload": { "order_id": "ord_58213", "total_cents": 489900 }
}'
import { Relay } from "@relay/sdk";
const relay = new Relay(process.env.RELAY_KEY);
// Retries, ordering and replay are handled on the wire
const event = await relay.events.send({
type: "order.created",
destination: "crm.sync",
payload: { orderId: "ord_58213", totalCents: 489900 },
});
console.log(event.status); // "delivered" — in ~38 ms
from relay import Relay
relay = Relay(os.environ["RELAY_KEY"])
# Retries, ordering and replay are handled on the wire
event = relay.events.send(
type="order.created",
destination="crm.sync",
payload={"order_id": "ord_58213", "total_cents": 489900},
)
print(event.status) # "delivered" — in ~38 ms
client := relay.New(os.Getenv("RELAY_KEY"))
// Retries, ordering and replay are handled on the wire
event, err := client.Events.Send(ctx, &relay.Event{
Type: "order.created",
Destination: "crm.sync",
Payload: relay.M{"order_id": "ord_58213", "total_cents": 489900},
})
if err != nil { log.Fatal(err) }
fmt.Println(event.Status) // "delivered" — in ~38 ms
Live medians from the last 30 days across production traffic. The status page shows the same dashboards we watch — not a softer copy.
Median time from your POST landing to the destination's 200, measured at the edge.
Includes every retry we made so you didn't have to. Failures land in a dead-letter queue you can replay.
From single webhooks to 40k-events-per-second batch replays, on the same API surface.
Pin traffic to a region and it never leaves. EU events can live in fra + ams, full stop.
Each one is an API first and a dashboard second. Compose them; we never make you adopt the whole platform to use one piece.
140+ maintained destinations — warehouses, queues, CRMs, plain webhooks. Auth, pagination and rate limits are our code, not yours.
Ordered per key, exactly-once to each destination. Fan one event out to twelve consumers without twelve producers.
Reshape payloads in flight with JS or WASM modules — versioned, testable against captured traffic, deployed in one commit.
Exponential backoff with jitter by default; a dead-letter queue you can inspect; replay any window of traffic to any destination, months later.
A full parallel environment with synthetic traffic generators. Break things on sk_test_ keys; production never notices.
Every event carries its full delivery history: attempts, latencies, response bodies. Trace one order from POST to warehouse row.
Point your systems at one endpoint. Register destinations once — a webhook URL, a Kafka topic, a Postgres table, a warehouse — and Relay learns their auth, their limits, their moods.
relay destinations add crm.sync --url https://crm.internal/hooksPayloads rarely match on both ends. Write a ten-line transform, test it against last Tuesday's real traffic in the sandbox, and ship it with your normal deploy.
relay transforms test rename-fields --replay 2026-06-23We chase the 200 so you don't. Backoff, ordering, idempotency and the dead-letter queue are defaults, not a quarter of platform work. When a destination heals, its backlog drains itself.
delivered=1,204,318 · retried=2,911 · dead-lettered=7 · todayEverything else — dashboards, CLI, Terraform provider — is built on these same routes with the same keys. p50 latencies are 30-day production medians.
| Method | Route | What it does | p50 |
|---|---|---|---|
| POST | /v1/events | Ingest one event; fan out to every matched destination | 38 ms |
| POST | /v1/events/batch | Up to 5,000 events per call, atomically accepted | 61 ms |
| GET | /v1/events/{id} | Full delivery history: attempts, latencies, response bodies | 24 ms |
| POST | /v1/destinations | Register a webhook, queue, database or warehouse | 45 ms |
| GET | /v1/destinations/{id}/health | Live success rate, backlog depth and drain estimate | 22 ms |
| POST | /v1/replays | Re-deliver any window of traffic, up to 40k events/s | 57 ms |
| GET | /v1/schemas/{type} | Versioned JSON Schema for any event type you've sent | 19 ms |
| DEL | /v1/keys/{id} | Revoke a key across all regions in under a second | 31 ms |
Versioned by date — you're reading v2026-06-18. Old versions keep working; we've never removed one.
For side projects and the proof-of-concept you're starting tonight.
5M events included, then $0.20 per 10,000. No per-seat math, ever.
Single-tenant cells for regulated traffic and ten-figure event volumes.
"We replaced 4,100 lines of retry-and-queue glue with nine lines of Relay. Our integration backlog was fourteen connectors deep; it cleared in one quarter."
Re-send any traffic window at up to 40,000 events/s, rate-shaped so you can't hurt your own destination.
Context-first API, zero-allocation encoder, 41% faster on our reference workload.
Keep EU traffic inside fra + ams end to end — including retries and dead-letter storage.
Bring modules up to 5 MB in any language that compiles to WASM. Rust and Zig templates in the CLI.
Free tier, no card, no sales call. If you're not in production in a week, tell us why — we read every reply to that email.
npm install @relay/sdk
also: pip install relay-sdk · go get relay.dev/sdk/v3 · cargo add relay