Verwenden von Proxies in Python mit Playwright

Proxys in Python mit Playwright verwenden

Playwright und Proxys

Playwright ist ein Browser-Automatisierungs-Framework von Microsoft, das Chromium, Firefox und WebKit unterstützt. Die Python-Version von Playwright verfügt über eine integrierte Proxy-Unterstützung auf Browser-Ebene und für einzelne Kontexte.

Installation

pip install playwright
playwright install  # downloads browsers

Grundlegende Proxy-Konfiguration

HTTP-Proxy

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(
        proxy={
            "server": "http://proxy_ip:port"
        }
    )
    page = browser.new_page()
    page.goto("https://httpbin.org/ip")
    print(page.content())
    browser.close()

Mit Authentifizierung

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(
        proxy={
            "server": "http://proxy_ip:port",
            "username": "user",
            "password": "pass"
        }
    )
    page = browser.new_page()
    page.goto("https://httpbin.org/ip")
    print(page.content())
    browser.close()

SOCKS5-Proxy

browser = p.chromium.launch(
    proxy={"server": "socks5://proxy_ip:port"}
)

Asynchroner Modus

import asyncio
from playwright.async_api import async_playwright

async def main():
    async with async_playwright() as p:
        browser = await p.chromium.launch(
            proxy={
                "server": "http://proxy_ip:port",
                "username": "user",
                "password": "pass"
            }
        )
        page = await browser.new_page()
        await page.goto("https://httpbin.org/ip")
        content = await page.content()
        print(content)
        await browser.close()

asyncio.run(main())

Proxys auf Kontextebene

Playwright ermöglicht es Ihnen, verschiedene Proxys für verschiedene Kontexte (Profile) innerhalb eines einzigen Browsers festzulegen:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch()

    # Kontext 1 — US-Proxy
    context1 = browser.new_context(
        proxy={
            "server": "http://us_proxy:port",
            "username": "user",
            "password": "pass"
        }
    )

    # Kontext 2 — Deutschland-Proxy
    context2 = browser.new_context(
        proxy={
            "server": "http://de_proxy:port",
            "username": "user",
            "password": "pass"
        }
    )

    page1 = context1.new_page()
    page2 = context2.new_page()

    page1.goto("https://httpbin.org/ip")
    page2.goto("https://httpbin.org/ip")

    print("US:", page1.content())
    print("DE:", page2.content())

    browser.close()

Dies ist eine leistungsstarke Funktion: ein Browser, mehrere Kontexte mit unterschiedlichen IPs und Fingerabdrücken.

Proxys für bestimmte Domains umgehen

browser = p.chromium.launch(
    proxy={
        "server": "http://proxy_ip:port",
        "bypass": "localhost,*.local,example.com"
    }
)

Domains in der Bypass-Liste werden direkt aufgerufen, wodurch der Proxy umgangen wird.

Headless- und Headed-Modi

# Headless (ohne GUI) — für Scraping
browser = p.chromium.launch(headless=True, proxy={"server": "http://proxy:port"})

# Headed (mit GUI) — zum Debugging
browser = p.chromium.launch(headless=False, proxy={"server": "http://proxy:port"})

Arbeiten mit verschiedenen Browsern

Playwright unterstützt drei Engines:

# Chromium
browser = p.chromium.launch(proxy=proxy_config)

# Firefox
browser = p.firefox.launch(proxy=proxy_config)

# WebKit (Safari)
browser = p.webkit.launch(proxy=proxy_config)

Alle drei unterstützen Proxys identisch.

Stealth-Modus und Anti-Bot-Umgehung

Playwright wird von Anti-Bot-Systemen erkannt. Zur Umgehung:

playwright-stealth

pip install playwright-stealth

from playwright.sync_api import sync_playwright
from playwright_stealth import stealth_sync

with sync_playwright() as p:
    browser = p.chromium.launch(proxy={"server": "http://proxy:port"})
    page = browser.new_page()
    stealth_sync(page)  # wendet Stealth-Patches an
    page.goto("https://target-site.com")

Empfehlungen zur Umgehung

1. Verwenden Sie Residential- oder Mobile-Proxys
2. Legen Sie einen realistischen User-Agent fest
3. Konfigurieren Sie die Viewport-Größe
4. Fügen Sie Verzögerungen zwischen Aktionen hinzu
5. Simulieren Sie Mausbewegungen und Scrollen

Screenshots und PDFs über Proxy

page.goto("https://example.com")
page.screenshot(path="screenshot.png", full_page=True)
page.pdf(path="page.pdf")

Anfragen abfangen

def handle_route(route):
    # Anfragen modifizieren
    headers = route.request.headers
    headers["X-Custom-Header"] = "value"
    route.continue_(headers=headers)

page.route("**/*", handle_route)
page.goto("https://example.com")

Praktisches Beispiel: Scraping mit Rotation

import asyncio
from playwright.async_api import async_playwright
import random

PROXIES = [
    {"server": "http://proxy1:port", "username": "u", "password": "p"},
    {"server": "http://proxy2:port", "username": "u", "password": "p"},
    {"server": "http://proxy3:port", "username": "u", "password": "p"},
]

async def scrape_page(playwright, url):
    proxy = random.choice(PROXIES)
    browser = await playwright.chromium.launch(proxy=proxy)
    page = await browser.new_page()
    try:
        await page.goto(url, timeout=30000)
        title = await page.title()
        return title
    except Exception as e:
        return f"Error: {e}"
    finally:
        await browser.close()

async def main():
    urls = [f"https://example.com/page/{i}" for i in range(10)]
    async with async_playwright() as p:
        tasks = [scrape_page(p, url) for url in urls]
        results = await asyncio.gather(*tasks)
        for url, result in zip(urls, results):
            print(f"{url}: {result}")

asyncio.run(main())

Fazit

Playwright ist ein leistungsstarkes Tool für die Arbeit mit Proxys in Python. Die Proxy-Unterstützung auf Kontextebene ermöglicht das Ausführen mehrerer Sitzungen mit unterschiedlichen IPs innerhalb eines einzigen Browsers. In Kombination mit Stealth-Patches und Residential-Proxys ist Playwright effektiv für das Scraping geschützter Websites.