Track once.Deliver everywhere.

All systems operational

Event tracking & routing for product teams

Track once.

Deliver everywhere.

Your app has things to say: signups, failed payments, deploys. Track each one with a single HTTP request: EventSend records it for search and analytics, then delivers it where your team already works. No bots to build, no infrastructure to babysit.

Talks to your AI Claude ChatGPT How

Start for free See the pipeline

No credit card required Free tier forever Cancel anytime

terminal

$ curl -X POST https://eventsend.io/api/events/es\_1a2b3c \\

\-H "Content-Type: application/json" \\

\-d '{"event": "deploy.finished", "level": "success",

"message": "v2.4.1 is live on production"}'

202 HTTP/1.1 202 Accepted

{"success": true}

Live pipeline

Watch an event travel

From 'payment.failed' in your code, or a Stripe webhook you never wrote a line for, to a ping in your phone or team's channels. Watch how every event finds its way, even when a destination misbehaves.

Your app

POST /api/events/es\_1a2b3c

JSON event · optional unique\_key

Stripe · source

POST /api/sources/src\_9f8e7d

signed webhook · zero code

EventSend core

Validate

Idempotency

Queue

Slack

Discord

Webhook

Duplicates get dropped, failures get retried — and you didn't have to build any of it

event log

Send test event

How it works

Three steps to production

Create a route

Sign up, create a route, copy its `es_`token, that's the whole setup. No OAuth dance, no SDK, no config files. Flip on debug mode to experiment without pinging anyone.

POST your events

Fire a tiny JSON payload from your backend, a cron job, a CI script, anything that speaks HTTP. Add a `unique_key`and retries never double-post.

We fan out & deliver

Events are logged and land in Slack, Discord, Telegram, your own phone, or in any webhook you point us at. Retries, rate limits, and flaky endpoints handled while you sleep.

Building with AI?

Let your agent do step 02.

Copy the ready-made prompt for your tool and paste it in. Your agent reads the codebase, lists the moments worth knowing about in your product, and instruments them server-side, failure paths included.

Then ask it what happened

Pick your tool

Cursor
Claude Code
Codex
Devin Desktop
GitHub Copilot
Lovable
Bolt
v0
Replit

Sources

No code? Paste one URL.

Sources flip the pipeline around: instead of your app POSTing to EventSend, tools like Stripe, GitHub and Vercel do. Paste one URL into Stripe and every payment lands in your channels; paste one into GitHub and every push, merged PR and failed CI run does too; paste one into Vercel and so does every deploy that ships or breaks — formatted, deduped, and retried. About 2 minutes, zero code.

Create a source, copy its URL

Pick Stripe, pick the route it feeds — we mint a private webhook endpoint for it.

https://eventsend.io/api/sources/src\_9f8e7d…

Paste it into Stripe

Add it as a webhook endpoint in the Stripe Dashboard, then paste the signing secret Stripe hands back. From then on every delivery is signature-verifiedbefore we touch it — and anything Stripe sends in the meantime gets retried, so nothing is lost.

That's it — "cha-ching" in Slack

A source is just another producer on a route, so its events flow through the same topics, destinations, retries, and delivery history as the ones your code sends. Stripe's retries? Deduplicated automatically.

Stripe live GitHub live Vercel live

stripe → your channels

`checkout.session.completed `

💰 New payment: 49.00 USD from [\[email protected\]](https://eventsend.io/cdn-cgi/l/email-protection)

`customer.subscription.created `

🎉 New subscription: Scale Monthly

`invoice.payment_failed `

⚠️ Payment failed: 29.00 USD — [\[email protected\]](https://eventsend.io/cdn-cgi/l/email-protection)

`customer.subscription.deleted `

👋 Subscription canceled: Scale Monthly

`charge.dispute.created `

🚨 Dispute opened: 49.00 USD

// opinionated defaults, on from the first webhook

Connect Stripe in 2 minutes

Works on the free tier — see it pay for itself before you pay for it.

Alerting

Signal when it matters. Silence when it doesn't.

Getting events into a channel is the easy part — surviving them is harder. Threshold alerts, rollups, quiet hours, and digests turn a noisy stream into the handful of messages worth reading. No per-seat pager bill attached.

Escalation

Threshold alerts

Ten payment failures in five minutes is one incident, not ten pings. Set a threshold on any route and a single critical alert goes to the destination you chose.

How threshold alerts work

Noise control

Smart rollups

The same event firing twenty times becomes one message — payment-failed ×20. Your channel stays readable; every underlying event stays in your history.

How rollups work

Boundaries

Quiet hours

Give each destination a daily window in your org's timezone. Only critical events break through overnight — everything else is held for your digest, not dropped.

How quiet hours work

Perspective

Email digests

A daily or weekly email with your top events, level breakdown, delivery failures, and whatever quiet hours held back — the whole story in one read.

How digests work

Build vs buy

Your time is worth more than glue code

Every destination you wire up by hand is another API to learn, another token to rotate, another failure mode to babysit. Or you can send one POST.

Doing it yourself

weeks of work

A different API, auth flow, and message format for every destination
Retry queues, rate limits, and duplicate protection to build and test yourself
Failures you discover only when someone misses an alert
Maintenance forever — provider changes, deprecations, expired tokens
Weeks before the first notification ever lands

With EventSend

one POST request

One endpoint and one JSON shape, whatever the destination
Retries, rate limits, and duplicate protection on from day one
Live delivery status for every event, all in one dashboard
Broken destinations pause themselves and let you know
New destinations appear in your account — no code changes on your side

Capabilities

The reliability layer you'd rather not build

Every card below is shipped and running on every event you send — so a flaky endpoint or a duplicate deploy never becomes your team's problem.

Security

Signed webhook deliveries

Receivers can trust that every webhook really came from you — each delivery is signed and timestamped, with a secret you can rotate anytime.

X-EventSend-Signature: sha256=4fd9a1c0e7…

X-EventSend-Timestamp: 1767139200

Reliability

Automatic retries

Endpoints flake; your events shouldn't vanish. Failed deliveries retry on their own with smart backoff — easing off politely when a destination pushes back — until the message lands.

try 1

try 2

try 3

delivered ✓

Consistency

Idempotent ingestion

Deploy retries, network blips, double-fired jobs — send a unique\_key and the duplicate dies with a 409 instead of spamming your team twice.

409 Conflict · duplicate unique\_key

Protection

Circuit breakers

When a destination goes down, we stop hammering it and recover automatically — no wasted quota, no pile-up when it comes back.

Throughput

Distributed rate limiting

Traffic spike at 3am? Cluster-wide limits smooth out bursts and respect each destination's own rules, so nothing gets throttled or dropped.

Observability

Real-time delivery feed

Know what happened without SSH-ing anywhere. Watch events stream in live, and filter by status, level, route, or channel when something looks off.

Collaboration

Organizations & teams

Solo today, five people next quarter — invite teammates with owner, admin, or member roles and share routes, channels, and history safely.

Hygiene

Broken endpoint detection

Rotated a token and forgot a webhook? Dead integrations pause themselves and email the owner — before silence gets mistaken for good news.

Development

Debug mode per route

Wire up staging without waking up the team — debug routes check every event and drop it, without recording or delivering a single one.

Security

SSRF-safe webhooks

Your infrastructure stays yours — webhook targets are DNS-resolved and checked against private IP ranges before we ever open a connection.

// One HTTP endpoint instead of a pile of integrations.

Insights

Every event, the moment it happens

Post an event and watch it arrive. The dashboard streams deliveries live, and the full story of every attempt is one click away — no log-diving required.

app.eventsend.io/dashboard

Dashboard Live

Total Events

8,214

Success Rate

99.2%

Active Channels

Recent Events All events »

payment.failed Jul 10, 2026 09:14:22 AM

Processing

❗ Payment failed for acme.io — card declined

ID: evt\_9f27c1

user.signup Jul 10, 2026 09:13:47 AM

Delivered

🎉 New user subscribed to the Growth plan

ID: evt\_4b81aa

Slack Telegram

deploy.finished Jul 10, 2026 09:11:05 AM

Delivered

🚀 v2.4.1 is live on production

ID: evt\_77d2e3

Slack Discord Webhook

backup.completed Jul 10, 2026 08:00:01 AM

Delivered

💾 Nightly database backup completed

ID: evt\_c05f19

Discord

Live event stream

Every event appears the moment it hits your route — no refresh, no polling.

Analytics & usage

Volume, error rate, delivery health and quota burn-down, with 12 months of history on every plan.

Search & filters

Slice your event history by status, level, route, channel, or free text.

Full delivery history

Every attempt for every destination, with the exact error when something fails.

On the roadmap

Alerting has shipped — delivery assurance is next.

Heartbeat monitors

Know when your nightly job doesn't run.

Event replay

Resend any failed delivery with one click.

Know what happened

Ask your AI what happened.

You stepped away, and things happened: a checkout failed, a customer cancelled, a webhook went quiet. Instead of digging through logs, ask. Claude or ChatGPT can read your event history and tell you what went wrong overnight, what a customer did before they churned, and whether anything is stuck right now.

claude · eventsend

you

Did anything fail in checkout today?

claude search\_events

Two errors in checkout since midnight, both already delivered:

09:14 payment.failed card declined for acme.io Slack ✓
07:41 checkout.timeout card authorization timed out, cus\_9Xk2 Slack ✓ Telegram ✓

Nothing else at error level in the last 24 hours.

you

What did cus\_9Xk2 do before cancelling?

claude get\_user\_timeline

Three events over 15 days, oldest first:

1. Sep 02 user.signup subscribed to the Growth plan 2. Sep 15 payment.failed card declined, retried twice 3. Sep 17 subscription.canceled two days after the second decline

// example exchange — nine read-only tools, your assistant picks which to call

### What happened while you were away
### Why a customer churned
### The assistant you already have

Pick your client

Claude Code
Cursor
Claude Desktop
claude.ai
ChatGPT

Read the MCP docs

Raw events reach back as far as your plan's retention; daily counts are kept for twelve months.

Integration

Works with any stack

Node, Python, Elixir, Ruby, Go, C# — if it can send an HTTP request, it can notify your team. No SDK to install, nothing to maintain.

JavaScript Python Elixir Ruby Go C#

app.js

// Using fetch
const response = await fetch(
  'https://eventsend.io/api/events/YOUR_WEBHOOK_ID',
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      event: 'user.signup',
      message: 'A new user subscribed to the service',
      payload: {
        user_id: '12345',
        email: '[email protected]'
      }
    })
  }
);console.log('Event sent:', await response.json());

import requests
response = requests.post(
    'https://eventsend.io/api/events/YOUR_WEBHOOK_ID',
    json={
        'event': 'user.signup',
        'message': 'A new user subscribed to the service',
        'payload': {
            'user_id': '12345',
            'email': '[email protected]'
        }
    }
)print(f'Event sent: {response.json()}')

# Using Req (included by default)
{:ok, response} = Req.post(
  "https://eventsend.io/api/events/YOUR_WEBHOOK_ID",
  json: %{
    event: "user.signup",
    message: "A new user subscribed to the service",
    payload: %{
      user_id: "12345",
      email: "[email protected]"
    }
  }
)IO.inspect(response.body, label: "Event sent")

require 'net/http'
require 'json'
uri = URI('https://eventsend.io/api/events/YOUR_WEBHOOK_ID')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri.path, 'Content-Type' => 'application/json')
request.body = {
  event: 'user.signup',
  message: 'A new user subscribed to the service',
  payload: {
    user_id: '12345',
    email: '[email protected]'
  }
}.to_jsonresponse = http.request(request)
puts "Event sent: #{response.body}"

package main
import (
    "bytes"
    "encoding/json"
    "net/http"
)
func main() {
    payload := map[string]interface{}{
        "event":   "user.signup",
        "message": "A new user subscribed to the service",
        "payload": map[string]string{
            "user_id": "12345",
            "email":   "[email protected]",
        },
    }    jsonData, _ := json.Marshal(payload)
    resp, _ := http.Post(
        "https://eventsend.io/api/events/YOUR_WEBHOOK_ID",
        "application/json",
        bytes.NewBuffer(jsonData),
    )
    defer resp.Body.Close()
}

using System.Net.Http;
using System.Text;
using System.Text.Json;
var client = new HttpClient();
var payload = new
{
    @event = "user.signup",
    message = "A new user subscribed to the service",
    payload = new
    {
        user_id = "12345",
        email = "[email protected]"
    }
};
var json = JsonSerializer.Serialize(payload);
var content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await client.PostAsync(
    "https://eventsend.io/api/events/YOUR_WEBHOOK_ID",
    content
);Console.WriteLine($"Event sent: {await response.Content.ReadAsStringAsync()}");

Destinations

Deliver where your team already works

Your team lives in chat, not in another dashboard. Send to Slack, Discord, and Telegram natively, wake your own phone with Pushover or browser push, reach everything else with webhooks — and new destinations are always on the way.

Slack

Available

Discord

Available

Webhooks

Available

Pushover

Available

Web Push

Available

MS Teams

Coming soon

ntfy

Coming soon

Need a destination we don't cover yet?

Request an integration

Pricing

Simple, transparent pricing

Start free on your side project, upgrade when your team does — overage is billed per event, never as a surprise tier jump.

Monthly Yearly (save \~20%)

Free

For side projects

$0 USD/month

2,500 events/month
2 seats
3 team destinations
1 source
7-day event retention
AI assistant access (MCP)
Hard-capped — no overage

Start free

Starter

For solo builders and small teams

$12 USD/month

50,000 events/month
Unlimited seats
Unlimited team destinations
Unlimited sources
$0.0005 per extra event
30-day event retention
AI assistant access (MCP)

Start free

Popular

Growth

For growing teams

$29 USD/month

150,000 events/month
Unlimited seats
Unlimited team destinations
Unlimited sources
$0.0005 per extra event
60-day event retention
AI assistant access (MCP)

Start free

Scale

For steady businesses

$59 USD/month

500,000 events/month
Unlimited seats
Unlimited team destinations
Unlimited sources
$0.0005 per extra event
90-day event retention
AI assistant access (MCP)

Start free

Enterprise

Unlimited events and seats, custom retention, and priority help — let's talk about your volume.

Contact sales

Prices in US dollars. Outside the US, checkout may show your local currency at the current exchange rate.

Coming from LogSnag? Compare the plans side by side

Get started

Start routing events in minutes.

A free tier that stays free, no credit card required — your first "it works!" can hit Slack before your coffee cools.

Start for free See the pipeline

Track once.Deliver everywhere.

Track once.Deliver everywhere.

Track once.

Watch an event travel

Three steps to production

Create a route

POST your events

We fan out & deliver

Let your agent do step 02.

No code? Paste one URL.

Create a source, copy its URL

Paste it into Stripe

That's it — "cha-ching" in Slack

Signal when it matters. Silence when it doesn't.

Threshold alerts

Smart rollups

Quiet hours

Email digests

Your time is worth more than glue code

Doing it yourself

With EventSend

The reliability layer you'd rather not build

Signed webhook deliveries

Automatic retries

Idempotent ingestion

Circuit breakers

Distributed rate limiting

Real-time delivery feed

Organizations & teams

Broken endpoint detection

Debug mode per route

SSRF-safe webhooks

Every event, the moment it happens

Live event stream

Analytics & usage

Search & filters

Full delivery history

Heartbeat monitors

Event replay

Ask your AI what happened.

Works with any stack

Deliver where your team already works

Slack

Discord

Telegram

Webhooks

Pushover

Web Push

MS Teams

ntfy

Simple, transparent pricing

Free

Starter

Growth

Scale

Enterprise

Start routing events in minutes.

Comments (0)