Webhook Notifications for Proxy Issues: Set Up Automated Monitoring in 10 Minutes

Imagine this situation: you launched an advertising campaign on 20 Facebook Ads accounts, and in the morning you found that half of the proxies stopped working last night. The result — wasted budget, blocked accounts, and lost time. Webhook notifications solve this problem by sending instant alerts about any proxy issues directly to Telegram, Slack, or Discord.

In this guide, I will show you how to set up automatic proxy monitoring with webhook notifications for arbitrageurs, SMM specialists, and e-commerce sellers. You will learn how to receive instant alerts about IP failures, blocks, and access issues — without the need to constantly check the functionality manually.

What is a webhook and why is it needed for proxy monitoring

A webhook is an automatic HTTP notification that is sent to a specified URL when a certain event occurs. In the context of proxy monitoring, this means that the system will automatically send you a message in Telegram, Slack, or another messenger as soon as it detects a problem with the IP address.

For businesses, this is critically important. If you are an arbitrageur working with Facebook Ads through 30 accounts, each using a separate proxy, manually checking the functionality of each IP will take at least an hour a day. Webhook notifications automate this process — you will be informed of the problem within 1-2 minutes after it occurs.

The main advantages of webhook notifications for proxy monitoring are:

• Instant response: notification arrives within 30-60 seconds after the problem is detected
• Time-saving: no need to manually check the functionality of each proxy
• Loss prevention: quick detection of the problem = minimal downtime of advertising campaigns
• Scalability: can monitor 100+ proxies simultaneously
• Flexible configuration: choose which events to track and where to send notifications

What proxy issues can be tracked via webhook

An effective monitoring system should track all critical events that may affect the operation of your accounts or parsers. Here are the main types of problems that can be monitored through webhook notifications:

For arbitrageurs working with Facebook Ads or TikTok Ads, notifications about IP blocks by the platform and geolocation changes are the most critical. If you set up an account for the USA, and the proxy suddenly starts showing an IP from another country — this guarantees a ban on the account.

SMM specialists managing dozens of Instagram or TikTok accounts should primarily monitor IP unavailability and authentication errors. If the proxy stops working while auto-posting continues to attempt connections — Instagram may suspect automation and block the account.

For marketplace sellers (Wildberries, Ozon, Avito) engaged in competitor price scraping, monitoring blocks and low speed is most important. If you are using data center proxies for scraping, the blocking of one IP can halt data collection on hundreds of products.

Setting up notifications in Telegram: step-by-step guide

Telegram is the most popular option for receiving webhook notifications among arbitrageurs and SMM specialists. The setup takes 5-10 minutes and does not require technical skills. Here is a step-by-step guide:

Step 1: Create a Telegram bot

1. Open Telegram and find the bot @BotFather
2. Send the command /newbot
3. Come up with a name for the bot (for example, "Proxy Monitor")
4. Come up with a username for the bot (must end with "bot", for example, "my_proxy_monitor_bot")
5. BotFather will send you a token — this is a long string like 123456789:ABCdefGHIjklMNOpqrsTUVwxyz
6. Save this token — it will be needed for webhook setup

Step 2: Get Chat ID

Chat ID is a unique identifier for the chat where notifications will be sent. To get it:

1. Find your bot in Telegram by username and click "Start"
2. Send the bot any message (for example, "test")
3. Open in your browser: https://api.telegram.org/bot[YOUR_TOKEN]/getUpdates
4. In the response, find the field "chat":{"id": — this is your Chat ID (for example, 123456789)

Step 3: Set up webhook in the monitoring service

Most proxy monitoring services (UptimeRobot, Pingdom, StatusCake) support webhook notifications. You need to specify the URL for sending notifications in the format:

https://api.telegram.org/bot[YOUR_TOKEN]/sendMessage?chat_id=[YOUR_CHAT_ID]&text=NOTIFICATION_TEXT

For example, if your token is 123456789:ABCdef, and the Chat ID is 987654321, then the webhook URL will be:

https://api.telegram.org/bot123456789:ABCdef/sendMessage?chat_id=987654321&text=Proxy%20is%20not%20working

Step 4: Test notifications

To check that the webhook works correctly, open your webhook URL in a browser. If everything is set up correctly, the bot will send you a test message in Telegram. If the message did not arrive — check the correctness of the token and Chat ID.

Integration with Slack and Discord for team collaboration

If you work in a team or manage an SMM agency, it is more convenient to use Slack or Discord for receiving notifications. This allows all employees to see proxy issues in real-time and respond quickly.

Setting up webhook for Slack

1. Open the settings of your Slack workspace
2. Go to the "Apps" → "Incoming Webhooks" section
3. Click "Add to Slack" and choose a channel for notifications (for example, #proxy-monitoring)
4. Copy the Webhook URL — it will look like https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXX
5. Use this URL in your monitoring service settings

The data format for Slack webhook (if the monitoring service supports custom payloads):

{
  "text": "⚠️ Proxy issue",
  "attachments": [
    {
      "color": "danger",
      "fields": [
        {
          "title": "IP Address",
          "value": "185.123.45.67",
          "short": true
        },
        {
          "title": "Problem",
          "value": "Connection timeout",
          "short": true
        }
      ]
    }
  ]
}

Setting up webhook for Discord

1. Open the settings of the Discord channel where notifications need to be sent
2. Go to "Integrations" → "Webhooks"
3. Click "New Webhook" and set a name (for example, "Proxy Monitor")
4. Copy the Webhook URL
5. Add /slack to the end of the URL for compatibility with Slack format

Discord supports message formatting through embeds, allowing you to create beautiful notifications with color coding based on the type of issue.

Ready-made proxy monitoring services with webhook

If you do not want to write your own monitoring script, you can use ready-made services. Here are proven solutions used by arbitrageurs and SMM specialists:

Setting up monitoring in UptimeRobot (example)

UptimeRobot is a popular choice among arbitrageurs due to its free plan and easy setup. Here’s how to set up proxy monitoring:

1. Sign up at uptimerobot.com
2. Click "Add New Monitor"
3. Select the type "HTTP(s)" or "Port" (for checking SOCKS5 proxies)
4. In the URL field, specify a test address that will be checked through the proxy (for example, https://api.ipify.org)
5. Set the check interval (5 minutes is recommended for the free plan)
6. In the "Alert Contacts" section, add a webhook: select the "Webhook" type and paste your Telegram/Slack webhook URL
7. Save the settings

Now every 5 minutes, UptimeRobot will check the availability of the proxy and send a notification to Telegram if it detects a problem. To monitor multiple proxies, create a separate monitor for each IP.

Creating your own monitoring script

For advanced users and those working with a large number of proxies (100+), it is more efficient to create your own monitoring script. This gives complete control over the check parameters and notification format.

Example script in Python

A simple script to check a list of proxies and send notifications to Telegram when problems are detected:

import requests
import time

# Telegram settings
TELEGRAM_TOKEN = "123456789:ABCdefGHIjklMNOpqrsTUVwxyz"
CHAT_ID = "987654321"

# List of proxies to monitor
PROXIES = [
    {"ip": "185.123.45.67", "port": 8080, "user": "user1", "pass": "pass1"},
    {"ip": "185.123.45.68", "port": 8080, "user": "user2", "pass": "pass2"},
]

def check_proxy(proxy):
    """Check the functionality of the proxy"""
    proxy_url = f"http://{proxy['user']}:{proxy['pass']}@{proxy['ip']}:{proxy['port']}"
    proxies = {"http": proxy_url, "https": proxy_url}
    
    try:
        response = requests.get("https://api.ipify.org?format=json", 
                              proxies=proxies, 
                              timeout=10)
        if response.status_code == 200:
            return True, response.json()['ip']
        return False, "HTTP error"
    except Exception as e:
        return False, str(e)

def send_telegram(message):
    """Send notification to Telegram"""
    url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage"
    data = {"chat_id": CHAT_ID, "text": message}
    requests.post(url, data=data)

# Main monitoring loop
while True:
    for proxy in PROXIES:
        is_working, result = check_proxy(proxy)
        
        if not is_working:
            message = f"⚠️ Proxy is not working!\n"
            message += f"IP: {proxy['ip']}:{proxy['port']}\n"
            message += f"Error: {result}"
            send_telegram(message)
        else:
            print(f"✅ Proxy {proxy['ip']} is working (external IP: {result})")
    
    time.sleep(300)  # Check every 5 minutes

Extended version with geolocation check

For arbitrageurs, it is critically important that the IP does not change country. Here is an improved version of the script with a geolocation check:

def check_proxy_geo(proxy, expected_country):
    """Check proxy with geolocation control"""
    proxy_url = f"http://{proxy['user']}:{proxy['pass']}@{proxy['ip']}:{proxy['port']}"
    proxies = {"http": proxy_url, "https": proxy_url}
    
    try:
        # Check IP and geolocation
        response = requests.get("http://ip-api.com/json/", 
                              proxies=proxies, 
                              timeout=10)
        
        if response.status_code == 200:
            data = response.json()
            current_country = data['countryCode']
            current_ip = data['query']
            
            if current_country != expected_country:
                return False, f"Country change: {expected_country} → {current_country}"
            
            return True, f"IP: {current_ip}, Country: {current_country}"
        
        return False, "HTTP error"
    except Exception as e:
        return False, str(e)

# Usage
PROXIES = [
    {"ip": "185.123.45.67", "port": 8080, "user": "user1", "pass": "pass1", "country": "US"},
    {"ip": "185.123.45.68", "port": 8080, "user": "user2", "pass": "pass2", "country": "GB"},
]

for proxy in PROXIES:
    is_working, result = check_proxy_geo(proxy, proxy['country'])
    if not is_working:
        send_telegram(f"⚠️ Problem with {proxy['ip']}: {result}")

Automatic launch via cron

To keep the script running continuously, set it to launch via cron (Linux/Mac) or Task Scheduler (Windows). Here is an example cron job for checking every 5 minutes:

*/5 * * * * /usr/bin/python3 /path/to/proxy_monitor.py

Integration with anti-detect browsers Dolphin Anty and AdsPower

If you are using anti-detect browsers for multi-accounting, you can set up automatic proxy switching when problems are detected. Dolphin Anty and AdsPower support APIs for managing profiles and proxies.

Automatic proxy replacement in Dolphin Anty

Dolphin Anty provides an API for changing profile settings. Here’s how to set up automatic replacement of non-working proxies:

1. Get the API key in the Dolphin Anty settings (Settings → API)
2. Prepare a list of backup proxies for each profile
3. Create a script that automatically changes the proxy via the API when a webhook notification about a problem is received

Example API request to Dolphin Anty for changing the proxy:

import requests

API_KEY = "your_dolphin_api_key"
PROFILE_ID = "12345"
NEW_PROXY = "http://user:pass@new-proxy-ip:port"

url = f"https://anty-api.com/browser_profiles/{PROFILE_ID}"
headers = {"Authorization": f"Bearer {API_KEY}"}
data = {
    "proxy": {
        "type": "http",
        "host": "new-proxy-ip",
        "port": "port",
        "login": "user",
        "password": "pass"
    }
}

response = requests.patch(url, headers=headers, json=data)
if response.status_code == 200:
    print(f"✅ Proxy updated for profile {PROFILE_ID}")
else:
    print(f"❌ Update error: {response.text}")

Setup in AdsPower

AdsPower also supports APIs for automation. The main steps are:

1. Enable Local API in AdsPower settings (Settings → Local API → Enable)
2. Use the endpoint /api/v1/user/update to update the proxy profile
3. Set up a webhook that calls this API when a problem is detected

Best practices for setting up notifications

To ensure that the webhook notification system works effectively and does not create information noise, follow these recommendations:

1. Set notification priorities

Not all problems require immediate action. Divide notifications into three levels:

• Critical (🔴): IP unavailability, platform blocking, geolocation change — require immediate action
• Important (🟡): low speed, high ping — can be fixed within an hour
• Informational (🟢): approaching traffic limit, subscription expiring in 7 days

For critical notifications, use Telegram with sound alerts enabled. Informational ones can be sent to a separate Slack channel or via email.

2. Avoid false positives

Set a delay before sending a notification. If the proxy did not respond once — it may be a temporary failure. Send a notification only if the problem is confirmed by 2-3 consecutive checks.

3. Add context to notifications

A good notification should contain all the necessary information for a quick resolution of the problem:

• IP address and port of the proxy
• Type of problem (timeout, blocking, geo change)
• Time of problem detection
• Which accounts or profiles use this proxy
• Recommended action (for example, "Switch to backup proxy #2")

4. Use different channels for different types of proxies

If you work with different types of proxies (mobile, residential, data center), create separate notification channels for each type. This will simplify problem diagnosis and task distribution within the team.

5. Set up automatic actions

An advanced level is to set up not only notifications but also automatic actions when problems are detected:

• Automatic proxy switching in anti-detect browsers
• Stopping the scraper or auto-posting until the problem is resolved
• Switching to a backup proxy from the pool
• Automatically creating a ticket to the provider's support

6. Keep a log of issues

Set up saving all notifications to a database or Google Sheets. This will help:

• Identify problematic IPs that frequently fail
• Assess the quality of the proxy provider's service
• Build availability graphs for reporting
• Optimize load distribution among proxies

Conclusion

Webhook notifications about proxy issues are not just a convenience, but a necessity for professional work with multi-accounting, traffic arbitrage, and scraping. A properly configured monitoring system can reduce downtime from several hours to 5-15 minutes, which is critically important when working with advertising budgets or managing client accounts.

The main advantages you gain after setting up webhook notifications: instant problem detection (30-60 seconds instead of several hours of manual checking), automation of routine checks (freeing up 1-2 hours a day), prevention of losses from advertising campaign downtime, and the ability to scale to 100+ proxies without increasing the burden on the team.

Start with a simple setup of a Telegram bot and a free monitoring service like UptimeRobot — this will take 10-15 minutes. As the number of proxies grows and tasks become more complex, transition to your own monitoring scripts with automatic replacement of problematic IPs via the API of anti-detect browsers.

If you plan to work seriously with multi-accounting or arbitrage, we recommend using reliable residential proxies with high uptime. This minimizes the number of problems and allows you to focus on business development rather than constantly putting out fires with unavailable IP addresses.