How to Use a Playwright Proxy in 2025

With websites implementing measures like anti-bots to prevent web scraping, scrapers are often flagged and blocked. This is where Playwright proxies come in.

By routing your automated browser traffic through proxy servers, you can effectively avoid IP bans and access geo-restricted content. In this tutorial, you'll learn:

• Basic Proxy Implementation.
• Playwright Proxy Authentication.
• How to Rotate Proxies in Playwright.
• How to Choose the Best Proxies.

Ready to enhance your web scraping capabilities? Let's dive in!

Quick Answer: Setting Up a Proxy in Playwright

In this section, you'll learn how to set up proxies in Playwright, where to get the proxies from, and how to authenticate them.

To demonstrate proxy implementation, you'll create a simple script that accesses HTTPBin, a service that returns the IP address of the client making the request. This will help us verify if the proxy is working correctly.

To follow along in this tutorial, install the Playwright Python library using the pip command:

pip install playwright

Then, install the necessary browsers using the install command.

playwright install

Next, grab a free proxy from the Free Proxy List website.

Here's the basic setup for using a proxy with Playwright:

from playwright.async_api import async_playwright
import asyncio

async def main():
    async with async_playwright() as playwright:
        # configure browser with proxy
        browser = await playwright.chromium.launch(
            proxy={
                "server": "38.165.231.59:8080",
            },
        )
        context = await browser.new_context()
        page = await context.new_page()

        await page.goto("https://httpbin.io/ip")
        html_content = await page.content()
        print(html_content)

        await context.close()
        await browser.close()

asyncio.run(main())

You'll get the following output on running this script:

{
  "origin": "38.165.231.59"
}

Bingo! The result above is the IP address of our free proxy. Now you know how to set up a Playwright proxy.

Playwright Proxy Authentication

Some proxy providers, particularly the ones offering premium proxies, require authentication to access their servers.

Add the necessary credentials as parameters in the launch() method to authenticate a Playwright proxy. Here's an example:

browser = await playwright.chromium.launch(
    proxy={
        "server": "<PROXY_IP_ADDRESS>:<PROXY_PORT>",
        "username": "<YOUR_USERNAME>",
        "password": "<YOUR_PASSWORD>",
    },
)

Now your Playwright scraper looks like this:

from playwright.async_api import async_playwright
import asyncio


async def main():
    async with async_playwright() as playwright:
        browser = await playwright.chromium.launch(
            proxy={
                "server": "<PROXY_IP_ADDRESS>:<PROXY_PORT>",
                "username": "<YOUR_USERNAME>",
                "password": "<YOUR_PASSWORD>",
            },
        )
        context = await browser.new_context()
        page = await context.new_page()

        await page.goto("https://httpbin.io/ip")
        html_content = await page.content()
        print(html_content)

        await context.close()
        await browser.close()


asyncio.run(main())

Rotating Proxies in Playwright

When your script sends numerous requests rapidly, websites may flag this behavior as suspicious and block your IP address. Implementing a rotating proxy strategy can effectively prevent this.

By switching to a new IP address after a set number of requests or time intervals, you make each request appear as if it's coming from a different user.

To implement proxy rotation in Playwright, create a simple proxy pool and randomly select different proxies for each request using Python's random module. This approach helps distribute your requests across multiple IPs and reduces the chances of getting blocked.

Let's look at a practical example using free proxies from the Free Proxy List.

from playwright.async_api import async_playwright
import asyncio
import random

# define a pool of proxy servers
proxy_pool = [
    {"server": "68.183.185.62:80"},
    {"server": "61.28.233.217:3128"},
    {"server": "213.230.108.208:3128"},
    # add more proxy servers as needed
]


async def main():
    # select a random proxy for each request
    proxy = random.choice(proxy_pool)

    async with async_playwright() as playwright:
        browser = await playwright.chromium.launch(proxy=proxy)
        context = await browser.new_context()
        page = await context.new_page()

        await page.goto("https://httpbin.io/ip")
        text_content = await page.content()
        print(text_content)

        await context.close()
        await browser.close()


asyncio.run(main())

Here's the result from manually running this script multiple times:

# request 1
{
  "origin": "68.183.185.62"
}
# request 2
{
  "origin": "213.230.108.208"
}
# request 3
{
  "origin": "61.28.233.217"
}

Awesome, you've created your first Playwright proxy rotator.

However, it's essential to note that free proxies are unreliable and only used for testing purposes. For actual web scraping projects, you need premium proxies that rotate proxies automatically for you.

Let's explore these options next.

How to Choose the Best Proxies

To minimize detection and avoid getting blocked while scraping, consider using premium proxies, particularly residential proxies with IP addresses tied to real devices. If you're looking for reliable options, check out our curated list of the best web scraping proxy services.

One of the best premium proxy service providers is ZenRows Residential Proxies. It offers advanced features that go beyond basic proxy rotation. It provides proxy auto-rotation, residential IPs, geolocation features, and more that significantly increase your scraping success rate.

To get started, sign up for ZenRows to open the Request Builder. Go to the Residential Proxies page. Then, copy the proxy domain, port, and credentials (username and password).

Modify your Playwright code with the copied credentials as follows:

from playwright.async_api import async_playwright
import asyncio

async def main():
    async with async_playwright() as playwright:
        browser = await playwright.chromium.launch(
            proxy={
                "server": "<PROXY_DOMAIN>:<PROXY_PORT>",
                "username": "<YOUR_ZENROWS_PROXY_USERNAME>",
                "password": "<YOUR_ZENROWS_PROXY_PASSWORD>",
            },
        )
        context = await browser.new_context()
        page = await context.new_page()

        await page.goto("https://httpbin.io/ip")
        html_content = await page.content()
        print(html_content)

        await context.close()
        await browser.close()

asyncio.run(main())

Run the code. Here's an example of what the output would look like:

{
  "origin": "94.19.73.27:65404"
}

The above output confirms that your request was routed through ZenRows' premium proxies.

Congratulations! You now know how to configure a proxy in Playwright.

Conclusion

Setting up proxies with Playwright is essential for successful web scraping, but managing proxy rotation manually can be time-consuming and error-prone. While free proxies might seem appealing, their unreliability and poor success rates make them unsuitable for serious scraping projects.

Premium residential proxies are the way to go for reliable results. ZenRows offers a comprehensive solution that automatically handles proxy management. Ready to supercharge your web scraping? Try ZenRows for free!