# Configurazione proxy Playwright con IP residenziali rotanti (Python e Node.js)

> Configurazione proxy Playwright in Python e Node.js: proxy residenziali autenticati per browser o contesto, sessioni sticky, pagine leggere.

- URL: https://crawlrelay.com/it/docs/playwright/
- Ultimo aggiornamento: 2026-10-13
- Publisher: CrawlRelay (https://crawlrelay.com)

Assegna il proxy al lancio per un'uscita per browser, oppure per contesto per un paese o una sessione sticky per contesto. Poi riduci il traffico bloccando ciò che non ti serve.

**Risposta rapida — Come uso un proxy autenticato in Playwright?**

Passa un oggetto `proxy` con `server`, `username` e `password` a `launch()` o a `new_context()`: `server` è `http://gw.crawlrelay.com:7777`, e le credenziali vanno nei loro campi dedicati, mai nell’URL del server. Con proxy residenziali **CrawlRelay**, inserisci il paese e un ID sessione nello username per dare a ogni contesto la sua uscita. Il traffico costa 0,50 USD/GB da 50 GB. Pagamento in crypto, senza KYC.

## Configurazione di Playwright a colpo d’occhio

| Attributo | Valore |
| --- | --- |
| Opzione proxy | `{"server": "http://gw.crawlrelay.com:7777", "username": ..., "password": ...}` |
| Dove | `launch(proxy=...)` per tutto il browser, oppure `new_context(proxy=...)` per contesto |
| Porta | Porta HTTP 7777; siti HTTPS passano tramite CONNECT |
| SOCKS5 | Chromium non supporta l’autenticazione SOCKS5: usa la porta HTTP |
| Un IP per contesto | `-session-<id>-ttl-<minutes>` nello username del contesto |
| Costo tipico per pagina | Circa 2 MB con ogni risorsa; poche centinaia di KB bloccando immagini, font e media |

## Come do a ogni contesto browser il suo paese o sessione?

Crea un contesto per paese o per sessione sticky. I contesti sono economici rispetto ai browser e ognuno conserva i suoi cookie, storage e credenziali proxy. Abbina la località del contesto al paese di uscita così il sito vede un visitatore coerente.

*Python (API sync): un contesto per paese*

```python
from playwright.sync_api import sync_playwright

GATEWAY = "http://gw.crawlrelay.com:7777"
LOCALES = {"us": "en-US", "de": "de-DE", "jp": "ja-JP"}

with sync_playwright() as p:
    browser = p.chromium.launch()
    for country, locale in LOCALES.items():
        context = browser.new_context(
            proxy={"server": GATEWAY, "username": "USERNAME-country-%s" % country, "password": "PASSWORD"},
            locale=locale,
        )
        page = context.new_page()
        page.goto("https://api.ipify.org", wait_until="domcontentloaded")
        print(country, page.inner_text("body"))
        context.close()
    browser.close()
```

## Come imposto il proxy in Playwright per Node.js e riduco il traffico?

L’opzione ha la stessa forma in Node.js. La maggior parte del peso di una pagina renderizzata sono immagini, font e media: la pagina mediana pesava 2.164 KB su mobile secondo l’HTTP Archive Web Almanac 2025. Se ti servono solo testo e link, blocca quelle richieste in un handler di routing.

*Node.js: sessione sticky al lancio, risorse pesanti bloccate*

```javascript
import { chromium } from "playwright";

const browser = await chromium.launch({
  proxy: {
    server: "http://gw.crawlrelay.com:7777",
    username: "USERNAME-country-us-session-pw1-ttl-30",
    password: "PASSWORD",
  },
});
const context = await browser.newContext();
// Images, fonts and media are most of a page's bytes
await context.route("**/*", (route) =>
  ["image", "font", "media"].includes(route.request().resourceType()) ? route.abort() : route.continue()
);
const page = await context.newPage();
const response = await page.goto("https://example.com/", { waitUntil: "domcontentloaded" });
console.log(response.status(), await page.title());
await browser.close();
```

## Come faccio a far girare tante pagine in parallelo con asyncio?

Usa l'API async con un pool fisso di contesti. Ogni contesto mantiene una sessione sticky per tutta la sua durata, così il sito vede pochi visitatori stabili invece di un IP per richiesta. Ricicla il contesto, con un nuovo ID sessione, dopo un certo numero di pagine o dopo un errore.

*Python (API async): pool di contesti sticky*

```python
import asyncio
import uuid

from playwright.async_api import async_playwright

GATEWAY = "http://gw.crawlrelay.com:7777"
WORKERS = 4


async def worker(browser, queue):
    session = uuid.uuid4().hex[:10]
    context = await browser.new_context(proxy={
        "server": GATEWAY,
        "username": "USERNAME-country-us-session-%s-ttl-30" % session,
        "password": "PASSWORD",
    })
    page = await context.new_page()
    while not queue.empty():
        url = await queue.get()
        try:
            response = await page.goto(url, wait_until="domcontentloaded", timeout=45000)
            print(session, url, response.status if response else None)
        except Exception as exc:  # timeouts and network errors: log and move on
            print(session, url, type(exc).__name__)
        finally:
            queue.task_done()
    await context.close()


async def main(urls):
    queue = asyncio.Queue()
    for url in urls:
        queue.put_nowait(url)
    async with async_playwright() as p:
        browser = await p.chromium.launch()
        await asyncio.gather(*(worker(browser, queue) for _ in range(WORKERS)))
        await browser.close()


asyncio.run(main(["https://example.com/", "https://example.org/"]))
```

## Perché mi dà ERR_TUNNEL_CONNECTION_FAILED o ERR_PROXY_CONNECTION_FAILED?

- **net::ERR_TUNNEL_CONNECTION_FAILED** significa che il proxy non ha accettato la richiesta CONNECT. Spesso le credenziali erano dentro `server` invece che `username` e `password`, quindi Chromium non le ha inviate. Vedi [l’errore tunnel](https://crawlrelay.com/it/docs/errors/err-tunnel-connection-failed/).
- **net::ERR_PROXY_CONNECTION_FAILED** significa che il browser non ha raggiunto il gateway: errore nell’host o nella porta, o rete che blocca la porta. Vedi [l’errore connessione proxy](https://crawlrelay.com/it/docs/errors/err-proxy-connection-failed/).
- **Timeout 30000ms superato** su `goto` di solito significa che aspetti `load` o `networkidle` su una pagina che continua a caricare tracker. Aspetta `domcontentloaded` poi il selettore che ti serve.

## Cosa non deve fare uno scraper Playwright?

Usa Playwright per renderizzare pagine pubbliche che richiedono JavaScript, non per impersonare persone. La [Acceptable Use Policy](https://crawlrelay.com/it/acceptable-use/) di CrawlRelay vieta usare browser tramite il nostro gateway per creare account in massa, prendere il controllo di account, risolvere CAPTCHA automaticamente o aggirare blocchi intenzionali di un sito. Non documentiamo plugin stealth o spoofing di fingerprint. Se un sito sfida il tuo browser, rallenta, controlla robots.txt e termini, chiedi accesso o usa la sua API.

## Playwright e proxy: domande

### Posso usare un proxy diverso per ogni contesto Playwright?

Sì. Passa `proxy` a `browser.new_context()` in Python o `browser.newContext()` in Node.js. Ogni contesto avrà così la sua uscita, cookie e storage. Le versioni molto vecchie di Playwright su Windows richiedevano un proxy al lancio; se hai quell’errore, lancia con un proxy placeholder e imposta quello reale per contesto.

### Playwright supporta proxy SOCKS5 con autenticazione?

No in Chromium, che non supporta l’autenticazione SOCKS5 con username e password. Usa la porta HTTP del gateway (7777): gestisce siti HTTPS tramite tunnel CONNECT e supporta username e password in tutti i motori browser che Playwright controlla.

### Come verifico quale IP e paese usa una pagina Playwright?

Apri `https://api.ipify.org` nello stesso contesto prima della pagina target e leggi il testo del body, come nel primo esempio. Ricorda che una sessione sticky mantiene quell’IP solo finché il dispositivo residenziale resta online; registra l’IP all’inizio di ogni contesto per individuare cambiamenti.

### Quanto traffico usa una pagina Playwright tramite proxy?

Tutto è conteggiato: HTML, script, stili, immagini, font e chiamate API. Una pagina completa pesa circa 2 MB in media; bloccare immagini, font e media spesso riduce a poche centinaia di KB. Misura le tue pagine reali sommando le dimensioni delle risposte in un handler `response` per 50 pagine.

### Conviene usare browser headless o con interfaccia per scraping?

Headless è la scelta normale per i server e consuma meno risorse. Usa un browser con interfaccia solo per debug. Nessuno modifica le regole: visualizza pagine pubbliche con un ritmo corretto e rispetta robots.txt e termini del sito.

**Renderizza pagine pubbliche tramite IP residenziali** 5,94 USD per 10 GB, 0,50 USD/GB da 50 GB. [Vedi i prezzi](https://crawlrelay.com/it/pricing/) · [Guida Puppeteer](https://crawlrelay.com/it/docs/puppeteer/)

---

CrawlRelay: CrawlRelay è un servizio di proxy residenziali rotanti e proxy mobili 4G/5G primo per sviluppatori: traffico pay-as-you-go senza scadenza da 0,50 USD/GB, pagato in crypto, senza caricamento documenti. Senza KYC — niente documento, selfie o altri documenti. Paga in crypto.