playwright-stealth

The recommended way to use playwright-stealth is to use the Stealth().use_async() context manager. This wraps the Playwright async_playwright instance, ensuring that all pages and contexts created within that session automatically have stealth evasions applied.

This approach is the most seamless as it handles the application of evasions to every new page and context created under the managed playwright instance.

import asyncio
from playwright.async_api import async_playwright
from playwright_stealth import Stealth


async def main():
    # This is the recommended usage. All pages created will have stealth applied:
    async with Stealth().use_async(async_playwright()) as p:
        browser = await p.chromium.launch()
        page = await browser.new_page()

        webdriver_status = await page.evaluate("navigator.webdriver")
        print("from new_page: ", webdriver_status)

        different_context = await browser.new_context()
        page_from_different_context = await different_context.new_page()

        different_context_status = await page_from_different_context.evaluate("navigator.webdriver")
        print("from new_context: ", different_context_status)


asyncio.run(main())

If you need more control or are working with an existing Playwright instance, you can instantiate a Stealth object and apply it to a specific BrowserContext using await stealth.apply_stealth_async(context).

This allows you to target specific contexts rather than the entire Playwright session. You can also configure the Stealth instance with custom options like navigator_languages_override or init_scripts_only.

import asyncio
from playwright.async_api import async_playwright
from playwright_stealth import Stealth


async def advanced_example():
    # Custom configuration with specific languages
    custom_languages = ("fr-FR", "fr")
    stealth = Stealth(
        navigator_languages_override=custom_languages,
        init_scripts_only=True
    )

    async with async_playwright() as p:
        browser = await p.chromium.launch()
        context = await browser.new_context()
        # Apply stealth to the specific context
        await stealth.apply_stealth_async(context)

        # Test stealth on multiple pages created from this context
        page_1 = await context.new_page()
        page_2 = await context.new_page()

        # Verify language settings
        for i, page in enumerate([page_1, page_2], 1):
            is_mocked = await page.evaluate("navigator.languages") == custom_languages
            print(f"Stealth applied to page {i}: {is_mocked}")


asyncio.run(advanced_example())

The Stealth class is the main entry point for applying evasions to Playwright. You can configure which stealth strategies are enabled or disabled and provide overrides for specific browser properties like User Agent, Platform, or WebGL settings.

Key Configuration Options:

• navigator_user_agent_override: Set a custom User Agent string.
• navigator_platform_override: Set a custom platform (e.g., 'Win32').
• navigator_languages_override: A tuple of (language, script) (e.g., ('en-US', 'en')).
• webgl_renderer_override: Override the WebGL renderer string.
• webgl_vendor_override: Override the WebGL vendor string.
• sec_ch_ua_override: Manually set the Sec-CH-UA header value.
• init_scripts_only: If True, only applies the init scripts without patching Playwright methods.

from playwright_stealth import Stealth

stealth = Stealth(
    navigator_user_agent_override="My Custom UA",
    navigator_platform_override="Win32",
    webgl_vendor_override="Intel Inc."
)

The following boolean flags control which JavaScript evasion scripts are injected into the page. Most are True by default.