Recopilación de datos de investigación de mercado con manejo de CAPTCHA

La investigación de mercado requiere datos de sitios web de la competencia, plataformas de reseñas, bolsas de trabajo y directorios de la industria, la mayoría de los cuales están protegidos por CAPTCHA. CaptchaAI automatiza la resolución para que su flujo de datos permanezca intacto.

Fuentes de datos comunes y sus CAPTCHA

Canal de recopilación de datos

import requests
import time
import re
import csv
import os

API_KEY = os.environ["CAPTCHAAI_API_KEY"]


def solve_captcha(params):
    params["key"] = API_KEY
    resp = requests.get("https://ocr.captchaai.com/in.php", params=params)
    if not resp.text.startswith("OK|"):
        raise Exception(f"Submit: {resp.text}")

    task_id = resp.text.split("|")[1]
    for _ in range(60):
        time.sleep(5)
        result = requests.get("https://ocr.captchaai.com/res.php", params={
            "key": API_KEY, "action": "get", "id": task_id,
        })
        if result.text == "CAPCHA_NOT_READY":
            continue
        if result.text.startswith("OK|"):
            return result.text.split("|", 1)[1]
        raise Exception(f"Solve: {result.text}")
    raise TimeoutError()


class MarketResearchCollector:
    def __init__(self):
        self.session = requests.Session()
        self.session.headers["User-Agent"] = (
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
            "AppleWebKit/537.36 Chrome/120.0.0.0"
        )

    def fetch(self, url):
        """Fetch a page, solving CAPTCHAs as needed."""
        resp = self.session.get(url)

        # Detect reCAPTCHA
        match = re.search(
            r'data-sitekey=["\']([A-Za-z0-9_-]+)["\']', resp.text
        )
        if match:
            token = solve_captcha({
                "method": "userrecaptcha",
                "googlekey": match.group(1),
                "pageurl": url,
            })
            resp = self.session.post(url, data={
                "g-recaptcha-response": token,
            })

        # Detect Turnstile
        match = re.search(
            r'data-sitekey=["\']([0-9x][A-Za-z0-9_-]+)["\']', resp.text
        )
        if match and "cf-turnstile" in resp.text:
            token = solve_captcha({
                "method": "turnstile",
                "sitekey": match.group(1),
                "pageurl": url,
            })
            resp = self.session.post(url, data={
                "cf-turnstile-response": token,
            })

        return resp.text

    def collect_reviews(self, urls):
        """Collect review data from multiple pages."""
        reviews = []
        for url in urls:
            try:
                html = self.fetch(url)
                page_reviews = self._parse_reviews(html)
                reviews.extend(page_reviews)
                print(f"  Collected {len(page_reviews)} reviews from {url}")
                time.sleep(2)  # Polite delay
            except Exception as e:
                print(f"  Error on {url}: {e}")
        return reviews

    def collect_company_profiles(self, urls):
        """Collect company profile data."""
        profiles = []
        for url in urls:
            try:
                html = self.fetch(url)
                profile = self._parse_profile(html)
                if profile:
                    profiles.append(profile)
                    print(f"  Collected: {profile.get('name', 'Unknown')}")
                time.sleep(2)
            except Exception as e:
                print(f"  Error on {url}: {e}")
        return profiles

    def _parse_reviews(self, html):
        """Extract review data from HTML."""
        reviews = []
        # Generic review extraction patterns
        for match in re.finditer(
            r'class="review-text"[^>]*>(.*?)</div>', html, re.DOTALL
        ):
            reviews.append({
                "text": match.group(1).strip()[:500],
            })
        return reviews

    def _parse_profile(self, html):
        """Extract company profile from HTML."""
        name = re.search(r'<h1[^>]*>(.*?)</h1>', html)
        desc = re.search(
            r'class="description"[^>]*>(.*?)</div>', html, re.DOTALL
        )
        return {
            "name": name.group(1).strip() if name else None,
            "description": desc.group(1).strip()[:300] if desc else None,
        }

    def export_csv(self, data, filename):
        """Export collected data to CSV."""
        if not data:
            return
        keys = data[0].keys()
        with open(filename, "w", newline="", encoding="utf-8") as f:
            writer = csv.DictWriter(f, fieldnames=keys)
            writer.writeheader()
            writer.writerows(data)
        print(f"Exported {len(data)} records to {filename}")

Uso

collector = MarketResearchCollector()

# Collect competitor reviews
review_urls = [
    "https://example-reviews.com/product/competitor-a",
    "https://example-reviews.com/product/competitor-b",
    "https://example-reviews.com/product/competitor-c",
]
reviews = collector.collect_reviews(review_urls)
collector.export_csv(reviews, "competitor_reviews.csv")

# Collect company profiles
profile_urls = [
    "https://example-directory.com/company/alpha-corp",
    "https://example-directory.com/company/beta-inc",
]
profiles = collector.collect_company_profiles(profile_urls)
collector.export_csv(profiles, "company_profiles.csv")

Casos de uso

Inteligencia de precios competitivos

Supervise los precios de la competencia en las plataformas de comercio electrónico. Realice un seguimiento de los cambios de precios, promociones y niveles de existencias.

Análisis de sentimiento de marca

Recopile reseñas y calificaciones de plataformas de reseñas. Agregue datos de sentimiento de múltiples fuentes.

Análisis del mercado laboral

Busque ofertas de trabajo para comprender las tendencias de contratación, los rangos salariales y la demanda de habilidades en su industria.

Investigación del panorama de patentes

Recopile solicitudes de patentes de bases de datos públicas para realizar un seguimiento de las tendencias de innovación y la actividad de I+D de la competencia.

Consejos de escala

Preguntas frecuentes

¿Es legal extraer datos de mercado?

Generalmente se permite la extracción de datos públicos. Consulte siempre los términos de servicio del sitio y cumpla con las regulaciones locales. No extraigas datos personales sin consentimiento.

¿Cuánto cuesta esto con CaptchaAI?

El scraping típico de una investigación de mercado activa CAPTCHA en aproximadamente el 30 % de las páginas. Para 1000 páginas/day, espere ~300 resueltas por 0,5-3 dólares en total.

¿Cómo manejo los sitios que bloquean los scrapers por completo?

Combine CaptchaAI con rotación de proxy y patrones de solicitud realistas. Vea nuestroRaspar sin bloquearseguía.

Guías relacionadas

• Monitoreo de precios de comercio electrónico
• Manejo de CAPTCHA para Web Scraping
• Rotación de proxy para raspado CAPTCHA