How to Send Multi-Channel Notifications with One API

The Problem with Single-Channel Notifications

Most applications start with one notification channel -- usually email. But as your user base grows, you realize that not everyone checks email promptly. Some users prefer Telegram. Your internal team lives in Slack. Your customers want WhatsApp. Suddenly, you are maintaining separate integrations for each channel, each with its own API, authentication, error handling, and rate limiting. This is exactly the problem One-Ping solves.

With One-Ping, you write one API call and your notification reaches every channel you specify. No more managing six different SDKs. No more duplicating notification logic across channels. One integration handles everything.

Step-by-Step Setup

The Multi-Channel API Call

Here is what a multi-channel notification looks like in practice. This single request sends a notification to Telegram, Email, and Slack simultaneously.

cURL

# Send to Telegram + Email + Slack in one request
curl -X POST https://api.one-ping.com/send \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "message": "New order #1234 from John Doe - $49.99",
    "channels": ["telegram", "email", "slack"],
    "recipient": "+34612345678",
    "metadata": {
      "email": {
        "subject": "New Order #1234",
        "to": "[email protected]"
      },
      "telegram": {
        "chat_id": "123456789"
      }
    }
  }'

JavaScript

const sendNotification = async (orderData) => {
  const response = await fetch('https://api.one-ping.com/send', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.ONEPING_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      message: `New order #${orderData.id} - $${orderData.total}`,
      channels: ['telegram', 'email', 'slack'],
      metadata: {
        email: {
          subject: `New Order #${orderData.id}`,
          to: '[email protected]',
          html: `<h2>Order #${orderData.id}</h2>
                 <p>Customer: ${orderData.customer}</p>
                 <p>Total: $${orderData.total}</p>`
        },
        slack: {
          blocks: [{
            type: 'section',
            fields: [
              { type: 'mrkdwn', text: `*Order:* #${orderData.id}` },
              { type: 'mrkdwn', text: `*Total:* $${orderData.total}` }
            ]
          }]
        }
      }
    })
  });

  return response.json();
};

Python

import requests
import os

def send_notification(order):
    response = requests.post(
        'https://api.one-ping.com/send',
        headers={
            'Authorization': f'Bearer {os.environ["ONEPING_API_KEY"]}',
            'Content-Type': 'application/json'
        },
        json={
            'message': f'New order #{order["id"]} - ${order["total"]}',
            'channels': ['telegram', 'email', 'slack'],
            'metadata': {
                'email': {
                    'subject': f'New Order #{order["id"]}',
                    'to': '[email protected]'
                },
                'telegram': {
                    'chat_id': '123456789'
                }
            }
        }
    )
    return response.json()

Channel Configuration Reference

Each channel requires specific credentials and configuration. Here is a quick reference for all supported channels:

Fallback Strategies

Not all channels are equally reliable at all times. A Slack webhook might be temporarily down, or an email server could be slow. One-Ping's fallback system ensures your critical notifications always get through.

How Fallbacks Work

When you configure a fallback, One-Ping tries to deliver through the primary channel first. If delivery fails (timeout, API error, or invalid recipient), it automatically retries through the fallback channel. You can chain multiple fallbacks for maximum reliability.

// Fallback: Try Slack first, then Telegram, then Email
{
  "message": "Critical: Database connection pool exhausted",
  "channels": ["slack"],
  "fallback": ["telegram", "email"]
}

Parallel vs. Sequential Delivery

By default, when you specify multiple channels in the channels array, One-Ping delivers to all of them in parallel. This is the "broadcast" approach and is ideal for most use cases. The fallback system is sequential -- it only triggers the next channel if the previous one fails. Combine both strategies for different notification types based on their importance.

Best Practices for Multi-Channel Notifications

• Choose channels by audience: Internal team alerts belong in Slack or Telegram. Customer-facing notifications work best via email or WhatsApp. Do not blast every channel for every event.
• Respect user preferences: Let your users choose which channels they want to receive notifications on. One-Ping makes it easy to send to whatever channels a user has enabled.
• Use channel-specific formatting: A notification that looks great in Slack (with blocks and fields) should also look good as a plain email. Always provide a good base message and enhance with metadata.
• Group notifications intelligently: Not everything needs to be instant. Consider using daily digests for low-priority events and reserving multi-channel instant notifications for truly important events.
• Monitor delivery rates: Use the One-Ping dashboard to track which channels have the highest delivery and open rates for your notifications. This data helps you optimize your channel selection over time.
• Handle errors gracefully: The One-Ping API returns delivery status for each channel in the response. Log failures and set up your own alerts for persistent delivery issues.

Common Multi-Channel Patterns

Here are proven patterns used by One-Ping customers for different notification scenarios: