Python检测QQ域名封禁状态（2025年7月最新版）

介绍

本教程提供2025年7月最新版的Python代码，用于检测域名在QQ平台是否被封禁。通过调用QQ官方API接口，可以获取域名状态信息，返回结果中status为1表示域名正常，为0表示域名被封禁，并包含详细的状态信息。

Python代码

import requests
import time
from typing import Dict, List, Optional
from urllib.parse import urlparse

class QQDomainChecker:
    """
    QQ域名封禁状态检测工具（2025年7月最新版）
    功能特点：
    - 支持单域名和批量检测
    - 自动重试机制（默认3次）
    - 结果缓存（默认30分钟）
    - 详细的错误处理
    - 支持域名格式验证
    - 自动URL标准化处理
    """
    
    VERSION = "2025.07"
    STATUS_NORMAL = 1
    STATUS_BANNED = 0
    STATUS_ERROR = -1
    
    def __init__(self, max_retries: int = 3, cache_time: int = 1800):
        """
        初始化检测器
        :param max_retries: 最大重试次数
        :param cache_time: 结果缓存时间(秒)
        """
        self.api_url = "https://api.wxapi.work/qq/api.php"
        self.headers = {
            'User-Agent': f'QQDomainChecker/{self.VERSION}',
            'Accept': 'application/json',
            'X-Requested-With': 'Python'
        }
        self.timeout = 8
        self.max_retries = max_retries
        self.cache = {}
        self.cache_time = cache_time
    
    def check_domain(self, domain_or_url: str, force_check: bool = False) -> Dict:
        """
        检测域名状态
        :param domain_or_url: 域名或完整URL
        :param force_check: 是否强制刷新缓存
        :return: 标准化检测结果
        """
        # 标准化域名/URL
        domain = self._normalize_domain(domain_or_url)
        if not domain:
            return self._format_error_result(
                domain_or_url, 
                "无效的域名格式"
            )
        
        # 检查缓存
        cache_key = domain.lower()
        if not force_check and cache_key in self.cache:
            cached_result = self.cache[cache_key]
            if time.time() - cached_result['timestamp'] < self.cache_time:
                return cached_result['result']
        
        # 执行检测
        result = self._do_check_with_retry(domain)
        
        # 缓存结果
        self.cache[cache_key] = {
            'result': result,
            'timestamp': time.time()
        }
        
        return result
    
    def batch_check(self, domains: List[str]) -> Dict[str, Dict]:
        """
        批量检测域名状态
        :param domains: 域名列表
        :return: 字典形式的结果 {域名: 结果}
        """
        results = {}
        for domain in domains:
            results[domain] = self.check_domain(domain)
            time.sleep(0.5)  # 避免请求过于频繁
        return results
    
    def _do_check_with_retry(self, domain: str) -> Dict:
        """带重试机制的检测"""
        for attempt in range(self.max_retries):
            try:
                response = requests.get(
                    f"{self.api_url}?url={domain}",
                    headers=self.headers,
                    timeout=self.timeout
                )
                response.raise_for_status()
                return self._parse_response(response.json(), domain)
                
            except requests.exceptions.Timeout:
                if attempt == self.max_retries - 1:
                    return self._format_error_result(domain, "请求超时")
                time.sleep(1)
                
            except requests.exceptions.RequestException as e:
                if attempt == self.max_retries - 1:
                    return self._format_error_result(domain, f"API请求失败: {str(e)}")
                time.sleep(1)
    
    def _parse_response(self, api_response: Dict, original_domain: str) -> Dict:
        """解析API响应"""
        if not isinstance(api_response, dict):
            return self._format_error_result(original_domain, "无效的API响应格式")
        
        # 获取状态码并确保为整数
        status_code = api_response.get("status", self.STATUS_BANNED)
        try:
            status_code = int(status_code)
        except (TypeError, ValueError):
            status_code = self.STATUS_BANNED
        
        return {
            "status": status_code,
            "domain": original_domain,
            "message": api_response.get("message", "未知状态"),
            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
        }
    
    def _normalize_domain(self, domain_or_url: str) -> Optional[str]:
        """标准化域名/URL"""
        if not domain_or_url or not isinstance(domain_or_url, str):
            return None
        
        domain_or_url = domain_or_url.strip()
        
        # 如果没有协议头，添加http://以便解析
        if not domain_or_url.startswith(('http://', 'https://')):
            domain_or_url = 'http://' + domain_or_url
        
        try:
            parsed = urlparse(domain_or_url)
            if not parsed.netloc:
                return None
            return parsed.netloc
        except:
            return None
    
    def _format_error_result(self, domain: str, error_msg: str) -> Dict:
        """格式化错误结果"""
        return {
            "status": self.STATUS_ERROR,
            "domain": domain,
            "message": error_msg,
            "error": True,
            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
        }

def main():
    """主函数"""
    checker = QQDomainChecker()
    
    # 测试案例
    test_cases = [
        {"domain": "baidu.com", "desc": "已知正常的域名"},
        {"domain": "http://example.com", "desc": "带协议的URL"},
        {"domain": "invalid.domain", "desc": "无效域名"},
        {"domain": "", "desc": "空域名"},
        {"domain": "qq.com/path", "desc": "带路径的URL"}
    ]
    
    print(f"QQ域名封禁状态检测报告（{time.strftime('%Y年%m月')}）")
    print("=" * 90)
    print("{:<25} {:<10} {:<15} {:<40}".format(
        "域名", "状态", "代码", "详细信息"))
    print("-" * 90)
    
    for case in test_cases:
        result = checker.check_domain(case["domain"])
        
        # 状态描述
        status_desc = {
            checker.STATUS_NORMAL: "正常",
            checker.STATUS_BANNED: "封禁",
            checker.STATUS_ERROR: "错误"
        }.get(result["status"], "未知")
        
        print("{:<25} {:<10} {:<15} {:<40}".format(
            case["domain"] or "[空域名]",
            status_desc,
            result["status"],
            result["message"]
        ))
        
        time.sleep(1)  # 避免请求过于频繁

if __name__ == "__main__":
    main()

使用方法

1. 安装依赖库：

   pip install requests

2. 基本使用：

   from qq_domain_checker import QQDomainChecker
   
   checker = QQDomainChecker()
   result = checker.check_domain("baidu.com")
   print(result)

3. 批量检测：

   domains = ["baidu.com", "qq.com", "example.com"]
   results = checker.batch_check(domains)

4. 运行结果示例：

   {
     "status": 1,
     "domain": "baidu.com",
     "message": "域名正常",
     "timestamp": "2025-07-16 10:30:00"
   }

   或

   {
     "status": 0,
     "domain": "example.com",
     "message": "域名已被封禁",
     "timestamp": "2025-07-16 10:31:00"
   }

2025年7月更新说明

1. 支持URL和域名两种输入格式
2. 自动标准化处理输入（去除协议、路径等）
3. 改进批量检测性能
4. 优化错误处理机制
5. 添加更详细的状态描述
6. 支持状态码常量（STATUS_NORMAL/STATUS_BANNED/STATUS_ERROR）

返回结果说明

• status:
  • 1 表示域名正常
  • 0 表示域名被封禁
  • -1 表示检测异常
• domain: 检测的域名
• message: 详细的状态信息
• timestamp: 检测时间戳

注意事项

1. 支持输入完整URL或纯域名（自动处理）
2. API有严格的频率限制，建议间隔1秒以上
3. 大量检测建议使用批量模式并添加适当延迟
4. 本工具仅限合法用途使用

高级功能

1. 强制刷新缓存：

   result = checker.check_domain("baidu.com", force_check=True)

2. 自定义缓存时间：

   checker = QQDomainChecker(cache_time=900)  # 15分钟缓存

3. 结果筛选：

   banned_domains = [d for d, r in results.items() if r["status"] == 0]

4. 结果导出：

   import json
   with open("domain_status.json", "w") as f:
       json.dump(results, f, indent=2, ensure_ascii=False)

5. 从文件导入域名列表：

   with open("domains.txt") as f:
       domains = [line.strip() for line in f if line.strip()]
   results = checker.batch_check(domains)