Protecting Ad Accounts from Suspension: A Technical Guide to Proactive Domain Monitoring

Account suspensions cost media buyers thousands. Most are triggered by domain issues that could have been caught early. Here's a proactive monitoring system.

Why Accounts Get Suspended

Domain flagged by Google Safe Browsing — #1 cause
SSL certificate issues — expired or misconfigured
DNS propagation failures — domain resolves inconsistently
Content policy violations — detected by automated crawlers
Traffic pattern anomalies — sudden spikes trigger reviews

Building a Monitoring System

import asyncio
import aiohttp
from datetime import datetime

class DomainMonitor:
    def __init__(self, domains: list[str]):
        self.domains = domains
        self.alerts = []

    async def check_gsb(self, domain: str) -> dict:
        """Check Google Safe Browsing status"""
        # Uses proprietary threat intelligence feed
        status = await self._query_gsb_api(domain)
        return {
            'domain': domain,
            'safe': status == 'clean',
            'threat_type': status if status != 'clean' else None,
            'checked_at': datetime.utcnow().isoformat()
        }

    async def check_ssl(self, domain: str) -> dict:
        """Verify SSL certificate validity"""
        try:
            async with aiohttp.ClientSession() as session:
                async with session.get(f'https://{domain}') as resp:
                    return {'valid': True, 'status': resp.status}
        except aiohttp.ClientSSLError:
            return {'valid': False, 'error': 'SSL verification failed'}

    async def check_dns(self, domain: str) -> dict:
        """Check DNS resolution across multiple nameservers"""
        import socket
        try:
            ips = socket.getaddrinfo(domain, 443)
            return {'resolves': True, 'ip_count': len(set(ip[4][0] for ip in ips))}
        except socket.gaierror:
            return {'resolves': False}

    async def full_check(self):
        results = {}
        for domain in self.domains:
            gsb = await self.check_gsb(domain)
            ssl = await self.check_ssl(domain)
            dns = await self.check_dns(domain)

            health_score = 100
            if not gsb['safe']: health_score -= 50
            if not ssl['valid']: health_score -= 25
            if not dns['resolves']: health_score -= 25

            results[domain] = {
                'health_score': health_score,
                'gsb': gsb,
                'ssl': ssl,
                'dns': dns,
                'action': 'rotate' if health_score < 50 else 'monitor' if health_score < 80 else 'ok'
            }
        return results

# Usage
monitor = DomainMonitor(['campaign1.example.com', 'campaign2.example.com'])
asyncio.run(monitor.full_check())

Alert Integration

Connect to Slack, Telegram, or email for instant notifications:

async def alert_on_issues(results):
    for domain, status in results.items():
        if status['action'] == 'rotate':
            await send_alert(
                f"🚨 CRITICAL: {domain} needs rotation! "
                f"Health: {status['health_score']}/100"
            )
        elif status['action'] == 'monitor':
            await send_alert(
                f"⚠️ WARNING: {domain} degraded. "
                f"Health: {status['health_score']}/100"
            )