Pourquoi Playwright pour le scraping à base de proxy
Playwright est un cadre moderne d'automatisation de navigateur de Microsoft qui prend en charge Chrome, Firefox et WebKit. Contrairement aux bibliothèques HTTP seulement, Playwright rend des pages complètes — en exécutant JavaScript, en gérant du contenu dynamique et en passant des contrôles anti-bot qui rejettent les requêtes HTTP brutes.
En cas de combinaison avec Proxies résidentielles, Playwright devient l'un des outils les plus efficaces pour la collecte de données à partir de sites Web fortement protégés. Ce guide couvre la configuration proxy à tous les niveaux: dans tout le navigateur, par contexte et par page — avec le code de travail que vous pouvez copier directement dans vos projets.
Ce guide suppose que vous avez un compte ProxyHat. Si vous êtes nouveau à proxies, commencez par Qu'est-ce qu'un serveur mandataire? et ensuite revoir notre meilleurs proxies pour le grattage de toile Aperçu général.
Installation et configuration
Node.js (primaire)
# Install Playwright
npm init -y
npm install playwright
# Download browser binaries
npx playwright install chromium
Python
# Install Playwright for Python
pip install playwright
python -m playwright install chromium
Configuration de proxy au niveau du navigateur
L'approche la plus simple définit un proxy au lancement du navigateur. Chaque contexte et page hérite automatiquement de ce proxy.
Node.js — Proxy à l'aide du navigateur
const { chromium } = require('playwright');
(async () => {
const browser = await chromium.launch({
proxy: {
server: 'http://gate.proxyhat.com:8080',
username: 'USERNAME',
password: 'PASSWORD',
},
});
const page = await browser.newPage();
await page.goto('https://httpbin.org/ip');
console.log(await page.textContent('body'));
await browser.close();
})();
Python — Proxy à l'aide du navigateur
from playwright.sync_api import sync_playwright
with sync_playwright() as p:
browser = p.chromium.launch(
proxy={
"server": "http://gate.proxyhat.com:8080",
"username": "USERNAME",
"password": "PASSWORD",
}
)
page = browser.new_page()
page.goto("https://httpbin.org/ip")
print(page.text_content("body"))
browser.close()
Rotation de proxy par contexte
Le vrai pouvoir de Playwright réside dans contextes du navigateur. Chaque contexte est une session isolée — cookies séparés, stockage et cache — et peut avoir son propre mandataire. C'est le modèle recommandé pour la rotation proxy car il évite les frais généraux de lancement d'un nouveau navigateur pour chaque IP.
Node.js — Rotation par contexte
const { chromium } = require('playwright');
const crypto = require('crypto');
async function createProxiedContext(browser) {
const sessionId = crypto.randomBytes(4).toString('hex');
const context = await browser.newContext({
proxy: {
server: 'http://gate.proxyhat.com:8080',
username: `USERNAME-session-${sessionId}`,
password: 'PASSWORD',
},
});
return context;
}
(async () => {
// Launch browser WITHOUT a proxy — set it per context
const browser = await chromium.launch();
const urls = [
'https://example.com/page/1',
'https://example.com/page/2',
'https://example.com/page/3',
];
for (const url of urls) {
const context = await createProxiedContext(browser);
const page = await context.newPage();
try {
await page.goto(url, { timeout: 30000 });
const content = await page.content();
console.log(`Fetched ${url} — ${content.length} chars`);
} catch (err) {
console.error(`Failed ${url}: ${err.message}`);
} finally {
await context.close(); // Releases the session
}
}
await browser.close();
})();
Python — Rotation par contexte
import uuid
from playwright.sync_api import sync_playwright
def create_proxied_context(browser):
session_id = uuid.uuid4().hex[:8]
context = browser.new_context(
proxy={
"server": "http://gate.proxyhat.com:8080",
"username": f"USERNAME-session-{session_id}",
"password": "PASSWORD",
}
)
return context
with sync_playwright() as p:
browser = p.chromium.launch()
urls = [
"https://example.com/page/1",
"https://example.com/page/2",
"https://example.com/page/3",
]
for url in urls:
context = create_proxied_context(browser)
page = context.new_page()
try:
page.goto(url, timeout=30000)
print(f"Fetched {url} — {len(page.content())} chars")
except Exception as e:
print(f"Failed {url}: {e}")
finally:
context.close()
browser.close()
Contextes géographiques
Lors de la suppression de contenus localisés, vous pouvez combiner la géo-cible de ProxyHat avec les paramètres locaux et fuseau horaire de Playwright pour une authenticité maximale. Voir tous les emplacements disponibles sur notre emplacement page.
const { chromium } = require('playwright');
const GEO_PROFILES = {
us: { locale: 'en-US', timezone: 'America/New_York', country: 'us' },
de: { locale: 'de-DE', timezone: 'Europe/Berlin', country: 'de' },
jp: { locale: 'ja-JP', timezone: 'Asia/Tokyo', country: 'jp' },
};
async function createGeoContext(browser, region) {
const profile = GEO_PROFILES[region];
return browser.newContext({
proxy: {
server: 'http://gate.proxyhat.com:8080',
username: `USERNAME-country-${profile.country}`,
password: 'PASSWORD',
},
locale: profile.locale,
timezoneId: profile.timezone,
geolocation: null,
});
}
(async () => {
const browser = await chromium.launch();
for (const region of ['us', 'de', 'jp']) {
const context = await createGeoContext(browser, region);
const page = await context.newPage();
await page.goto('https://example.com/pricing');
console.log(`${region.toUpperCase()}: ${await page.title()}`);
await context.close();
}
await browser.close();
})();
Scraping simultané avec le groupe de travailleurs
Les contextes de dramaturge sont légers. Vous pouvez exécuter plusieurs contextes en parallèle, chacun avec une session proxy différente, pour augmenter considérablement le débit.
const { chromium } = require('playwright');
const crypto = require('crypto');
const MAX_CONCURRENCY = 5;
async function scrapeUrl(browser, url) {
const sessionId = crypto.randomBytes(4).toString('hex');
const context = await browser.newContext({
proxy: {
server: 'http://gate.proxyhat.com:8080',
username: `USERNAME-session-${sessionId}`,
password: 'PASSWORD',
},
});
const page = await context.newPage();
try {
await page.goto(url, { timeout: 30000, waitUntil: 'domcontentloaded' });
const title = await page.title();
return { url, title, success: true };
} catch (err) {
return { url, error: err.message, success: false };
} finally {
await context.close();
}
}
async function scrapeAll(urls) {
const browser = await chromium.launch();
const results = [];
// Process in batches of MAX_CONCURRENCY
for (let i = 0; i < urls.length; i += MAX_CONCURRENCY) {
const batch = urls.slice(i, i + MAX_CONCURRENCY);
const batchResults = await Promise.all(
batch.map(url => scrapeUrl(browser, url))
);
results.push(...batchResults);
console.log(`Completed batch ${Math.floor(i / MAX_CONCURRENCY) + 1}`);
}
await browser.close();
return results;
}
// Usage
const urls = Array.from({ length: 20 }, (_, i) =>
`https://example.com/product/${i + 1}`
);
scrapeAll(urls).then(results => {
const success = results.filter(r => r.success).length;
console.log(`Success: ${success}/${results.length}`);
});
Pour des modèles de concordance plus avancés, voir notre guide sur à l'échelle des demandes de procuration avec contrôle de la concordance.
Configuration de vol
Les navigateurs Playwright par défaut ont des marqueurs d'automatisation détectables. Ces paramètres réduisent votre empreinte digitale et aident à contourner systèmes anti-bot.
Paramètres essentiels de vol
const { chromium } = require('playwright');
(async () => {
const browser = await chromium.launch({
args: [
'--disable-blink-features=AutomationControlled',
'--disable-features=IsolateOrigins,site-per-process',
],
});
const context = await browser.newContext({
proxy: {
server: 'http://gate.proxyhat.com:8080',
username: 'USERNAME',
password: 'PASSWORD',
},
userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
viewport: { width: 1920, height: 1080 },
locale: 'en-US',
timezoneId: 'America/New_York',
deviceScaleFactor: 1,
hasTouch: false,
isMobile: false,
javaScriptEnabled: true,
});
// Remove automation markers
await context.addInitScript(() => {
// Override navigator.webdriver
Object.defineProperty(navigator, 'webdriver', {
get: () => undefined,
});
// Override navigator.plugins to look real
Object.defineProperty(navigator, 'plugins', {
get: () => [1, 2, 3, 4, 5],
});
// Override navigator.languages
Object.defineProperty(navigator, 'languages', {
get: () => ['en-US', 'en'],
});
// Override chrome.runtime to avoid detection
window.chrome = { runtime: {} };
});
const page = await context.newPage();
await page.goto('https://bot.sannysoft.com/');
await page.screenshot({ path: 'stealth-test.png' });
await browser.close();
})();
Configuration Python Stealth
from playwright.sync_api import sync_playwright
with sync_playwright() as p:
browser = p.chromium.launch(
args=[
"--disable-blink-features=AutomationControlled",
]
)
context = browser.new_context(
proxy={
"server": "http://gate.proxyhat.com:8080",
"username": "USERNAME",
"password": "PASSWORD",
},
user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
"AppleWebKit/537.36 (KHTML, like Gecko) "
"Chrome/131.0.0.0 Safari/537.36",
viewport={"width": 1920, "height": 1080},
locale="en-US",
timezone_id="America/New_York",
)
context.add_init_script("""
Object.defineProperty(navigator, 'webdriver', {
get: () => undefined,
});
window.chrome = { runtime: {} };
""")
page = context.new_page()
page.goto("https://httpbin.org/headers")
print(page.text_content("body"))
browser.close()
Réessayer la logique avec la rotation par procuration
La combinaison de la logique de ré-essai et de la rotation automatique des proxys permet d'obtenir une nouvelle IP et un nouveau contexte.
const { chromium } = require('playwright');
const crypto = require('crypto');
async function fetchWithRetry(browser, url, maxRetries = 3) {
for (let attempt = 1; attempt <= maxRetries; attempt++) {
const sessionId = crypto.randomBytes(4).toString('hex');
const context = await browser.newContext({
proxy: {
server: 'http://gate.proxyhat.com:8080',
username: `USERNAME-session-${sessionId}`,
password: 'PASSWORD',
},
});
const page = await context.newPage();
try {
const response = await page.goto(url, {
timeout: 30000,
waitUntil: 'domcontentloaded',
});
if (response && response.status() >= 400) {
console.log(`Attempt ${attempt}: HTTP ${response.status()}, retrying...`);
await context.close();
continue;
}
const html = await page.content();
await context.close();
return html;
} catch (err) {
console.log(`Attempt ${attempt} failed: ${err.message}`);
await context.close();
if (attempt === maxRetries) {
throw new Error(`All ${maxRetries} attempts failed for ${url}`);
}
// Exponential backoff
await new Promise(r => setTimeout(r, 1000 * Math.pow(2, attempt - 1)));
}
}
}
(async () => {
const browser = await chromium.launch();
try {
const html = await fetchWithRetry(browser, 'https://example.com/data');
console.log(`Fetched ${html.length} chars`);
} catch (err) {
console.error(err.message);
}
await browser.close();
})();
SOCKS5 Proxy avec dramaturge
ProxyHat prend également en charge SOCKS5 sur le port 1080. Ceci est utile lorsque vous avez besoin de proxy protocole-agnostique ou que vous voulez éviter les frais généraux HTTP CONNECT.
const { chromium } = require('playwright');
(async () => {
const browser = await chromium.launch({
proxy: {
server: 'socks5://gate.proxyhat.com:1080',
username: 'USERNAME',
password: 'PASSWORD',
},
});
const page = await browser.newPage();
await page.goto('https://httpbin.org/ip');
console.log(await page.textContent('body'));
await browser.close();
})();
Profil de scrapage de production
Voici un racleur entièrement prêt à la production qui combine tous les modèles ci-dessus — rotation par proxy par contexte, paramètres furtifs, logique de réessayer, proximité, et extraction de données structurée.
const { chromium } = require('playwright');
const crypto = require('crypto');
const fs = require('fs');
class PlaywrightScraper {
constructor({ concurrency = 3, maxRetries = 3 }) {
this.concurrency = concurrency;
this.maxRetries = maxRetries;
this.browser = null;
this.results = [];
this.stats = { success: 0, failed: 0 };
}
async init() {
this.browser = await chromium.launch({
args: ['--disable-blink-features=AutomationControlled'],
});
}
_createContext() {
const sessionId = crypto.randomBytes(4).toString('hex');
return this.browser.newContext({
proxy: {
server: 'http://gate.proxyhat.com:8080',
username: `USERNAME-session-${sessionId}`,
password: 'PASSWORD',
},
userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
viewport: { width: 1920, height: 1080 },
locale: 'en-US',
});
}
async scrapePage(url) {
for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
const context = await this._createContext();
const page = await context.newPage();
try {
const response = await page.goto(url, {
timeout: 30000,
waitUntil: 'networkidle',
});
if (!response || response.status() >= 400) {
await context.close();
continue;
}
// Extract data — customize this for your target
const data = await page.evaluate(() => ({
title: document.title,
text: document.body.innerText.substring(0, 500),
}));
await context.close();
this.stats.success++;
return { url, ...data, success: true };
} catch (err) {
await context.close();
if (attempt === this.maxRetries) {
this.stats.failed++;
return { url, error: err.message, success: false };
}
await new Promise(r => setTimeout(r, 1000 * attempt));
}
}
}
async scrapeAll(urls) {
await this.init();
for (let i = 0; i < urls.length; i += this.concurrency) {
const batch = urls.slice(i, i + this.concurrency);
const batchResults = await Promise.all(
batch.map(url => this.scrapePage(url))
);
this.results.push(...batchResults);
}
await this.browser.close();
console.log(`Done: ${this.stats.success} OK, ${this.stats.failed} failed`);
return this.results;
}
}
// Usage
const scraper = new PlaywrightScraper({ concurrency: 5, maxRetries: 3 });
const urls = Array.from({ length: 50 }, (_, i) =>
`https://example.com/item/${i + 1}`
);
scraper.scrapeAll(urls).then(results => {
fs.writeFileSync('results.json', JSON.stringify(results, null, 2));
});
Pour construire une couche d'abstraction proxy réutilisable, voir Bâtir un calque mandataire. Explorer les Numéro SDK et Python SDK pour une gestion par procuration simplifiée, et contrôle Prix ProxyHat pour commencer.
