One API Call.
Notifications Everywhere.

Send alerts to Telegram, Discord, Slack, and custom webhooks with a single HTTP POST. Any language. Any framework. If your code can send an HTTP request, it can send notifications through NotificationsBot.

Send a notification POST /events
curl -X POST https://api.notificationsbot.com/events \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "title": "Deploy Complete",
  "message": "v2.4.1 deployed to production. All health checks passing.",
  "channel_code": "my_saas_app"
}'

Built for Developers

Everything you need to add multi-channel notifications to your app, without the infrastructure headaches.

Simple REST API

One POST endpoint. Bearer token auth. JSON body. No SDKs to install, no client libraries to manage. If you can write curl, you can send notifications.

Multi-Channel Delivery

One API call delivers to Telegram, Discord, Slack, and custom webhooks simultaneously. Add or remove delivery channels from the dashboard without touching your code.

Subscriber Management

Add and remove recipients from the dashboard. Subscribers self-onboard via a link. No code changes needed when your team grows or notification recipients change.

Groups and Channels

Route different events to different people. Create channels for each app, groups within channels (e.g., "tech", "billing", "alerts"), and target notifications precisely where they need to go.

Event Logs

Full history of every notification you have sent, with delivery status, timestamps, and metadata. Debug delivery issues in seconds from the dashboard instead of digging through server logs.

Scheduled Notifications

Send events at a future time with the scheduled_at parameter. Perfect for maintenance reminders, deploy countdowns, timed announcements, and any notification that should arrive later.

Works with Every Language

The same API call, in whatever language your project uses. Just an HTTP POST with a JSON body.

curl -X POST https://api.notificationsbot.com/events \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "title": "Payment received",
  "message": "User #4821 upgraded to Pro plan ($5/mo)",
  "channel_code": "my_saas_app",
  "group_codes": ["billing"],
  "metadata": {
    "user_id": "4821",
    "plan": "pro",
    "amount": 5.00
  }
}'
import requests

response = requests.post(
    "https://api.notificationsbot.com/events",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json"
    },
    json={
        "title": "Payment received",
        "message": "User #4821 upgraded to Pro plan ($5/mo)",
        "channel_code": "my_saas_app",
        "group_codes": ["billing"],
        "metadata": {
            "user_id": "4821",
            "plan": "pro",
            "amount": 5.00
        }
    }
)

print(response.json())
const response = await fetch(
  "https://api.notificationsbot.com/events",
  {
    method: "POST",
    headers: {
      "Authorization": "Bearer YOUR_API_KEY",
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      title: "Payment received",
      message: "User #4821 upgraded to Pro plan ($5/mo)",
      channel_code: "my_saas_app",
      group_codes: ["billing"],
      metadata: {
        user_id: "4821",
        plan: "pro",
        amount: 5.00
      }
    })
  }
);

const data = await response.json();
console.log(data);
package main

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

func main() {
    body, _ := json.Marshal(map[string]interface{}{
        "title":        "Payment received",
        "message":      "User #4821 upgraded to Pro plan ($5/mo)",
        "channel_code": "my_saas_app",
        "group_codes":  []string{"billing"},
        "metadata": map[string]interface{}{
            "user_id": "4821",
            "plan":    "pro",
            "amount":  5.00,
        },
    })

    req, _ := http.NewRequest("POST",
        "https://api.notificationsbot.com/events",
        bytes.NewBuffer(body))
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    fmt.Println("Status:", resp.Status)
}
$ch = curl_init("https://api.notificationsbot.com/events");

curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer YOUR_API_KEY",
        "Content-Type: application/json"
    ],
    CURLOPT_POSTFIELDS => json_encode([
        "title" => "Payment received",
        "message" => "User #4821 upgraded to Pro plan (\$5/mo)",
        "channel_code" => "my_saas_app",
        "group_codes" => ["billing"],
        "metadata" => [
            "user_id" => "4821",
            "plan" => "pro",
            "amount" => 5.00
        ]
    ])
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;

API Reference

Everything you need to start sending notifications.

POST https://api.notificationsbot.com/events

Authentication

Include your API key in the Authorization header as a Bearer token. Generate API keys from the dashboard.

Request Body (JSON)

Parameter Type Description
title required string The notification title displayed to subscribers.
message required string The notification body. Supports plain text.
channel_code required string The channel to send this event to. Created in the dashboard.
group_codes optional string[] Target specific groups within the channel. If omitted, all channel subscribers receive the notification.
metadata optional object Arbitrary key-value data attached to the event. Visible in logs for debugging.
scheduled_at optional string (ISO 8601) Schedule delivery for a future time. Example: 2026-04-10T15:00:00Z

Response

{
  "id": "evt_a1b2c3d4e5",
  "status": "queued",
  "created_at": "2026-04-03T12:00:00Z"
}

Why NotificationsBot API Instead of Building Your Own

You could wire up Telegram bots, Discord webhooks, and Slack apps yourself. Here is why you probably should not.

No bot management

Skip creating and maintaining Telegram bots, Discord webhook URLs, and Slack app manifests. We handle the integration layer so you do not have to.

Zero infrastructure

No queues to provision, no workers to monitor, no retry logic to implement. Send a POST request and your notification is on its way.

Enterprise message broker

Notifications are processed through a managed enterprise message broker with built-in retry logic and delivery guarantees. Your events will not get lost.

Dashboard included

Manage channels, subscribers, and groups from a web UI. View full event logs with delivery status. No need to build admin tooling.

Language agnostic

If your runtime can make an HTTP POST request, it works. No SDKs, no dependencies, no version conflicts. cURL, Python, Node.js, Go, PHP, Ruby, Java, Rust, .NET -- all the same one-liner.

Ship in minutes, not weeks

Building multi-channel notification infrastructure from scratch takes weeks of development and ongoing maintenance. With NotificationsBot, you are sending notifications in under five minutes.

Simple, Developer-Friendly Pricing

Start free. Upgrade when you need more volume.

Free

$0/month

100 events/month, 1 channel, 1 subscriber

Get Started

Start Sending Notifications in 5 Minutes

Create an account, grab your API key, and send your first notification. No credit card required.

1 Sign up
2 Create a channel
3 Send a POST request
Create free account