Guide complet du scraping pour les dramaturges 2026 - de l'installation à la contournement des anti-bots

Playwright est un outil d'automatisation de navigateur open source largement utilisé pour le crawling de sites Web dynamiques, basé sur les données de 2026. Développé par Microsoft, il permet de contrôler Chromium, Firefox et WebKit avec une seule API et prend en charge à la fois Python et Node.js. Il permet d'exécuter un véritable navigateur dans des environnements où des éléments tels que les pages rendues en JavaScript, les services nécessitant une connexion, ou les flux de défilement infini ne peuvent pas être traités avec des outils comme Requests ou BeautifulSoup.

En résumé
- Playwright est plus rapide que Selenium et prend en charge l'attente automatique, l'interception réseau et le traitement parallèle par défaut
- L'installation se fait en deux lignes de code en Python (pip install playwright + playwright install)
- Avec l'évolution des anti-bots tels que Cloudflare AI Labyrinth en 2025, l'utilisation de playwright-stealth seule atteint ses limites
- L'intégration avec le MCP (Model Context Protocol) ouvre la voie à une ère où les agents d'IA contrôlent directement le navigateur
- Il est recommandé de comparer la construction interne du crawling (590 à 1 030 000 KRW par mois) avec les services gérés (à partir de 300 000 KRW par mois) pour plus de 300 000 requêtes par mois.

Dans cet article, nous couvrirons l'installation de Playwright, des exemples de code de crawling de base et intermédiaire, un tableau comparatif de Selenium et Puppeteer, des stratégies de contournement des anti-bots, l'écosystème MCP et une analyse des coûts.

1. Qu'est-ce que Playwright et pourquoi l'utiliser pour le crawling ?

Playwright est un framework d'automatisation de navigateur open source publié par Microsoft en 2020. Il permet de contrôler les navigateurs Chromium, Firefox et WebKit (moteur de Safari) avec une seule API et prend en charge Python, Node.js, Java et C#.

Du point de vue du crawling, Playwright est remarquable pour trois raisons.

Attente automatique : Lorsque vous sélectionnez un élément avec page.locator(), Playwright attend automatiquement que cet élément apparaisse à l'écran. Il n'est pas nécessaire d'utiliser des méthodes classiques comme time.sleep() pour synchroniser les timings.

Interception réseau : Vous pouvez intercepter et modifier toutes les requêtes HTTP qui se produisent pendant le chargement de la page. Cela permet d'appeler directement des API internes sans passer par l'interface utilisateur Web, ce qui peut considérablement accélérer la collecte de données.

Contextes multiples : Vous pouvez exécuter plusieurs sessions indépendantes simultanément dans une seule instance de navigateur, ce qui rend le crawling parallèle très efficace.

2. Comment choisir entre Playwright, Selenium et Puppeteer ?

Il est courant de se demander quel outil choisir lors du démarrage d'un nouveau projet. Nous avons résumé les principales différences entre ces trois outils dans le tableau ci-dessous.

Recommandation pour 2026 :

• Playwright : Pour les nouveaux projets, les sites Web dynamiques et les cas nécessitant une compatibilité multi-navigateurs
• Selenium : Pour la compatibilité avec les systèmes hérités, notamment les anciens navigateurs comme IE
• Puppeteer : Pour les projets spécifiques à Chrome et les environnements familiers avec l'écosystème Node.js

3. Comment installer Playwright ?

Environnement Python

# Playwright 설치
pip install playwright

# 브라우저 바이너리 설치 (Chromium, Firefox, WebKit 세 가지 모두)
playwright install

# Chromium만 설치하려면
playwright install chromium

Environnement Node.js

# 새 프로젝트 초기화 (대화형 설정)
npm init playwright@latest

# 또는 직접 설치
npm install playwright
npx playwright install

Environnement Docker

Lorsque vous exécutez Playwright sur un serveur plutôt que sur un environnement de développement local, l'utilisation de l'image Docker officielle fournie par Microsoft est la méthode la plus simple.

FROM mcr.microsoft.com/playwright/python:v1.58.0-noble

WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "crawler.py"]

4. Crawling de base - Extraction des premières données en 5 minutes

Exemple en Python : Collecte de titres de news

from playwright.sync_api import sync_playwright

def scrape_headlines():
    with sync_playwright() as p:
        # headless=True 로 설정하면 브라우저 창 없이 실행
        browser = p.chromium.launch(headless=True)
        page = browser.new_page()

        page.goto("https://news.ycombinator.com")

        # 모든 뉴스 제목 선택
        items = page.locator(".titleline > a").all()
        headlines = [item.inner_text() for item in items]

        for i, title in enumerate(headlines[:10], 1):
            print(f"{i}. {title}")

        browser.close()
        return headlines

if __name__ == "__main__":
    scrape_headlines()

Exemple en Node.js : Même tâche

const { chromium } = require('playwright');

async function scrapeHeadlines() {
  const browser = await chromium.launch({ headless: true });
  const page = await browser.newPage();

  await page.goto('https://news.ycombinator.com');

  const headlines = await page.locator('.titleline > a').allInnerTexts();

  headlines.slice(0, 10).forEach((title, i) => {
    console.log(`${i + 1}. ${title}`);
  });

  await browser.close();
  return headlines;
}

scrapeHeadlines();

Il est également possible de sauvegarder des captures d'écran et de générer des fichiers PDF en une seule ligne de code.

# 스크린샷 저장
page.screenshot(path="screenshot.png", full_page=True)

# PDF 저장 (Chromium만 지원)
page.pdf(path="page.pdf")

5. Techniques avancées de crawling

Pagination automatique

from playwright.sync_api import sync_playwright

def scrape_paginated(base_url, max_pages=5):
    results = []
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        page = browser.new_page()

        for page_num in range(1, max_pages + 1):
            page.goto(f"{base_url}?page={page_num}")
            # 요소가 로드될 때까지 대기
            page.wait_for_selector(".product-item")

            items = page.locator(".product-item").all()
            for item in items:
                results.append(item.inner_text())

            # 다음 페이지 버튼이 없으면 종료
            if not page.locator(".next-page").count():
                break

        browser.close()
    return results

Gestion du défilement infini

def scrape_infinite_scroll(url, scroll_count=10):
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        page = browser.new_page()
        page.goto(url)

        prev_count = 0
        for _ in range(scroll_count):
            # 페이지 맨 아래까지 스크롤
            page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
            # 새 콘텐츠 로딩 대기
            page.wait_for_timeout(1500)

            current_count = page.locator(".item").count()
            if current_count == prev_count:
                break  # 더 이상 로딩되지 않으면 종료
            prev_count = current_count

        items = page.locator(".item").all_inner_texts()
        browser.close()
        return items

Interception réseau - Extraction directe d'API

Sur les pages rendues en JavaScript, en capturant directement les réponses des API internes, vous pouvez obtenir des données JSON propres sans avoir à analyser le HTML.

import json

def intercept_api(url):
    captured_data = []

    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        page = browser.new_page()

        # API 응답을 가로채는 핸들러 등록
        def handle_response(response):
            if "api/products" in response.url and response.status == 200:
                try:
                    data = response.json()
                    captured_data.extend(data.get("items", []))
                except Exception:
                    pass

        page.on("response", handle_response)
        page.goto(url)
        page.wait_for_load_state("networkidle")

        browser.close()
    return captured_data

Traitement parallèle de plusieurs pages

from playwright.sync_api import sync_playwright

def scrape_parallel(urls):
    results = {}
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        # BrowserContext로 독립 세션 생성
        context = browser.new_context()

        pages = [context.new_page() for _ in urls]
        for page, url in zip(pages, urls):
            page.goto(url, wait_until="domcontentloaded")

        for page, url in zip(pages, urls):
            results[url] = page.title()

        browser.close()
    return results

Guides connexes : Guide complet du crawling de Coupang | Guide complet du crawling d'Instagram

6. Comment contourner les systèmes anti-bots ? (Dernières techniques de 2026)

Les principales plateformes telles que Coupang, Naver, Instagram utilisent des systèmes anti-bots sophistiqués tels que Cloudflare Turnstile, DataDome, Akamai Bot Manager. Voici les méthodes couramment utilisées en 2026 pour les contourner.

Application de playwright-stealth

playwright-stealth patche les signaux les plus courants utilisés pour détecter les navigateurs headless. Il supprime les propriétés comme navigator.webdriver, modifie l'User-Agent, et masque le rendu WebGL, le tout automatiquement.

pip install playwright-stealth

from playwright.sync_api import sync_playwright
from playwright_stealth import stealth_sync

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()
    stealth_sync(page)  # 스텔스 적용
    page.goto("https://target-site.com")

Rotation de l'User-Agent

import random

USER_AGENTS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36",
]

context = browser.new_context(
    user_agent=random.choice(USER_AGENTS)
)

Configuration de proxy

context = browser.new_context(
    proxy={
        "server": "http://proxy-server:8080",
        "username": "user",
        "password": "password"
    }
)

Simulation de comportement humain

import random

# 마우스 움직임 추가
page.mouse.move(
    random.randint(100, 800),
    random.randint(100, 600)
)

# 자연스러운 타이핑 딜레이
page.locator("#search").type("검색어", delay=random.randint(80, 150))

# 스크롤 후 짧은 대기
page.evaluate("window.scrollBy(0, 300)")
page.wait_for_timeout(random.randint(800, 2000))

Tendances anti-bots majeures de 2026

Cloudflare AI Labyrinth : Nouvelle méthode de défense annoncée par Cloudflare en mars 2025. Au lieu de bloquer les bots, elle les dirige vers un labyrinthe de pages factices générées par l'IA. Si un client explore plus de 4 niveaux, il est automatiquement identifié comme un bot et son empreinte est enregistrée. L'objectif est l'identification et le suivi plutôt que le simple blocage.

Empreinte digitale Canvas/WebGL : Les systèmes anti-bots combinent les résultats du rendu Canvas, les informations du rendu WebGL et les résultats du traitement AudioContext pour créer une empreinte digitale unique du navigateur. Il est difficile de contourner cela uniquement avec playwright-stealth, et il est recommandé d'utiliser des bibliothèques supplémentaires comme browserforge pour masquer cette empreinte.

Limites : Comme mentionné dans la documentation officielle de playwright-stealth, cette bibliothèque ne fait que contourner les détections simples. Face à des systèmes anti-bots de niveau entreprise comme DataDome ou Akamai, l'efficacité des méthodes individuelles de contournement est limitée.

Guides connexes : Guide complet de légalité du crawling

7. Écosystème Playwright de 2026 - MCP et automatisation par l'IA

Serveur MCP Playwright

En 2026, l'intégration la plus remarquable dans l'écosystème Playwright est celle du MCP (Model Context Protocol). En utilisant le package playwright-mcp officiellement distribué par Microsoft, des agents d'IA tels que Claude, GPT, Cursor peuvent contrôler directement le navigateur avec des commandes en langage naturel.

# Claude Desktop에 Playwright MCP 연동
npx @playwright/mcp@latest

Lorsqu'un agent d'IA donne l'instruction "Récupère la liste des produits de cette page", le serveur MCP traduit et exécute cette commande en commandes Playwright, puis renvoie les résultats. Cette méthode permet d'automatiser l'automatisation du navigateur sans avoir à écrire de code.

Cependant, il convient de faire attention à la consommation de jetons. Selon les benchmarks de Microsoft, le MCP Playwright consomme environ 114 000 jetons pour une tâche similaire, tandis que le CLI Playwright en consomme environ 27 000. Pour des tâches répétées à grande échelle, la méthode CLI est plus rentable.

Stagehand / Browser Use

Stagehand (Browserbase) et Browser Use sont des frameworks qui ajoutent une couche d'IA au-dessus de Playwright. En donnant des instructions en langage naturel comme "Clique sur le bouton suivant", l'IA analyse le DOM pour trouver l'élément correspondant et l'active. L'avantage clé est que cela fonctionne sans avoir besoin de recoder même si la structure du site change.

Serveur MCP Hashscraper

Si vous cherchez un serveur MCP dédié au crawling, vous pouvez envisager d'utiliser @scrapi.ai/mcp-server fourni par Hashscraper. Vous pouvez obtenir les résultats du crawling en une seule commande MCP sans avoir à déployer votre propre infrastructure Playwright.

Guides connexes : Guide complet du crawling par agent d'IA

8. Playwright est-il suffisant ? Limites et alternatives réalistes

Limites de Playwright

Bien que Playwright soit un outil puissant, il rencontre plusieurs limites lorsqu'il est utilisé en production de manière continue.

• Blocage IP : Les requêtes répétées à partir de la même IP peuvent entraîner un blocage. La gestion d'un pool de proxies est essentielle, mais obtenir des IP locales peut être difficile.
• Mises à jour des anti-bots : Les systèmes comme Cloudflare, DataDome mettent régulièrement à jour leurs logiques de détection. Ce qui fonctionne aujourd'hui pour contourner les protections peut être bloqué demain.
• Gestion de l'infrastructure : La planification du crawling, la récupération des erreurs, le pipeline de données, les systèmes de surveillance doivent être mis en place.

Comparaison des coûts entre la construction interne et les services gérés

En se basant sur une collecte de données de 30 000 requêtes par mois, les coûts peuvent être comparés comme suit.

Savoir coder et exploiter de manière stable sont deux problèmes différents. Pour un projet secondaire ou un outil interne avec une pile technologique claire, la construction interne avec Playwright est recommandée. Cependant, pour une collecte de données stable à long terme dans un but commercial, il est plus raisonnable de prendre en compte les coûts d'exploitation de l'infrastructure et les risques.

Prenez rendez-vous pour une consultation gratuite avec Hashscraper pour partager vos besoins actuels et obtenir des recommandations optimales avant de déployer votre propre infrastructure Playwright.

Guides connexes : Comparaison des services de crawling web | Guide complet sur le coût de l'externalisation du crawling

9. FAQ

Q1. Le crawling avec Playwright est-il légal ?

La collecte de données publiques est généralement légale dans la plupart des pays. Cependant, des actions telles que l'ignorance des directives du fichier robots.txt d'un site, le contournement des connexions sécurisées, la copie non autorisée de contenus protégés par des droits d'auteur, ou la surcharge des serveurs peuvent poser des problèmes légaux. En Corée, un jugement lié au crawling de Baemin en 2024 a soulevé des questions sur le non-respect des conditions de service et les perturbations des activités. Il est recommandé de consulter un avocat en fonction de l'objectif et de la méthode de collecte de données, surtout pour des crawlings à des fins commerciales. Pour plus de détails, consultez le Guide complet de légalité du crawling.

Q2. Comment choisir entre Playwright et Selenium ?

Pour un nouveau projet en 2026, Playwright est recommandé. Il surpasse Selenium en termes d'attente automatique, de prise en charge multi-navigateurs, de traitement parallèle et de vitesse d'exécution. Selenium est plus adapté pour la compatibilité avec les systèmes hérités et les navigateurs spécifiques comme IE.

Q3. Quelle est la différence entre le mode headless et headed ?

headless=True exécute le navigateur en arrière-plan sans afficher la fenêtre du navigateur. C'est le mode par défaut pour les environnements de serveur. headless=False (mode headed) affiche la fenêtre du navigateur réellement, ce qui est utile pour le débogage car vous pouvez voir l'exécution. Certains systèmes anti-bots détectent plus facilement les navigateurs headless, donc essayer le mode headed peut être une solution.

Q4. Est-il possible de crawler des sites protégés par Cloudflare ?

Les sites protégés par Cloudflare Turnstile ou Bot Management sont difficiles à crawler avec playwright-stealth seul. Même en combinant des IP résidentielles, du masquage d'empreinte digitale et des simulations de comportement humain, le taux de réussite peut être instable. L'AI Labyrinth de 2025 dirige les bots vers un labyrinthe de pages factices pour gaspiller leurs ressources, ce qui rend la détection plus difficile. Pour des crawlings à grande échelle sur Cloudflare, il est plus réaliste d'utiliser des services spécialisés.

Q5. Comment améliorer la vitesse de crawling avec Playwright ?

Les principales méthodes pour améliorer la vitesse de crawling sont les suivantes. Tout d'abord, bloquez les ressources inutiles telles que les images, les polices et les CSS en utilisant l'interception réseau. Ensuite, utilisez BrowserContext pour exécuter plusieurs pages en parallèle. Enfin, si possible, capturez directement les réponses des API internes au lieu de parser le HTML. Ces trois méthodes peuvent souvent multiplier la vitesse par 3 à 5.

Q6. Playwright est-il adapté au crawling à grande échelle ?

L'exécution de Playwright sur un seul serveur est adaptée jusqu'à quelques dizaines de milliers de requêtes par mois. Au-delà, vous devrez mettre en place une file de tâches distribuée (Celery, RQ, etc.), plusieurs serveurs, une gestion de pool de proxies et un système de récupération des erreurs. Si vous collectez plus de 30 000 requêtes par mois, il est temps de comparer et d'envisager un service géré.

Q7. Python ou Node.js, lequel choisir ?

Si vous devez intégrer des données scientifiques, analytiques ou des pipelines de machine learning, Python est