Collecter des données de recherche académique sur des sites protégés par CAPTCHA

Les bases de données académiques et les portails de revues déclenchent souvent un CAPTCHA lorsqu'ils détectent des recherches intensives, des exports répétés ou une navigation trop régulière. Pour les équipes de recherche, les projets de bibliométrie et les workflows de veille scientifique, ce point de friction peut vite bloquer toute automatisation. CaptchaAI permet de gérer ces vérifications dans un flux de collecte plus robuste, tout en respectant les conditions d'accès et les API officielles lorsqu'elles existent.

Où apparaissent les CAPTCHA sur les plateformes académiques ?

L'objectif n'est pas de contourner la logique de ces plateformes, mais de rendre fiable un workflow autorisé de collecte de métadonnées, de citations ou de pages de résultats lorsque le CAPTCHA s'intercale au milieu du processus.

Exemple pratique : collecteur de citations

import requests
import time
import re
from bs4 import BeautifulSoup
import csv

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("Timeout")


class AcademicScraper:
    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 (Windows NT 10.0; Win64; x64) "
            "AppleWebKit/537.36 Chrome/126.0.0.0 Safari/537.36",
            "Accept-Language": "en-US,en;q=0.9",
        })

    def search_papers(self, search_url, query, max_pages=10):
        """Search academic database for papers matching query."""
        all_papers = []

        for page in range(max_pages):
            url = f"{search_url}?q={query}&start={page * 10}"
            resp = self.session.get(url, timeout=30)

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

            papers = self._parse_results(resp.text)
            if not papers:
                break  # No more results

            all_papers.extend(papers)
            print(f"Page {page + 1}: {len(papers)} papers")
            time.sleep(5)  # Respectful delay

        return all_papers

    def get_paper_details(self, paper_url):
        """Get detailed metadata for a single paper."""
        resp = self.session.get(paper_url, timeout=30)

        if self._has_captcha(resp.text):
            resp = self._solve_and_retry(resp.text, paper_url)

        soup = BeautifulSoup(resp.text, "html.parser")
        return {
            "title": self._safe_text(soup, "h1, .article-title"),
            "authors": self._safe_text(soup, ".authors, .author-list"),
            "abstract": self._safe_text(soup, ".abstract, #abstract"),
            "doi": self._safe_text(soup, ".doi, [data-doi]"),
            "journal": self._safe_text(soup, ".journal-name, .publication"),
            "year": self._safe_text(soup, ".pub-date, .year"),
            "citations": self._safe_text(soup, ".citation-count, .cited-by"),
        }

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

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

    def _solve_and_retry(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_results(self, html):
        soup = BeautifulSoup(html, "html.parser")
        papers = []
        for item in soup.select(".gs_r, .search-result, article.result"):
            title_el = item.select_one("h3 a, .result-title a")
            if title_el:
                papers.append({
                    "title": title_el.get_text(strip=True),
                    "url": title_el.get("href", ""),
                    "snippet": self._safe_text(item, ".gs_rs, .abstract-snippet"),
                    "authors": self._safe_text(item, ".gs_a, .author-info"),
                })
        return papers

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


# Usage - Literature review
scraper = AcademicScraper(
    proxy="http://user:pass@residential.proxy.com:5000"
)

papers = scraper.search_papers(
    "https://scholar.example.com/scholar",
    query="machine learning CAPTCHA solving",
    max_pages=5,
)

# Get details for top papers
detailed = []
for paper in papers[:20]:
    if paper["url"]:
        detail = scraper.get_paper_details(paper["url"])
        detailed.append(detail)
        time.sleep(3)

scraper.export_to_csv(detailed, "literature_review.csv")

Cet exemple montre une structure utile en production : une session HTTP stable, une détection explicite du CAPTCHA, une nouvelle soumission après résolution, puis une extraction claire des résultats et des métadonnées. Pour des sources académiques, cette discipline de workflow compte souvent plus qu'un script de scraping rapide.

Analyse bibliométrique et réseaux de citations

def bibliometric_analysis(scraper, seed_papers, depth=2):
    """Follow citations to build a citation network."""
    visited = set()
    network = []

    def _crawl(paper_url, current_depth):
        if current_depth > depth or paper_url in visited:
            return
        visited.add(paper_url)

        try:
            details = scraper.get_paper_details(paper_url)
            network.append(details)

            # Follow "cited by" links
            resp = scraper.session.get(f"{paper_url}/citations", timeout=30)
            if scraper._has_captcha(resp.text):
                resp = scraper._solve_and_retry(resp.text, f"{paper_url}/citations")

            citations = scraper._parse_results(resp.text)
            for cite in citations[:5]:  # Limit breadth
                if cite["url"]:
                    _crawl(cite["url"], current_depth + 1)
                    time.sleep(3)

        except Exception as e:
            print(f"Error crawling {paper_url}: {e}")

    for paper in seed_papers:
        _crawl(paper["url"], 0)

    return network

Quand vous construisez un graphe de citations, il ne suffit pas de lire la première page de résultats. Il faut aussi suivre les liens de citation, limiter la largeur d'exploration et garder un délai fixe entre les requêtes. Sur les portails académiques, un parallélisme trop agressif augmente souvent plus vite le risque de CAPTCHA ou de blocage IP qu'il n'améliore la vitesse réelle de collecte.

Limites de débit recommandées pour les sites académiques

Les plateformes académiques réagissent vite aux adresses IP qui envoient un trafic très régulier ou trop dense. Des délais prudents, une rotation de proxys résidentiels quand c'est nécessaire et l'usage prioritaire des interfaces officielles donnent en général de meilleurs résultats qu'une accélération agressive.

Dépannage

FAQ

Le scraping des bases de données académiques est-il autorisé ?

Cela dépend des conditions d'utilisation de chaque plateforme et du type de données visées. Les métadonnées publiques, comme les titres, auteurs ou résumés, sont parfois accessibles, alors que le texte intégral reste soumis à licence. Si une API officielle existe, comme E-utilities pour PubMed, il faut la privilégier.

Comment réduire le risque de blocage sur Google Scholar ?

Prévoyez au moins 10 secondes entre les requêtes, utilisez des proxys résidentiels pour les volumes importants et fixez un plafond clair du nombre de recherches par heure. Pensez aussi à sauvegarder les résultats intermédiaires pour éviter de rejouer les mêmes requêtes.

Peut-on utiliser CaptchaAI avec un proxy institutionnel ?

Oui. Vous pouvez faire passer la session de navigation par un proxy institutionnel tout en utilisant CaptchaAI pour traiter les CAPTCHA lorsqu'ils apparaissent. Les deux couches sont séparées, mais la cohérence de session, des cookies et des en-têtes reste essentielle.

Guides connexes

• Rotation des proxys residentiels
• Reduire les interruptions CAPTCHA dans le web scraping

Mettez en place un workflow de recherche plus stable : obtenez votre clé CaptchaAI et automatisez la collecte de citations et de métadonnées sans fragiliser votre pipeline.