Erfassung von Social-Media-Forschungsdaten mit CAPTCHA-Verwaltung

Sobald ein automatisierter Scraper mehr als eine Handvoll öffentlicher Profile abruft, antwortet Instagram mit einem reCAPTCHA, Twitter/X mit einer Cloudflare-Turnstile-Abfrage und LinkedIn mit einer Cloudflare Challenge. Für Marktforschung, Markenbeobachtung oder akademische Auswertungen heißt das: Ohne automatisches CAPTCHA-Handling bricht die Datenerfassung nach wenigen Minuten ab. CaptchaAI löst diese Abfragen per API und liefert das Token zurück an Ihre Scraping-Session – der Abruf läuft weiter, ohne manuelles Eingreifen.

Dieser Leitfaden zeigt eine Python-Pipeline für öffentlich zugängliche Social-Media-Daten – und wo Sie Anfragefrequenz, Proxys und CAPTCHA-Handling ansetzen, damit die Erfassung nicht schon nach Minuten stoppt.

Rechtlicher Hinweis: In der EU gelten IP-Adressen und Profildaten als personenbezogene Daten. Prüfen Sie vor jedem Projekt Ihre Rechtsgrundlage nach DSGVO, halten Sie sich an die Nutzungsbedingungen der Plattform und beschränken Sie die Erfassung – wo möglich – auf öffentliche, aggregierte Werte.

Welche Plattform welche CAPTCHA-Abfrage auslöst

Jede Plattform setzt CAPTCHAs an anderen Stellen und in anderer Form ein. Die Übersicht zeigt, womit Sie pro Plattform rechnen müssen:

Anfragefrequenz und Sitzungslimits

Bevor Sie eine Zeile Code schreiben, lohnt der Blick auf die Grenzwerte: Zu viele Anfragen in zu kurzer Zeit lösen mehr CAPTCHAs aus, als jeder Solver auffangen kann. Bleiben Sie pro Plattform unter diesen Richtwerten und beenden Sie Sessions, bevor die Erkennung greift:

Proxy-Wahl pro Plattform

Der passende Proxy-Typ entscheidet oft schon darüber, ob überhaupt ein CAPTCHA erscheint. Grundregel: Was die Plattform von echten Nutzern erwartet, sollte auch Ihr Traffic zeigen.

Der Research-Scraper mit CAPTCHA-Handling

Die Basisklasse kapselt Session, Proxy und CAPTCHA-Erkennung. Trifft der Scraper auf eine Abfrage, liest er den sitekey aus dem HTML, schickt ihn an CaptchaAI und fügt das zurückgelieferte Token in den Folge-Request ein:

import requests
import time
import re

CAPTCHAAI_KEY = "YOUR_API_KEY"
CAPTCHAAI_URL = "https://ocr.captchaai.com"


def solve_captcha(method, sitekey, pageurl, **kwargs):
    data = {
        "key": CAPTCHAAI_KEY,
        "method": method,
        "googlekey": sitekey,
        "pageurl": pageurl,
        "json": 1,
    }
    data.update(kwargs)
    resp = requests.post(f"{CAPTCHAAI_URL}/in.php", data=data)
    task_id = resp.json()["request"]

    for _ in range(60):
        time.sleep(5)
        result = requests.get(f"{CAPTCHAAI_URL}/res.php", params={
            "key": CAPTCHAAI_KEY, "action": "get",
            "id": task_id, "json": 1,
        })
        r = result.json()
        if r["request"] != "CAPCHA_NOT_READY":
            return r["request"]
    raise TimeoutError("Solve timeout")


class SocialMediaResearcher:
    def __init__(self, proxy=None):
        self.session = requests.Session()
        if proxy:
            self.session.proxies = {"http": proxy, "https": proxy}
        self.session.headers.update({
            "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) "
            "AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 "
            "Mobile/15E148 Safari/604.1",
            "Accept-Language": "en-US,en;q=0.9",
        })

    def authenticate(self, login_url, credentials, sitekey):
        """Login with CAPTCHA handling."""
        # Load login page
        self.session.get(login_url)

        # Solve CAPTCHA
        token = solve_captcha("userrecaptcha", sitekey, login_url)

        # Submit login
        resp = self.session.post(login_url, data={
            **credentials,
            "g-recaptcha-response": token,
        })
        return resp.status_code == 200

    def collect_profiles(self, profile_urls):
        """Collect public profile data with CAPTCHA handling."""
        profiles = []

        for url in profile_urls:
            try:
                resp = self.session.get(url, timeout=30)

                # Handle CAPTCHA if triggered
                if self._has_captcha(resp.text):
                    resp = self._handle_captcha(resp.text, url)

                profiles.append({
                    "url": url,
                    "data": self._parse_profile(resp.text),
                    "status": "success",
                })
                time.sleep(5)  # Slow down between profiles

            except Exception as e:
                profiles.append({
                    "url": url,
                    "error": str(e),
                    "status": "failed",
                })

        return profiles

    def _has_captcha(self, html):
        return any(tag in html.lower() for tag in [
            'data-sitekey', 'g-recaptcha', 'cf-turnstile',
            'challenge-platform', 'captcha',
        ])

    def _handle_captcha(self, html, url):
        match = re.search(r'data-sitekey="([^"]+)"', html)
        if not match:
            return self.session.get(url)

        sitekey = match.group(1)

        if 'cf-turnstile' in html:
            token = solve_captcha("turnstile", sitekey, url)
            return self.session.post(url, data={"cf-turnstile-response": token})
        else:
            token = solve_captcha("userrecaptcha", sitekey, url)
            return self.session.post(url, data={"g-recaptcha-response": token})

    def _parse_profile(self, html):
        from bs4 import BeautifulSoup
        soup = BeautifulSoup(html, "html.parser")
        return {
            "name": self._safe_text(soup, "h1, .profile-name"),
            "bio": self._safe_text(soup, ".bio, .profile-bio"),
            "followers": self._safe_text(soup, "[data-followers], .followers"),
            "posts": self._safe_text(soup, "[data-posts], .posts-count"),
        }

    def _safe_text(self, soup, selector):
        el = soup.select_one(selector)
        return el.get_text(strip=True) if el else ""

Der userrecaptcha-Aufruf deckt reCAPTCHA v2 und v3 ab, der turnstile-Aufruf die Cloudflare-Turnstile-Abfrage. Für Plattformen mit reiner Cloudflare Challenge ist zusätzlich der Endpunkt mit der Methode cloudflare_challenge sinnvoll.

Hashtag- und Trend-Analyse

Für Reichweiten- und Trendauswertungen sammeln Sie Beiträge zu einem Hashtag über mehrere Ergebnisseiten. Die CAPTCHA-Prüfung läuft dabei pro Seite automatisch mit:

def research_hashtag(hashtag, platform_url, pages=5):
    """Collect posts for a specific hashtag."""
    researcher = SocialMediaResearcher(
        proxy="http://user:pass@mobile.proxy.com:5000"
    )

    all_posts = []
    for page in range(pages):
        url = f"{platform_url}/explore/tags/{hashtag}?page={page}"
        resp = researcher.session.get(url, timeout=30)

        if researcher._has_captcha(resp.text):
            resp = researcher._handle_captcha(resp.text, url)

        from bs4 import BeautifulSoup
        soup = BeautifulSoup(resp.text, "html.parser")
        posts = soup.select(".post-item, article")
        for post in posts:
            all_posts.append({
                "text": post.get_text(strip=True)[:500],
                "hashtag": hashtag,
                "page": page,
            })

        time.sleep(5)

    return all_posts

Markenerwähnungen automatisiert überwachen

Ein täglicher Scan über mehrere Plattformen liefert eine strukturierte Übersicht, wie oft eine Marke oder ein Keyword erwähnt wird. Der BrandMonitor bündelt Suchbegriffe pro Plattform und protokolliert die Trefferzahl je Keyword:

import json
from datetime import datetime


class BrandMonitor:
    def __init__(self, brand_name, keywords, proxy=None):
        self.brand = brand_name
        self.keywords = keywords
        self.researcher = SocialMediaResearcher(proxy=proxy)

    def daily_scan(self, platform_urls):
        """Run daily brand mention scan across platforms."""
        report = {
            "brand": self.brand,
            "date": datetime.now().isoformat(),
            "platforms": {},
        }

        for name, url in platform_urls.items():
            mentions = []
            for keyword in self.keywords:
                search_url = f"{url}/search?q={keyword}"
                try:
                    resp = self.researcher.session.get(search_url, timeout=30)

                    if self.researcher._has_captcha(resp.text):
                        resp = self.researcher._handle_captcha(
                            resp.text, search_url,
                        )

                    from bs4 import BeautifulSoup
                    soup = BeautifulSoup(resp.text, "html.parser")
                    results = soup.select(".search-result, .post")
                    mentions.append({
                        "keyword": keyword,
                        "count": len(results),
                    })
                    time.sleep(5)
                except Exception as e:
                    mentions.append({
                        "keyword": keyword,
                        "error": str(e),
                    })

            report["platforms"][name] = mentions

        return report


# Usage
monitor = BrandMonitor(
    brand_name="CaptchaAI",
    keywords=["captchaai", "captcha ai", "captcha solver"],
    proxy="http://user:pass@mobile.proxy.com:5000",
)
report = monitor.daily_scan({
    "twitter": "https://twitter-alternative.example.com",
    "reddit": "https://www.reddit.com",
})
print(json.dumps(report, indent=2))

Typische Probleme und Lösungen

Kosten und Threads

CaptchaAI rechnet pro gleichzeitigem Thread ab, nicht pro gelöstem CAPTCHA – und jeder Plan enthält unbegrenzte Lösungen pro Thread. Für Social-Media-Research bestimmt damit allein die Parallelität den Plan, nicht das Datenvolumen. Ein einzelner sequenzieller Scraper kommt mit BASIC (15 $/Monat, 5 Threads) aus. Wer mehrere Plattformen gleichzeitig scannt, skaliert über STANDARD (30 $/Monat, 15 Threads) und ADVANCE (90 $/Monat, 50 Threads). Die Preise sind in US-Dollar angegeben.

Häufige Fragen

Welche Social-Media-CAPTCHAs löst CaptchaAI?

reCAPTCHA v2 und v3, Cloudflare Turnstile und die Cloudflare Challenge – also genau die Typen, die Instagram, Facebook, TikTok, Twitter/X, Reddit und LinkedIn einsetzen. hCaptcha und FunCaptcha werden nicht unterstützt; stellt eine Plattform darauf um, greift die Pipeline für diesen Typ nicht.

Ist das Erfassen öffentlicher Social-Media-Daten in der EU zulässig?

Die Erhebung öffentlich zugänglicher Daten für nichtkommerzielle Forschung ist verbreitet, aber nicht grenzenlos. Gerichte haben das Scraping öffentlicher Daten teils als zulässig eingestuft; in der EU zählen IP-Adressen und Profildaten jedoch als personenbezogen. Prüfen Sie Ihre Rechtsgrundlage nach DSGVO und beachten Sie die Nutzungsbedingungen der jeweiligen Plattform.

Wie viele Threads brauche ich für tägliches Monitoring?

Für einen einzelnen sequenziellen Scraper genügt BASIC (15 $/Monat, 5 Threads). Wer mehrere Plattformen parallel scannt, fährt mit STANDARD (30 $/Monat, 15 Threads) besser, weil jeder gleichzeitige Scan einen Thread belegt. Da pro Thread unbegrenzt gelöst wird, skaliert nur die Parallelität den Plan mit.

Brauche ich mobile Proxys oder reichen Rechenzentrums-Proxys?

Für Instagram und TikTok sind mobile Proxys (4G) klar im Vorteil, weil beide Plattformen mobilen Traffic erwarten. Facebook, Twitter/X und Reddit funktionieren mit Residential-Proxys; Datacenter-IPs werden dort meist schnell markiert. Reine Rechenzentrums-Proxys sind nur für unkritische, öffentliche Endpunkte sinnvoll.

Warum sollte ich zuerst die offizielle Plattform-API prüfen?

Wenn eine offizielle API die benötigten Daten liefert, ist sie fast immer die bessere Wahl – stabiler, dokumentiert und im Einklang mit den Nutzungsbedingungen. Scraping mit CaptchaAI ist für Daten gedacht, die über keine offizielle Schnittstelle verfügbar sind.

Verwandte Leitfäden

• Proxy-Authentifizierung für höhere Erfolgsquoten
• Browser-Sitzungen dauerhaft halten
• Session-State über verteilte Worker teilen

Erfassen Sie öffentliche Social-Media-Daten zuverlässig – holen Sie sich Ihren CaptchaAI-Schlüssel und lösen Sie Plattform-CAPTCHAs automatisch.