Playwright Proxy: Authenticated Setup per Browser Context (Node.js and Python)

Give each context its own proxy object with server, username and password. The username carries the country and the session, so two contexts in one browser leave through two different IPs:

// npm i playwright && npx playwright install chromium
const { chromium } = require('playwright');

(async () => {
  const browser = await chromium.launch();
  // Context 1: rotating, a new US IP on every request
  const us = await browser.newContext({ proxy: {
    server: 'http://gate.proxyfield.io:7000',
    username: '<login>-country-us',
    password: '<password>',
  } });
  // Context 2: one German IP held for 10 minutes (sticky session)
  const de = await browser.newContext({ proxy: {
    server: 'http://gate.proxyfield.io:7000',
    username: '<login>-country-de-session-he9f2qga-ttl-600',
    password: '<password>',
  } });
  for (const context of [us, de]) {
    const page = await context.newPage();
    await page.goto('https://ipinfo.io/json');
    console.log(await page.textContent('body'));
  }
  await browser.close();
})();

{ "ip": "<US exit IP>", "country": "US", ... }
{ "ip": "<DE exit IP>", "country": "DE", ... }

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch()
    for username in ("<login>-country-us", "<login>-country-de-session-he9f2qga-ttl-600"):
        context = browser.new_context(proxy={"server": "http://gate.proxyfield.io:7000",
                                             "username": username, "password": "<password>"})
        page = context.new_page()
        page.goto("https://ipinfo.io/json")
        print(page.inner_text("body"))  # one US object, then one DE object, with different IPs
        context.close()
    browser.close()

import { test } from '@playwright/test';

test('two exit countries', async ({ browser }) => {
  for (const cc of ['us', 'de']) {
    const context = await browser.newContext({ proxy: {
      server: 'http://gate.proxyfield.io:7000',
      username: `<login>-country-${cc}`,
      password: '<password>',
    } });
    const page = await context.newPage();
    await page.goto('https://ipinfo.io/json');
    console.log(cc, await page.textContent('body'));
    await context.close();
  }
});

The lowest-cost way in is 1 GB of residential for $2.95 or 20 GB of rotating datacenter for $5.80. The lowest price per GB is rotating datacenter at $0.29/GB; for most scraping, use residential at $2.95/GB for 1 GB down to $1.95/GB from 1,000 GB; and blocking images, fonts and media cuts the bytes per page (in the example below, a 10,000-page job drops from about 20 GB to about 5 GB; example inputs, not measurements). Pick the lowest-cost proxy type your target accepts, then cut the bytes each page loads. Free public proxy lists are not a budget option for Playwright: they are shared, often already flagged, and their operators can read unencrypted traffic.

Run one cURL command before you write any Playwright code: if it fails, Playwright will fail too.

# Any exit IP
curl -x http://gate.proxyfield.io:7000 -U "<login>:<password>" https://api.ipify.org

# An exit IP in New York, United States
curl -x http://gate.proxyfield.io:7000 -U "<login>-country-us-city-new_york:<password>" https://api.ipify.org

You should see an IP that is not yours. Check its country with https://ipinfo.io/json, or test your proxy in the ProxyField proxy checker (up to 100 proxies per check; your list and results are not stored). More flags and SOCKS5 examples: test the proxy with cURL.

Set proxy in chromium.launch(), and every context and page of that browser goes through it.

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

(async () => {
  const browser = await chromium.launch({
    proxy: {
      server: 'http://gate.proxyfield.io:7000',
      username: '<login>-country-us',
      password: '<password>',
    },
  });
  const page = await browser.newPage();
  await page.goto('https://api.ipify.org?format=json');
  console.log(await page.textContent('body')); // {"ip":"<exit IP>"}
  await browser.close();
})();

Notes:

• Playwright takes the username and password as separate fields, so special characters in the password need no URL-encoding. Don't put user:pass@ inside server.
• A server without a scheme, such as gate.proxyfield.io:7000, is read as an HTTP proxy.
• To send some hosts direct, add bypass: 'localhost,.internal.example' to the proxy object.
• firefox.launch() and webkit.launch() take the same proxy option.

The Python API takes the same settings as a dict: proxy= on launch() for the whole browser, or on new_context() for one context. For proxies in plain Python scripts, see Python proxy setup.

# pip install playwright && playwright install chromium
from playwright.sync_api import sync_playwright

PROXY = {
    "server": "http://gate.proxyfield.io:7000",
    "username": "<login>-country-us",
    "password": "<password>",
}

with sync_playwright() as p:
    browser = p.chromium.launch(proxy=PROXY)
    page = browser.new_page()
    page.goto("https://api.ipify.org?format=json")
    print(page.inner_text("body"))
    browser.close()

This async version gives each context its own country and prints the exit IP and country of each:

import asyncio
from playwright.async_api import async_playwright

def proxy_for(username):
    return {"server": "http://gate.proxyfield.io:7000", "username": username, "password": "<password>"}

async def main():
    async with async_playwright() as p:
        browser = await p.chromium.launch()
        for username in ("<login>-country-us", "<login>-country-de-session-he9f2qga-ttl-600"):
            context = await browser.new_context(proxy=proxy_for(username))
            page = await context.new_page()
            await page.goto("https://ipinfo.io/json")
            print(username, await page.inner_text("body"))
            await context.close()
        await browser.close()

asyncio.run(main())

Each context has its own proxy, cookies and storage, and one browser process can run many contexts at once, which is lighter than launching one browser per proxy. Set locale and timezoneId to match the exit country, so the page's language and clock agree with its IP:

await browser.newContext({ proxy: proxyFor('us'), locale: 'en-US', timezoneId: 'America/New_York' });
await browser.newContext({ proxy: proxyFor('de'), locale: 'de-DE', timezoneId: 'Europe/Berlin' });

Older Playwright versions needed a launch-level proxy before contexts could set their own (Chromium on Windows threw Browser needs to be launched with the global proxy). If you see that error, update Playwright, or launch with proxy: { server: 'http://per-context' } and keep the per-context settings.

Targeting goes in the username. ProxyField targets by country, region (state) and city, covers all 50 US states, and charges the same price per GB for every targeting. Names are lowercase with underscores.

A sticky IP ends when its ttl runs out, after 120 s without traffic, or when its exit node drops: the gateway then retries once with a new session, so the IP may change, and an established connection that breaks is not restored. The carrier is not a targeting option. All parameters: targeting docs.

You don't rotate proxies in Playwright code: the gateway gives a new IP on every request, or keeps one IP for a sticky session of 30 s to 36 h.

• Sticky session per context for logged-in flows, multi-step forms and any sequence of pages that must come from one IP.
• Rotation for independent page fetches, such as one product page or one search result per job.

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

const jobs = ['https://api.ipify.org?format=json', 'https://api.ipify.org?format=json', 'https://api.ipify.org?format=json'];

(async () => {
  const browser = await chromium.launch();
  for (const url of jobs) {
    // One context per job: fresh cookies, fresh connection, new exit IP.
    const context = await browser.newContext({
      proxy: { server: 'http://gate.proxyfield.io:7000', username: '<login>-country-us', password: '<password>' },
    });
    const page = await context.newPage();
    await page.goto(url);
    console.log(await page.textContent('body'));
    await context.close();
  }
  await browser.close();
})();

Browsers keep their connections to the proxy open and reuse them, so requests inside one page load can leave through the same IP. Open a new context when a task needs a new IP. More on both modes: rotating proxies with sticky sessions.

Playwright connects to SOCKS5 proxies with a socks5:// server, but Chromium does not send a username and password to a SOCKS5 proxy: it stops at launch with Browser does not support socks5 proxy authentication. So for SOCKS5 in Chromium, add your own IP to the allowlist in the dashboard, leave the credentials out and connect to socks5://gate.proxyfield.io:<port>, where <port> is the port you set up in the dashboard; or stay on HTTP, http://gate.proxyfield.io:7000 with your username and password, which also carries HTTPS sites.

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

(async () => {
  // Allowlist your own IP in the dashboard first: no username or password here.
  // <port> is the port you set up in the dashboard for your allowlisted IP.
  const browser = await chromium.launch({ proxy: { server: 'socks5://gate.proxyfield.io:<port>' } });
  const page = await browser.newPage();
  await page.goto('https://api.ipify.org?format=json');
  console.log(await page.textContent('body'));
  await browser.close();
})();

With allowlisted access there is no username to carry targeting: with the allowlist, the product, location and session are set per port in the dashboard.

You pay per GB, so every image, font and video a page loads through the proxy uses your balance. Block them with context.route(), and the same pages cost fewer GB.

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

const BLOCKED = new Set(['image', 'font', 'media']);

(async () => {
  const browser = await chromium.launch({
    proxy: { server: 'http://gate.proxyfield.io:7000', username: '<login>-country-us', password: '<password>' },
  });
  const context = await browser.newContext();

  // 1. Abort images, fonts and media before they reach the proxy.
  await context.route('**/*', (route) =>
    BLOCKED.has(route.request().resourceType()) ? route.abort() : route.continue()
  );

  // 2. Add up the bytes of every finished request.
  const sizes = [];
  context.on('requestfinished', (request) => sizes.push(request.sizes()));

  const page = await context.newPage();
  await page.goto('https://example.com', { waitUntil: 'networkidle' });

  let bytes = 0;
  for (const s of await Promise.all(sizes)) {
    bytes += s.requestHeadersSize + s.requestBodySize + s.responseHeadersSize + s.responseBodySize;
  }
  console.log(`${(bytes / 1024).toFixed(1)} KB through the proxy`);
  await browser.close();
})();

Keep scripts and stylesheets: most pages need them to render. request.sizes() counts headers and bodies as the browser sees them and leaves out connection overhead, so treat the total as an estimate. Your dashboard shows real-time usage and the gigabytes you have left.

Set headers for a whole context with extraHTTPHeaders and userAgent in browser.newContext(), next to its proxy, and keep Accept-Language, locale and timezoneId in line with the exit country (scraping headers guide). The ProxyField gateway adds no Via, X-Forwarded-For or Forwarded header, passes your own headers through, and removes Proxy-Authorization before the request reaches the site.

Three projects add stealth on top of Playwright, and all three take the same proxy settings:

• playwright-extra is a Node.js wrapper that brings puppeteer-extra plugins, including the stealth plugin, to Playwright. Its last release, 4.3.6, dates from March 2023.
• playwright-stealth is a Python port of the stealth evasions. Version 2.0.3 came out in April 2026.
• Camoufox is a Firefox-based anti-detect browser with a Playwright-style Python API. It accepts the same proxy dict, and with geoip=True it matches its locale and timezone to the proxy's exit IP. Version 0.5.8 came out in October 2026.

More options: Puppeteer alternatives. For browser profiles managed in a desktop app: proxies for antidetect browsers.

A residential proxy fixes only the IP signal: Cloudflare also reads the browser's fingerprint, TLS signature and behavior, and no proxy solves a challenge. So on public pages, within the site's terms, run one context on one sticky residential IP per visit with a matching locale and time zone, go slowly, and stop when the challenge repeats:

const context = await browser.newContext({
  proxy: { server: 'http://gate.proxyfield.io:7000', username: '<login>-country-us-session-cf1-ttl-1800', password: '<password>' },
  locale: 'en-US',
  timezoneId: 'America/New_York',
});

Gateway responses for specific failures: 407 Proxy Authentication Required for a wrong login or password, an IP not on the allowlist or a malformed location, 402 Payment Required when no traffic is left and 502 Bad Gateway when no exit could be connected; a restricted site gets no separate response, and a 403 comes from the site itself. More: proxy errors. Our 24/7 live chat also helps with setup and integration.

Set proxy under use in playwright.config.ts, and every test in the project runs through it.

// playwright.config.ts
import { defineConfig } from '@playwright/test';

export default defineConfig({
  use: {
    proxy: {
      server: 'http://gate.proxyfield.io:7000',
      username: process.env.PF_USER, // e.g. <login>-country-us
      password: process.env.PF_PASS,
    },
  },
});

Run it with PF_USER=<login>-country-us PF_PASS=<password> npx playwright test. To use another proxy for one file, call test.use({ proxy: { ... } }) at the top of that file; for a proxy per test, create a context from the browser fixture with browser.newContext({ proxy }).

Start with the Easy Trial: 1 GB for $2.95, no minimum purchase, no subscription, and the traffic never expires. Pay in USDT, BTC, ETH and 10 other coins; the smallest payment for traffic is $2.95. All purchases are final. See pricing per GB.