# Playwright proxy setup met roterende residentiële IP’s (Python en Node.js)

> Playwright proxy setup in Python en Node.js: geverifieerde residentiële proxy's per browser of context, sticky sessies, lichtere pagina’s.

- URL: https://crawlrelay.com/nl/docs/playwright/
- Laatst bijgewerkt: 2026-10-13
- Publisher: CrawlRelay (https://crawlrelay.com)

Geef de proxy bij het starten voor één uitgang per browser, of per context voor één land of één sticky sessie per context. Snijd dan het verkeer door te blokkeren wat je niet nodig hebt.

**Kort antwoord — Hoe gebruik ik een geauthenticeerde proxy in Playwright?**

Geef een `proxy` object door met `server`, `username` en `password` aan `launch()` of aan `new_context()`: `server` is `http://gw.crawlrelay.com:7777`, en de inloggegevens gaan in aparte velden, nooit in de server-URL. Met **CrawlRelay** residentiële proxy's plaats je het land en een sessie-ID in de gebruikersnaam om elke context een eigen uitgang te geven. Verkeer kost US$ 0,50/GB vanaf 50 GB. Betaalbaar in crypto, zonder KYC.

## Playwright setup in één oogopslag

| Attribuut | Waarde |
| --- | --- |
| Proxy-optie | `{"server": "http://gw.crawlrelay.com:7777", "username": ..., "password": ...}` |
| Waar | `launch(proxy=...)` voor de hele browser, of `new_context(proxy=...)` per context |
| Poort | HTTP-poort 7777; HTTPS-sites gaan via CONNECT |
| SOCKS5 | Chromium ondersteunt geen SOCKS5-authenticatie: gebruik de HTTP-poort |
| Eén IP per context | `-session-<id>-ttl-<minutes>` in de gebruikersnaam van de context |
| Typische paginakosten | Ongeveer 2 MB met alle resources; een paar honderd KB als beelden, lettertypen en media worden geblokkeerd |

## Hoe geef ik elke browsercontext zijn eigen land of sessie?

Maak één context per land of per sticky sessie. Contexten zijn goedkoop vergeleken met browsers, en elke houdt zijn eigen cookies, opslag en proxy-gegevens bij. Laat de locale van de context overeenkomen met het exit-land zodat de site een consistente bezoeker ziet.

*Python (sync API): één context per land*

```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()
```

## Hoe stel ik de proxy in Playwright in voor Node.js en beperk ik verkeer?

De optie heeft dezelfde vorm in Node.js. Het grootste deel van het gewicht van een gerenderde pagina zijn afbeeldingen, lettertypen en media: de mediane pagina woog 2.164 KB mobiel in de HTTP Archive Web Almanac 2025. Als je alleen tekst en links nodig hebt, breek die requests af in een routehandler.

*Node.js: sticky sessie bij lancering, zware resources geblokkeerd*

```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();
```

## Hoe draai ik veel pagina’s parallel met asyncio?

Gebruik de async API met een vaste pool van contexten. Elke context houdt één sticky sessie vast gedurende zijn levensduur, zodat een site een paar stabiele bezoekers ziet in plaats van één IP per request. Hergebruik een context, met een nieuwe sessie-ID, na een bepaald aantal pagina’s of na een fout.

*Python (async API): een pool van sticky contexten*

```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/"]))
```

## Waarom krijg ik ERR_TUNNEL_CONNECTION_FAILED of ERR_PROXY_CONNECTION_FAILED?

- **net::ERR_TUNNEL_CONNECTION_FAILED** betekent dat de proxy het CONNECT-verzoek niet accepteerde. Meestal stonden de inloggegevens in `server` in plaats van `username` en `password`, dus stuurde Chromium niets mee. Zie [de tunnelerror](https://crawlrelay.com/nl/docs/errors/err-tunnel-connection-failed/).
- **net::ERR_PROXY_CONNECTION_FAILED** betekent dat de browser de gateway nooit bereikte: typfout in host of poort, of een netwerk dat de poort blokkeert. Zie [de proxy connectiefout](https://crawlrelay.com/nl/docs/errors/err-proxy-connection-failed/).
- **Timeout 30000ms overschreden** op `goto` betekent meestal dat je wacht op `load` of `networkidle` op een pagina die trackers blijft laden. Wacht op `domcontentloaded` en daarna op de selector die je nodig hebt.

## Wat mag een Playwright scraper niet doen?

Gebruik Playwright om openbare pagina’s te renderen die JavaScript nodig hebben, niet om mensen te imiteren. CrawlRelay’s [Acceptable Use Policy](https://crawlrelay.com/nl/acceptable-use/) verbiedt browsers via onze gateway te gebruiken om accounts in bulk aan te maken, accounts over te nemen, CAPTCHAs automatisch op te lossen of blokkades van een site te omzeilen. We documenteren geen stealth-plugins of fingerprint spoofing. Als een site je browser uitdaagt, vertraag dan, controleer de robots.txt en voorwaarden, vraag toegang aan of gebruik de API.

## Playwright en proxies: veelgestelde vragen

### Kan ik voor elke Playwright-context een andere proxy gebruiken?

Ja. Geef `proxy` door aan `browser.new_context()` in Python of aan `browser.newContext()` in Node.js. Elke context heeft dan zijn eigen uitgang, cookies en opslag. Heel oude Playwright-versies op Windows vereisten ook een proxy bij het opstarten; zie je die fout, start dan met een placeholder proxy en stel de echte per context in.

### Ondersteunt Playwright SOCKS5-proxy’s met authenticatie?

Niet in Chromium, dat SOCKS5-authenticatie met gebruikersnaam en wachtwoord niet ondersteunt. Gebruik de HTTP-poort van de gateway (7777): die handelt HTTPS-sites via CONNECT-tunnels af en ondersteunt gebruikersnaam en wachtwoord in elke browser-engine die Playwright aanstuurt.

### Hoe controleer ik welke IP en welk land een Playwright-pagina gebruikt?

Open `https://api.ipify.org` in dezelfde context vóór je doelpagina en lees de bodytekst uit, zoals in het eerste voorbeeld. Houd er rekening mee dat een sticky sessie dat IP alleen behoudt zolang het residentiële apparaat online is; log het IP aan het begin van elke context om veranderingen te zien.

### Hoeveel verkeer gebruikt een Playwright-pagina via een proxy?

Alles wordt in rekening gebracht: HTML, scripts, stijlen, afbeeldingen, lettertypen en API-aanroepen. Een volledige pagina is gemiddeld ongeveer 2 MB; het blokkeren van afbeeldingen, lettertypen en media beperkt dit vaak tot enkele honderden kilobytes. Meet je echte pagina’s door de responsegroottes op te tellen in een `response`-handler voor 50 pagina’s.

### Moet ik headless of 'headed' browsers gebruiken voor scraping?

Headless is de normale keuze voor servers en gebruikt minder resources. Gebruik een 'headed' browser alleen om te debuggen wat een pagina toont. Geen van beide verandert de regels: render openbare pagina’s op een beleefde snelheid en respecteer de robots.txt en voorwaarden van de site.

**Render openbare pagina’s via residentiële IP's** US$ 5,94 voor 10 GB, US$ 0,50/GB van 50 GB. [Zie prijslijst](https://crawlrelay.com/nl/pricing/) · [Puppeteer gids](https://crawlrelay.com/nl/docs/puppeteer/)

---

CrawlRelay: CrawlRelay is een developer-first dienst met roterende residentiële proxy's en mobiele 4G-proxy's voor scrapers en AI-datastromen: niet-vervalverkeer op basis van pay-as-you-go vanaf US$ 0,50/GB, betaald in crypto, zonder ID-upload. Zonder KYC — geen ID, geen selfie, geen documenten. Betaal met crypto.