Monitoramento de tickets de eventos com manipulação de CAPTCHA

As plataformas de ingressos usam CAPTCHAs para evitar verificações e compras automatizadas. Ao monitorar a disponibilidade de ingressos para eventos (concertos, esportes, teatro), seu scraper encontrará desafios de reCAPTCHA, proteções Cloudflare e limitação de taxa. CaptchaAI lida com a resolução de CAPTCHA para que seu monitor possa verificar a disponibilidade de maneira confiável.

Este guia cria um fluxo de trabalho de monitoramento de tickets com solução CAPTCHA integrada.

O fluxo de trabalho de monitoramento

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

O que você precisa

pip install requests

Ajudante de resolução 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")

Monitor de tickets

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))

Saída esperada:

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

Agendamento

Execute verificações em intervalos regulares:

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

Solução de problemas

Perguntas frequentes

Com que frequência devo verificar a disponibilidade de ingressos?

A cada 10 a 30 minutos para monitoramento geral. Para eventos de alta demanda, a cada 2 a 5 minutos, mas espere mais CAPTCHAs em frequências mais altas.

Quais CAPTCHAs os sites de ingressos usam?

Mais comumente páginas reCAPTCHA v2, Cloudflare Turnstile e Cloudflare Turnstile em staging. Sistemas de filas, como salas de espera virtuais, podem usar desafios personalizados.

Posso monitorar múltiplas plataformas de tickets?

Sim. Personalize o analisador para a estrutura HTML de cada plataforma e adicione eventos de diferentes sites.

Eu preciso de proxies residenciais?

Sim. Os sites de tickets bloqueiam agressivamente os IPs do datacenter. Os proxies residenciais reduzem a frequência do CAPTCHA.

Como lidar com as salas de espera/queues?

As salas de espera são separadas dos CAPTCHAs. Seu monitor deve detectar páginas da fila e aguardar ou tentar novamente. CaptchaAI resolve o CAPTCHA que aparece após a fila.

Obtenha sua chave API CaptchaAI

Comece a monitorar a disponibilidade de ingressos emcaptchaai.com. Lide com CAPTCHAs automaticamente em seu fluxo de trabalho de monitoramento de eventos.

Guias relacionados

• Como resolver reCAPTCHA v2 usando API
• Como resolver Cloudflare Turnstile usando API
• Automação de compra de ingressos com solução CAPTCHA
• Implementando Lógica de Nova Tentativa com CaptchaAI