Aperçu

Playwright est une puissante bibliothèque d'automatisation de navigateur qui prend en charge Chromium, Firefox et WebKit. Combinée aux proxys résidentiels ChangeMyIP, elle devient un outil robuste pour le web scraping avancé, permettant de contourner les restrictions géographiques et les limites de débit. Ce tutoriel couvre la configuration de Playwright avec les proxys résidentiels rotatifs ChangeMyIP, la mise en œuvre de la rotation d'IP par requête, la gestion des empreintes de navigateur et le traitement du contenu dynamique.

Prérequis

Node.js 16+ et npm
Un compte ChangeMyIP avec accès aux proxys résidentiels (ou datacenter si vous préférez)
Connaissances de base en JavaScript/Node.js

Comprendre les points de terminaison de proxy résidentiel ChangeMyIP

ChangeMyIP fournit des proxys résidentiels dans plus de 40 pays. Vous pouvez vous authentifier avec un nom d'utilisateur/mot de passe. Le format de point de terminaison pour les proxys HTTP est :

http://<username>:<password>@<proxy-host>:<port>

Pour SOCKS5 :

socks5://<username>:<password>@<proxy-host>:<port>

Remplacez les espaces réservés par les identifiants de votre tableau de bord ChangeMyIP. Les proxys résidentiels rotatifs attribuent une nouvelle IP par requête par défaut, ou vous pouvez maintenir une session persistante (sticky) à l'aide d'un ID de session dans le nom d'utilisateur (consultez la documentation ChangeMyIP). Pour ce tutoriel, nous supposons une rotation.

Étape 1 : Configurer un projet Playwright

Créez un nouveau répertoire et initialisez npm :

mkdir changeMyIP-playwright-scraper
cd changeMyIP-playwright-scraper
npm init -y

Installez Playwright et ses dépendances :

npm install playwright
npx playwright install

Étape 2 : Configurer Playwright pour utiliser un proxy ChangeMyIP

Créez un fichier scraper.js et ajoutez le code suivant. Cela lance un navigateur Chromium avec votre proxy ChangeMyIP :

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

const proxyUrl = 'http://username:password@proxy-host:port'; // Replace with your ChangeMyIP details

(async () => {
  const browser = await chromium.launch({
    proxy: {
      server: proxyUrl,
    },
  });
  const page = await browser.newPage();
  await page.goto('https://httpbin.org/ip');
  const content = await page.textContent('body');
  console.log(content);
  await browser.close();
})();

Exécutez-le avec node scraper.js. Vous devriez voir l'IP du proxy, et non votre IP réelle.

Étape 3 : Mettre en œuvre des proxys rotatifs par requête

Pour le scraping avancé, vous pouvez vouloir une nouvelle IP pour chaque page ou requête. Comme les proxys résidentiels ChangeMyIP tournent par défaut à chaque requête, vous pouvez simplement créer un nouveau contexte de navigateur pour chaque tâche de scraping. Si vous devez forcer une nouvelle IP, lancez une nouvelle instance de navigateur ou utilisez une nouvelle session proxy.

Voici une fonction qui scrape une URL avec une nouvelle IP à chaque fois :

async function scrapeWithNewIP(url) {
  const browser = await chromium.launch({
    proxy: { server: proxyUrl },
  });
  const page = await browser.newPage();
  await page.goto(url, { waitUntil: 'networkidle' });
  const data = await page.evaluate(() => document.body.innerText);
  await browser.close();
  return data;
}

Appelez cette fonction pour chaque URL cible. Pour plus d'efficacité, réutilisez le navigateur et créez un nouveau contexte avec un proxy différent (si votre forfait autorise plusieurs points de terminaison). Sinon, lancer un nouveau navigateur est acceptable pour une échelle modérée.

Étape 4 : Gérer les empreintes de navigateur pour éviter les blocages

Les systèmes anti-bot détectent l'automatisation. Randomisez les propriétés du navigateur par session. Playwright permet de définir l'user agent, le viewport, le fuseau horaire, et plus encore. Utilisez une bibliothèque comme playwright-extra avec puppeteer-extra-plugin-stealth (compatible avec Playwright via playwright-extra). Ou définissez manuellement les en-têtes.

Exemple : lancer avec un user agent et un viewport personnalisés :

const browser = await chromium.launch({
  proxy: { server: proxyUrl },
});
const context = await browser.newContext({
  userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
  viewport: { width: 1920, height: 1080 },
  locale: 'en-US',
  timezoneId: 'America/New_York',
});

Faites tourner les user agents à partir d'une liste pour chaque session.

Étape 5 : Scraper du contenu dynamique et gérer la pagination

Playwright attend automatiquement les éléments. Utilisez page.waitForSelector pour le contenu dynamique. Pour le défilement infini, faites défiler jusqu'à ce qu'aucun nouvel élément ne se charge.

Exemple : scraper les titres de produits depuis une page e-commerce avec défilement infini :

async function scrapeProducts(page) {
  await page.goto('https://example.com/products', { waitUntil: 'networkidle' });
  let previousHeight = 0;
  while (true) {
    const currentHeight = await page.evaluate(() => document.body.scrollHeight);
    if (currentHeight === previousHeight) break;
    previousHeight = currentHeight;
    await page.evaluate(() => window.scrollTo(0, document.body.scrollHeight));
    await page.waitForTimeout(2000);
  }
  const products = await page.evaluate(() => {
    return Array.from(document.querySelectorAll('.product-title')).map(el => el.innerText);
  });
  return products;
}

Étape 6 : Mettre en œuvre une logique de nouvelle tentative avec de nouvelles IP

Lorsqu'une requête échoue (par ex. CAPTCHA, délai d'attente), réessayez avec une nouvelle IP. Comme les proxys rotatifs changent d'IP à chaque requête, un simple nouvel essai peut suffire. Pour les sessions persistantes (sticky), vous pouvez changer l'ID de session.

async function scrapeWithRetry(url, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    const browser = await chromium.launch({ proxy: { server: proxyUrl } });
    try {
      const page = await browser.newPage();
      await page.goto(url, { timeout: 30000 });
      const data = await page.content();
      await browser.close();
      return data;
    } catch (error) {
      console.error(`Attempt ${i + 1} failed: ${error.message}`);
      await browser.close();
    }
  }
  throw new Error(`Failed after ${maxRetries} retries`);
}

Dépannage

Erreur d'authentification : Vérifiez le nom d'utilisateur et le mot de passe. Assurez-vous qu'ils sont encodés en URL s'ils contiennent des caractères spéciaux.
Connexion au proxy refusée : Vérifiez l'hôte et le port du proxy. Assurez-vous que votre IP est autorisée si vous utilisez l'authentification par IP (ChangeMyIP prend en charge nom d'utilisateur/mot de passe, alors utilisez celle-ci).
CAPTCHA ou blocage : Faites tourner les user agents et introduisez des délais aléatoires. Utilisez des proxys résidentiels pour de meilleurs taux de réussite.
Performances lentes : Réduisez les instances de navigateur, utilisez le mode headless et bloquez les ressources inutiles (images, CSS) avec page.route.
Session persistante (sticky) non fonctionnelle : Consultez la documentation ChangeMyIP pour le format correct d'ID de session dans le nom d'utilisateur.

Résumé

Vous avez appris à intégrer les proxys résidentiels ChangeMyIP avec Playwright pour le web scraping avancé. En faisant tourner les IP, en gérant les empreintes de navigateur et en traitant le contenu dynamique, vous pouvez scraper à grande échelle tout en évitant les blocages. N'oubliez pas de respecter les conditions d'utilisation des sites web et le fichier robots.txt. Le réseau de proxys résidentiels de ChangeMyIP offre plus de 40 pays et plusieurs protocoles, ce qui en fait un choix adapté à ces tâches.