Surveillance des tickets d'événement avec gestion CAPTCHA

Les plateformes de billetterie utilisent des CAPTCHA pour empêcher les contrôles et les achats automatisés. Lors de la surveillance de la disponibilité des billets pour des événements (concerts, sports, théâtre), votre scraper sera confronté aux défis reCAPTCHA, aux protections Cloudflare et à la limitation de débit. CaptchaAI gère la résolution CAPTCHA afin que votre moniteur puisse vérifier la disponibilité de manière fiable.

Ce guide crée un flux de travail de surveillance des tickets avec résolution CAPTCHA intégrée.

Le flux de travail de surveillance

Configure events → Check availability → CAPTCHA?
                                           ↓ Yes
                                      Solve via CaptchaAI → Retry
                                           ↓ No
                                      Parse availability → Changed?
                                                             ↓ Yes
                                                         Send alert

Ce dont vous avez besoin

pip install requests

Aide au solveur CAPTCHA

import requests
import time

API_KEY = "YOUR_API_KEY"


def solve_captcha(method, params):
    """Generic CaptchaAI solver for any supported method."""
    params["key"] = API_KEY
    params["json"] = 1

    submit = requests.post("https://ocr.captchaai.com/in.php", data=params).json()

    if submit.get("status") != 1:
        raise RuntimeError(f"Submit error: {submit.get('request')}")

    task_id = submit["request"]
    initial_wait = 10 if method == "turnstile" else 20
    time.sleep(initial_wait)

    for _ in range(30):
        result = requests.get("https://ocr.captchaai.com/res.php", params={
            "key": API_KEY, "action": "get", "id": task_id, "json": 1
        }).json()
        if result.get("status") == 1:
            return result["request"]
        if result.get("request") != "CAPCHA_NOT_READY":
            raise RuntimeError(f"Solve error: {result['request']}")
        time.sleep(5)
    raise TimeoutError("Solve timed out")

Moniteur de billets

from datetime import datetime
import json


class TicketMonitor:
    def __init__(self, proxy=None):
        self.session = requests.Session()
        self.session.headers.update({
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
        })
        if proxy:
            self.session.proxies = {
                "http": f"http://{proxy}",
                "https": f"http://{proxy}"
            }
        self.last_status = {}

    def check_event(self, event):
        """Check ticket availability for an event, solving CAPTCHAs if needed."""
        url = event["url"]
        response = self.session.get(url)

        # Handle CAPTCHA if detected
        if "g-recaptcha" in response.text or "recaptcha" in response.text:
            sitekey = self._extract_sitekey(response.text)
            if sitekey:
                token = solve_captcha("userrecaptcha", {
                    "method": "userrecaptcha",
                    "googlekey": sitekey,
                    "pageurl": url
                })
                response = self.session.post(url, data={
                    "g-recaptcha-response": token
                })

        elif "cf-turnstile" in response.text:
            sitekey = self._extract_turnstile_key(response.text)
            if sitekey:
                token = solve_captcha("turnstile", {
                    "method": "turnstile",
                    "sitekey": sitekey,
                    "pageurl": url
                })
                response = self.session.post(url, data={
                    "cf-turnstile-response": token
                })

        # Parse availability
        availability = self._parse_availability(response.text, event)

        # Check for changes
        event_key = event["name"]
        if event_key in self.last_status:
            if availability != self.last_status[event_key]:
                self._send_alert(event, availability)

        self.last_status[event_key] = availability
        return availability

    def _extract_sitekey(self, html):
        if 'data-sitekey="' in html:
            start = html.index('data-sitekey="') + 14
            end = html.index('"', start)
            return html[start:end]
        return None

    def _extract_turnstile_key(self, html):
        if 'data-sitekey="' in html:
            start = html.index('data-sitekey="') + 14
            end = html.index('"', start)
            return html[start:end]
        return None

    def _parse_availability(self, html, event):
        """Parse ticket availability. Customize per ticketing site."""
        available = "sold out" not in html.lower()
        return {
            "event": event["name"],
            "available": available,
            "checked_at": datetime.now().isoformat()
        }

    def _send_alert(self, event, availability):
        """Send availability change notification."""
        status = "AVAILABLE" if availability["available"] else "SOLD OUT"
        print(f"[ALERT] {event['name']}: {status}")

    def monitor_all(self, events):
        """Check all events and return results."""
        results = []
        for event in events:
            try:
                result = self.check_event(event)
                results.append(result)
                print(f"[OK] {event['name']}: {'available' if result['available'] else 'sold out'}")
            except Exception as e:
                print(f"[ERROR] {event['name']}: {e}")
        return results


# Usage
events = [
    {
        "name": "Concert - Madison Square Garden - Aug 15",
        "url": "https://example-tickets.com/event/12345"
    },
    {
        "name": "Basketball Finals - Game 7",
        "url": "https://example-tickets.com/event/67890"
    }
]

monitor = TicketMonitor(proxy="user:pass@proxy.example.com:8080")
results = monitor.monitor_all(events)

for r in results:
    print(json.dumps(r, indent=2))

Résultat attendu :

[OK] Concert - Madison Square Garden - Aug 15: available
[OK] Basketball Finals - Game 7: sold out

Planification

Effectuez des contrôles à intervalles réguliers :

# Check every 15 minutes
*/15 * * * * cd /path/to/project && python ticket_monitor.py >> /var/log/tickets.log 2>&1

Dépannage

FAQ

À quelle fréquence dois-je vérifier la disponibilité des billets ?

Toutes les 10 à 30 minutes pour la surveillance générale. Pour les événements à forte demande, toutes les 2 à 5 minutes – mais attendez-vous à davantage de CAPTCHA à des fréquences plus élevées.

Quels CAPTCHA les sites de billetterie utilisent-ils ?

Le plus souvent, les pages reCAPTCHA v2, Cloudflare Turnstile et Cloudflare Challenge. Les systèmes de file d'attente comme les salles d'attente virtuelles peuvent utiliser des défis personnalisés.

Puis-je surveiller plusieurs plateformes de billetterie ?

Oui. Personnalisez l'analyseur pour la structure HTML de chaque plateforme et ajoutez des événements provenant de différents sites.

Ai-je besoin de procurations résidentielles ?

Oui. Les sites de tickets bloquent de manière agressive les adresses IP des centres de données. Les proxys résidentiels réduisent la fréquence des CAPTCHA.

Comment gérer les salles d'attente/queues ?

Les salles d’attente sont séparées des CAPTCHA. Votre moniteur doit détecter les pages de file d'attente et attendre ou réessayer. CaptchaAI résout le CAPTCHA qui apparaît après la file d'attente.

Obtenez votre clé API CaptchaAI

Commencez à surveiller la disponibilité des billets àcaptchaai.com. Gérez automatiquement les CAPTCHA dans votre flux de travail de surveillance des événements.

Guides associés

• Comment résoudre reCAPTCHA v2 à l'aide de l'API
• Comment résoudre Cloudflare Turnstile à l'aide de l'API
• Automatisation de l'achat de billets avec la résolution de CAPTCHA
• Implémentation d'une logique de nouvelle tentative avec CaptchaAI