System Operational

Event Routing Active

Organization Management

Effortless Event Routing for Modern Engineering Teams

Send events with a single HTTP POST. Route them anywhere. No complex authentication, no SDK installations. Just POST and go.

Get Started Free

View Documentation

99.9% Uptime

< 50ms Latency

Enterprise Security

quick-start.sh

# Send your first event

$ curl -X POST https://dispatch.kit/api/v1/webhooks/ your-id \

-d '{"payload": {"message": "User signed up", "event": "user.signup", "data": {"email": "[email protected]"}}}'

✓ Event delivered to 3 channels

That's it. No SDK installation. No complex authentication.

Stop Building Event Infrastructure

Focus on your product, not on notification plumbing

Without DispatchKit

Building custom integrations for each notification channel, maintaining OAuth flows, handling rate limits, and debugging webhook failures.

// 500+ lines of Slack integration code
// 300+ lines for Discord
// 400+ lines for email templates
// ...and growing

With DispatchKit

One webhook endpoint that routes to all channels. We handle the OAuth, rate limiting, retries, and delivery guarantees.

POST /api/webhook/your-id
{"payload": {"message": "deploy.success"}}

✓ Delivered everywhere

Without DispatchKit

Hard-coding notification logic throughout your application, making it difficult to add new channels or change routing rules.

if (event.type === 'error') {
  await slack.send(...);
  await pagerduty.alert(...);
  // Forgot to add email?
}

With DispatchKit

Configure routing rules in our dashboard. Add or remove channels without touching your code. Filter by event type, content, or custom rules.

Without DispatchKit

No visibility into delivery status. Did the notification reach Slack? Did the email bounce? You'll never know.

await notifications.send(event);
// 🤷 Did it work?

With DispatchKit

Real-time delivery tracking with detailed logs. Know exactly when and where each event was delivered, with retry history.

Stop Building, Start Shipping

Everything You Need, Nothing You Don't

Built by developers, for developers. Every feature designed to save you time.

Multi-Channel Routing

Route events to Slack, Discord, Teams, WhatsApp, SMS, email, and more with simple configuration.

Smart Filtering

Filter events by type, content, or custom rules. Only get notified about what matters.

Automatic Retries

Failed deliveries? We'll retry with exponential backoff. Your events always get through.

Real-time Analytics

Monitor event delivery, track performance, and debug issues with comprehensive dashboards.

Enterprise Security

End-to-end encryption, webhook signatures, and SOC2 compliance. Your data is safe.

Lightning Fast

Sub-50ms processing time. Your events are delivered faster than you can blink.

Built for Scale, Designed for Simplicity

Whether you're processing 100 events or 100 million, DispatchKit scales with your needs. Our infrastructure handles the complexity so you can focus on building your product.

Auto-scaling

Global CDN

Multi-region

See Your Events Flow in Real-Time

Watch as events are processed and delivered across all your channels

DispatchKit Dashboard

Live

Events Today

12,847

Active Channels

Success Rate

99.8%

Live Event Stream

user.signup

New premium customer

Slack

Discord

just now

Slack

Connected

Discord

Connected

Webhook

Connected

See your events flow in real-time

Start Your Free Trial

Simple Integration, Any Language

Get started in seconds with your favorite programming language. No SDKs required.

terminal

curl -X POST https://dispatch.kit/api/v1/webhooks/your-unique-id \
  -H "Content-Type: application/json" \
  -d '{
    "payload": {
      "message": "User signed up",
      "event": "user.signup",
      "data": {
        "email": "[email protected]",
        "plan": "premium"
      }
    }
  }'

main.py

import requests

def send_event(message, event, data):
    response = requests.post(
        "https://dispatch.kit/api/v1/webhooks/your-unique-id",
        json={
            "payload": {
                "message": message,
                "event": event,
                "data": data
            }
        }
    )
    return response.json()

# Send user signup event
send_event(
    "User signed up",
    "user.signup",
    {
        "email": "[email protected]",
        "plan": "premium"
    }
)

index.js

const sendEvent = async (message, event, data) => {
  const response = await fetch('https://dispatch.kit/api/v1/webhooks/your-unique-id', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      payload: {
        message,
        event,
        data
      }
    })
  });

  return response.json();
};

// Send user signup event
await sendEvent(
  'User signed up',
  'user.signup',
  {
    email: '[email protected]',
    plan: 'premium'
  }
);

main.rb

require 'net/http'
require 'json'

def send_event(message, event, data)
  uri = URI('https://dispatch.kit/api/v1/webhooks/your-unique-id')
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true

  request = Net::HTTP::Post.new(uri)
  request['Content-Type'] = 'application/json'
  request.body = {
    payload: {
      message: message,
      event: event,
      data: data
    }
  }.to_json

  response = http.request(request)
  JSON.parse(response.body)
end

# Send user signup event
send_event('User signed up', 'user.signup', {
  email: '[email protected]',
  plan: 'premium'
})

main.go

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

type Payload struct {
    Message string      `json:"message"`
    Event   string      `json:"event"`
    Data    interface{} `json:"data"`
}

type Request struct {
    Payload Payload `json:"payload"`
}

func sendEvent(message, event string, data interface{}) error {
    request := Request{
        Payload: Payload{
            Message: message,
            Event:   event,
            Data:    data,
        },
    }

    jsonData, _ := json.Marshal(request)

    _, err := http.Post(
        "https://dispatch.kit/api/v1/webhooks/your-unique-id",
        "application/json",
        bytes.NewBuffer(jsonData),
    )

    return err
}

// Send user signup event
sendEvent("User signed up", "user.signup", map[string]string{
    "email": "[email protected]",
    "plan":  "premium",
})

Route to Where Your Team Already Works

Connect to your favorite tools in seconds. We handle the complexity.

Slack Available

Discord Available

Pushover Available

Teams Soon

Email Soon

SMS Soon

Slack

Available

Discord

Available

Pushover

Available

Teams

Coming Soon

Email

Coming Soon

SMS

Coming Soon

Webhooks

Coming Soon

View All Integrations

Enterprise-Grade Infrastructure

Built on battle-tested technology that scales with your ambitions

Built with Modern Technology

Elixir + Phoenix

Fault-tolerant, scalable runtime

2M+ concurrent

connections

Redis

In-memory event storage

1M+ ops/sec

throughput

PostgreSQL

Reliable data persistence

ACID compliant

transactions

Phoenix LiveView

Real-time UI without JavaScript

~60 FPS

updates

Lightning-Fast Performance

<50ms

P99 Latency

99.99%

Uptime SLA

10K+

Events/sec

Data Loss

Auto-scaling infrastructure on AWS/GCP

Multi-region deployment with failover

End-to-end encryption & compliance

Built-in monitoring & alerting

"We chose Elixir and Phoenix because they let us handle millions of concurrent connections on a single server. Our infrastructure costs are 10x lower than comparable Node.js solutions."

— Engineering Team, DispatchKit

Simple, Transparent Pricing

Start free, scale as you grow. No hidden fees, no surprise charges.

Monthly Annual Save 20%

Free

per month (billed monthly)

3,000 events/month

3 integrations

Basic analytics

Community support

Get Started Free

Pro

$29

per month (billed monthly)

10,000 events/month

Unlimited integrations

Advanced analytics

Custom filters & rules

Priority email support

99.9% SLA

Get Started

Enterprise

Custom

tailored pricing

Unlimited events

Custom integrations

White-label solution

SSO & SAML

Dedicated support

99.99% SLA

Contact Sales