Monitoring Tiket Event dengan Penanganan CAPTCHA

Platform tiket menggunakan CAPTCHA untuk mencegah pengecekan dan pembelian otomatis. Saat memonitor ketersediaan tiket event — konser, olahraga, teater — scraper Anda akan menghadapi tantangan reCAPTCHA, proteksi Cloudflare, dan rate limiting. CaptchaAI menangani solve CAPTCHA sehingga monitor Anda dapat mengecek ketersediaan secara andal.

Panduan ini membangun workflow monitoring tiket dengan solve CAPTCHA terintegrasi.

Alur Kerja Monitoring

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

Yang Anda Butuhkan

pip install requests

Helper Solver 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")

Ticket Monitor

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

Hasil yang diharapkan:

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

Penjadwalan

Jalankan pengecekan secara berkala:

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

Pemecahan Masalah

Pertanyaan Umum

Seberapa sering saya harus mengecek ketersediaan tiket?

Setiap 10–30 menit untuk monitoring umum. Untuk event dengan permintaan tinggi, setiap 2–5 menit — namun harapkan lebih banyak CAPTCHA pada frekuensi lebih tinggi.

CAPTCHA apa yang digunakan situs tiket?

Paling umum reCAPTCHA v2, Cloudflare Turnstile, dan Cloudflare Challenge. Sistem antrian seperti virtual waiting room mungkin menggunakan challenge kustom.

Bisakah saya memonitor beberapa platform tiket?

Ya. Sesuaikan parser untuk setiap struktur HTML platform dan tambahkan event dari situs berbeda.

Apakah saya memerlukan egress jaringan yang diotorisasi?

Ya. Situs tiket secara agresif memblokir IP datacenter. egress jaringan yang diotorisasi mengurangi frekuensi CAPTCHA.

Bagaimana cara menangani virtual waiting room/queue?

Waiting room terpisah dari CAPTCHA. Monitor Anda mendeteksi halaman antrian dan menunggu atau retry. CaptchaAI menyelesaikan CAPTCHA yang muncul setelah antrian.

Mulai Sekarang

Mulai monitor ketersediaan tiket di captchaai.com. Tangani CAPTCHA otomatis dalam workflow monitoring event Anda.

Panduan Terkait

• Cara Solve reCAPTCHA v2 Menggunakan API
• Cara Solve Cloudflare Turnstile Menggunakan API
• Implementasi Retry Logic dengan CaptchaAI