Playwright for Python

https://playwright.dev/python/docs/
Admin
Playwright for Python is a library for end-to-end testing and browser automation, providing powerful...
Tokens:465,240
Snippets:3,818
Trust Score:9.9
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Record multiple trace chunks with tracing.start_chunk() and tracing.stop_chunk() (Async)

Source: https://playwright.dev/python/docs/api/class-tracing

Async version of the previous example. Starts tracing with screenshots and snapshots, then records two separate trace chunks. The first chunk captures a click on 'Get Started', the second navigates to example.com. Each chunk is saved to a separate zip file.

```python
await context.tracing.start(screenshots=True, snapshots=True)  

page = await context.new_page()  

await page.goto("https://playwright.dev")  

  

await context.tracing.start_chunk()  

await page.get_by_text("Get Started").click()  

# Everything between start_chunk and stop_chunk will be recorded in the trace.  

await context.tracing.stop_chunk(path = "trace1.zip")  

  

await context.tracing.start_chunk()  

await page.goto("http://example.com")  

# Save a second trace file with different actions.  

await context.tracing.stop_chunk(path = "trace2.zip")  
```

--------------------------------

### Start HAR recording with tracing.start_har() (Async)

Source: https://playwright.dev/python/docs/api/class-tracing

Async version of the previous example. Starts recording a HAR file to 'trace.har', navigates to playwright.dev, then stops recording.

```python
await context.tracing.start_har("trace.har")  

page = await context.new_page()  

await page.goto("https://playwright.dev")  

await context.tracing.stop_har()  
```

--------------------------------

### Capture a credential and save it (Sync setup)

Source: https://playwright.dev/python/docs/api/class-credentials

Sync setup test that captures a credential. Installs the authenticator, navigates to a registration page, clicks the 'Create a passkey' button, then reads back the registered passkey via context.credentials.get(rp_id="example.com") and saves it to playwright/.auth/passkey.json.

```python
# setup test: let the app register a passkey, then save it.  
context = browser.new_context()  
context.credentials.install()  

page = context.new_page()  
page.goto("https://example.com/register")  
page.get_by_role("button", name="Create a passkey").click()  

# Read back the passkey the page registered — it includes the private key.  
[credential] = context.credentials.get(rp_id="example.com")  
with open("playwright/.auth/passkey.json", "w") as f:  
    json.dump(credential, f)
```

--------------------------------

### Capture a credential and save it (Async setup)

Source: https://playwright.dev/python/docs/api/class-credentials

Async setup test that captures a credential. Installs the authenticator, navigates to a registration page, clicks the 'Create a passkey' button, then reads back the registered passkey via await context.credentials.get(rp_id="example.com") and saves it to playwright/.auth/passkey.json.

```python
# setup test: let the app register a passkey, then save it.  
context = await browser.new_context()  
await context.credentials.install()  

page = await context.new_page()  
await page.goto("https://example.com/register")  
await page.get_by_role("button", name="Create a passkey").click()  

# Read back the passkey the page registered — it includes the private key.  
[credential] = await context.credentials.get(rp_id="example.com")  
with open("playwright/.auth/passkey.json", "w") as f:  
    json.dump(credential, f)
```

--------------------------------

### Record multiple trace chunks with tracing.start_chunk() and tracing.stop_chunk() (Sync)

Source: https://playwright.dev/python/docs/api/class-tracing

Starts tracing with screenshots and snapshots, then records two separate trace chunks. The first chunk captures a click on 'Get Started', the second navigates to example.com. Each chunk is saved to a separate zip file.

```python
context.tracing.start(screenshots=True, snapshots=True)  

page = context.new_page()  

page.goto("https://playwright.dev")  

  

context.tracing.start_chunk()  

page.get_by_text("Get Started").click()  

# Everything between start_chunk and stop_chunk will be recorded in the trace.  

context.tracing.stop_chunk(path = "trace1.zip")  

  

context.tracing.start_chunk()  

page.goto("http://example.com")  

# Save a second trace file with different actions.  

context.tracing.stop_chunk(path = "trace2.zip")  
```

--------------------------------

### Install browser with dependencies

Source: https://playwright.dev/python/docs/browsers

Combines browser installation with OS dependency installation in a single command. Here it installs Chromium and its dependencies.

```bash
playwright install --with-deps chromium
```

--------------------------------

### Async APIResponse usage example

Source: https://playwright.dev/python/docs/api/class-apiresponse

Shows how to use the async API to create a request context, make a GET request, and assert on the response properties. Uses asyncio.run() to execute the main function.

```python
import asyncio  
from playwright.async_api import async_playwright, Playwright  

async def run(playwright: Playwright):  
    context = await playwright.request.new_context()  
    response = await context.get("https://example.com/user/repos")  
    assert response.ok  
    assert response.status == 200  
    assert response.headers["content-type"] == "application/json; charset=utf-8"  
    json_data = await response.json()  
    assert json_data["name"] == "foobar"  
    assert await response.body() == '{"status": "ok"}'  

async def main():  
    async with async_playwright() as playwright:  
        await run(playwright)  

asyncio.run(main())  
```

--------------------------------

### Install Playwright with uv

Source: https://playwright.dev/python/docs/library

Update uv, add Playwright as a dependency, and install browser binaries.

```bash
uv self update  

uv add playwright  

playwright install  

```

--------------------------------

### install - Install fake timers

Source: https://playwright.dev/python/docs/api/class-clock

Install fake implementations for time-related functions. Optionally initialize with a specific time (Unix seconds, string, or datetime).

```python
clock.install()  
clock.install(**kwargs)  
```

--------------------------------

### Sync APIResponse usage example

Source: https://playwright.dev/python/docs/api/class-apiresponse

Shows how to use the sync API to create a request context, make a GET request, and assert on the response properties such as ok, status, headers, json, and body.

```python
from playwright.sync_api import sync_playwright  

with sync_playwright() as p:  
    context = playwright.request.new_context()  
    response = context.get("https://example.com/user/repos")  
    assert response.ok  
    assert response.status == 200  
    assert response.headers["content-type"] == "application/json; charset=utf-8"  
    assert response.json()["name"] == "foobar"  
    assert response.body() == '{"status": "ok"}'  
```

--------------------------------

### Sync Playwright REPL example

Source: https://playwright.dev/python/docs/library

Launches Playwright in a Python REPL using the sync API. Starts Playwright, opens a browser, navigates to playwright.dev, takes a screenshot, and closes the browser. Use headless=False to see the browser UI.

```python
from playwright.sync_api import sync_playwright  

playwright = sync_playwright().start()  

# Use playwright.chromium, playwright.firefox or playwright.webkit  

# Pass headless=False to launch() to see the browser UI  

browser = playwright.chromium.launch()  

page = browser.new_page()  

page.goto("https://playwright.dev/")  

page.screenshot(path="example.png")  

browser.close()  

playwright.stop()  

```

--------------------------------

### Async Playwright REPL example

Source: https://playwright.dev/python/docs/library

Launches Playwright in an asyncio REPL using the async API. Starts Playwright, opens a browser, navigates to playwright.dev, takes a screenshot, and closes the browser.

```python
from playwright.async_api import async_playwright  

playwright = await async_playwright().start()  

browser = await playwright.chromium.launch()  

page = await browser.new_page()  

await page.goto("https://playwright.dev/")  

await page.screenshot(path="example.png")  

await browser.close()  

await playwright.stop()  

```

--------------------------------

### Install pytest-playwright with uv

Source: https://playwright.dev/python/docs/intro

Install the Playwright Pytest plugin using uv.

```bash
uv add pytest-playwright  
```

--------------------------------

### Launch a browser and create a page (Sync API)

Source: https://playwright.dev/python/docs/api/class-browser

Shows how to launch a Firefox browser, create a new page, navigate to example.com, and close the browser using the sync API.

```python
from playwright.sync_api import sync_playwright, Playwright  
  
def run(playwright: Playwright):  
    firefox = playwright.firefox  
    browser = firefox.launch()  
    page = browser.new_page()  
    page.goto("https://example.com")  
    browser.close()  
  
with sync_playwright() as playwright:  
    run(playwright)  
```

--------------------------------

### pause_at with install and goto - Sync and Async

Source: https://playwright.dev/python/docs/api/class-clock

Recommended pattern: install clock before navigation, let page load, then pause at test time. Sync and async variants shown.

```python
# Initialize clock with some time before the test time and let the page load  
# naturally. `Date.now` will progress as the timers fire.  
page.clock.install(time=datetime.datetime(2024, 12, 10, 8, 0, 0))  
page.goto("http://localhost:3333")  
page.clock.pause_at(datetime.datetime(2024, 12, 10, 10, 0, 0))  
```

```python
# Initialize clock with some time before the test time and let the page load  
# naturally. `Date.now` will progress as the timers fire.  
await page.clock.install(time=datetime.datetime(2024, 12, 10, 8, 0, 0))  
await page.goto("http://localhost:3333")  
await page.clock.pause_at(datetime.datetime(2024, 12, 10, 10, 0, 0))  
```

--------------------------------

### Generated test with assertions

Source: https://playwright.dev/python/docs/release-notes

Example of a generated test with assertions using the Playwright Test Generator. It navigates to the Playwright website, clicks the 'Get started' link, and uses expect() assertions for visibility, text, and value.

```python
from playwright.sync_api import Page, expect  

  

def test_example(page: Page) -> None:  
    page.goto("https://playwright.dev/")  
    page.get_by_role("link", name="Get started").click()  
    expect(page.get_by_label("Breadcrumbs").get_by_role("list")).to_contain_text("Installation")  
    expect(page.get_by_label("Search")).to_be_visible()  
    page.get_by_label("Search").click()  
    page.get_by_placeholder("Search docs").fill("locator")  
    expect(page.get_by_placeholder("Search docs")).to_have_value("locator");  
```

--------------------------------

### Get video path (Async)

Source: https://playwright.dev/python/docs/api/class-video

Async API example showing how to get the video file path from the page's video object.

```python
print(await page.video.path())  
```

--------------------------------

### Get video path (Sync)

Source: https://playwright.dev/python/docs/api/class-video

Sync API example showing how to get the video file path from the page's video object.

```python
print(page.video.path())  
```

--------------------------------

### List supported browsers

Source: https://playwright.dev/python/docs/browsers

Displays help and lists all supported browsers for the install command.

```bash
playwright install --help
```

--------------------------------

### Get page from locator with locator.page

Source: https://playwright.dev/python/docs/api/class-locator

Returns the page that this locator belongs to. Simple property access example.

```python
locator.page
```

--------------------------------

### Launch a browser and create a page (Async API)

Source: https://playwright.dev/python/docs/api/class-browser

Shows how to launch a Firefox browser, create a new page, navigate to example.com, and close the browser using the async API.

```python
import asyncio  
from playwright.async_api import async_playwright, Playwright  
  
async def run(playwright: Playwright):  
    firefox = playwright.firefox  
    browser = await firefox.launch()  
    page = await browser.new_page()  
    await page.goto("https://example.com")  
    await browser.close()  
  
async def main():  
    async with async_playwright() as playwright:  
        await run(playwright)  
asyncio.run(main())  
```

--------------------------------

### locator.evaluate async example

Source: https://playwright.dev/python/docs/api/class-locator

Asynchronous usage of locator.evaluate. Uses await to get the result from the JavaScript expression.

```python
result = await page.get_by_testid("myId").evaluate("(element, [x, y]) => element.textContent + ' ' + x * y", [7, 8])

print(result) # prints "myId text 56"
```

--------------------------------

### Async CDPSession usage example

Source: https://playwright.dev/python/docs/api/class-cdpsession

Shows how to create a CDPSession, send protocol methods, subscribe to events, and set playback rate asynchronously.

```python
client = await page.context.new_cdp_session(page)

await client.send("Animation.enable")

client.on("Animation.animationCreated", lambda: print("animation created!"))

response = await client.send("Animation.getPlaybackRate")

print("playback rate is " + str(response["playbackRate"]))

await client.send("Animation.setPlaybackRate", {
    "playbackRate": response["playbackRate"] / 2
})
```

--------------------------------

### locator.evaluate_all async example

Source: https://playwright.dev/python/docs/api/class-locator

Asynchronous usage of locator.evaluate_all. Uses await to get the boolean result from the JavaScript expression.

```python
locator = page.locator("div")

more_than_ten = await locator.evaluate_all("(divs, min) => divs.length > min", 10)
```

--------------------------------

### Get first matching element with locator.first

Source: https://playwright.dev/python/docs/api/class-locator

Returns a locator to the first matching element. This is a simple property access example.

```python
locator.first
```

--------------------------------

### Sync CDPSession usage example

Source: https://playwright.dev/python/docs/api/class-cdpsession

Shows how to create a CDPSession, send protocol methods, subscribe to events, and set playback rate synchronously.

```python
client = page.context.new_cdp_session(page)

client.send("Animation.enable")

client.on("Animation.animationCreated", lambda: print("animation created!"))

response = client.send("Animation.getPlaybackRate")

print("playback rate is " + str(response["playbackRate"]))

client.send("Animation.setPlaybackRate", {
    "playbackRate": response["playbackRate"] / 2
})
```

--------------------------------

### GitHub Actions workflow on deployment

Source: https://playwright.dev/python/docs/ci

This workflow starts tests after a GitHub Deployment reaches success state, useful for services like Vercel. It installs dependencies, ensures browsers are installed, and runs tests with the deployment URL as base URL.

```yaml
name: Playwright Tests  

on:  

  deployment_status:  

jobs:  

  test:  

    timeout-minutes: 60  

    runs-on: ubuntu-latest  

    if: github.event.deployment_status.state == 'success'  

    steps:  

    - uses: actions/checkout@v6  

      uses: actions/setup-python@v6  

      with:  

        python-version: '3.13'  

    - name: Install dependencies  

      run: |  

        python -m pip install --upgrade pip  

        pip install -r requirements.txt  

    - name: Ensure browsers are installed  

      run: python -m playwright install --with-deps  

    - name: Run tests  

      run: pytest  

      env:  

        # This might depend on your test-runner  

        PLAYWRIGHT_TEST_BASE_URL: ${{ github.event.deployment_status.target_url }}  

```

--------------------------------

### credentials.install()

Source: https://playwright.dev/python/docs/api/class-credentials

Installs the virtual WebAuthn authenticator into the context, overriding navigator.credentials.create() and navigator.credentials.get() in all current and future pages. Call this before the page first touches navigator.credentials.

```APIDOC
## credentials.install()

### Description
Installs the virtual WebAuthn authenticator into the context, overriding navigator.credentials.create() and navigator.credentials.get() in all current and future pages. Call this before the page first touches navigator.credentials.

### Method
install

### Endpoint
credentials.install

### Parameters
None

### Returns
- **NoneType** - No return value.

### Usage Example
```
credentials.install()
```
```

--------------------------------

### context.credentials.install()

Source: https://playwright.dev/python/docs/api/class-credentials

Installs the virtual authenticator, enabling it to answer WebAuthn ceremonies in the page.

```APIDOC
## context.credentials.install()

### Description
Installs the virtual authenticator, enabling it to answer WebAuthn ceremonies in the page.

### Method
install

### Parameters
None.

### Request Example
```python
context.credentials.install()
```

### Response
No return value.
```

--------------------------------

### Complete API test example with Playwright sync API

Source: https://playwright.dev/python/docs/api-testing

This is the complete example of an API test using Playwright's sync API. It requires GITHUB_API_TOKEN and GITHUB_USER environment variables, and creates a test repository named 'test'. The example includes fixtures for request context and repository setup, and tests for creating bug and feature issues.

```python
from enum import auto  

import os  

from typing import Generator  

  

import pytest  

from playwright.sync_api import Playwright, Page, APIRequestContext, expect  

  

GITHUB_API_TOKEN = os.getenv("GITHUB_API_TOKEN")  

assert GITHUB_API_TOKEN, "GITHUB_API_TOKEN is not set"  

  

GITHUB_USER = os.getenv("GITHUB_USER")  

assert GITHUB_USER, "GITHUB_USER is not set"  

  

GITHUB_REPO = "test"  

  

  

@pytest.fixture(scope="session")  

def api_request_context(  

    playwright: Playwright,  

) -> Generator[APIRequestContext, None, None]:  

    headers = {  

        # We set this header per GitHub guidelines.  

        "Accept": "application/vnd.github.v3+json",  

        # Add authorization token to all requests.  

        # Assuming personal access token available in the environment.  

        "Authorization": f"token {GITHUB_API_TOKEN}",  

    }  

    request_context = playwright.request.new_context(  

        base_url="https://api.github.com", extra_http_headers=headers  

    )  

    yield request_context  

    request_context.dispose()  

  

  

@pytest.fixture(scope="session", autouse=True)  

def create_test_repository(  

    api_request_context: APIRequestContext,  

) -> Generator[None, None, None]:  

    # Before all  

    new_repo = api_request_context.post("/user/repos", data={"name": GITHUB_REPO})  

    assert new_repo.ok  

    yield  

    # After all  

    deleted_repo = api_request_context.delete(f"/repos/{GITHUB_USER}/{GITHUB_REPO}")  

    assert deleted_repo.ok  

  

  

def test_should_create_bug_report(api_request_context: APIRequestContext) -> None:  

    data = {  

        "title": "[Bug] report 1",  

        "body": "Bug description",  

    }  

    new_issue = api_request_context.post(  

        f"/repos/{GITHUB_USER}/{GITHUB_REPO}/issues", data=data  

    )  

    assert new_issue.ok  

  

    issues = api_request_context.get(f"/repos/{GITHUB_USER}/{GITHUB_REPO}/issues")  

    assert issues.ok  

    issues_response = issues.json()  

    issue = list(  

        filter(lambda issue: issue["title"] == "[Bug] report 1", issues_response)  

    )[0]  

    assert issue  

    assert issue["body"] == "Bug description"  

  

  

def test_should_create_feature_request(api_request_context: APIRequestContext) -> None:  

    data = {  

        "title": "[Feature] request 1",  

        "body": "Feature description",  

    }  

    new_issue = api_request_context.post(  

        f"/repos/{GITHUB_USER}/{GITHUB_REPO}/issues", data=data  

    )  

    assert new_issue.ok  

  

    issues = api_request_context.get(f"/repos/{GITHUB_USER}/{GITHUB_REPO}/issues")  

    assert issues.ok  

    issues_response = issues.json()  

    issue = list(  

        filter(lambda issue: issue["title"] == "[Feature] request 1", issues_response)  

    )[0]  

    assert issue  

    assert issue["body"] == "Feature description"  

```

--------------------------------

### Start tracing with screenshots and snapshots

Source: https://playwright.dev/python/docs/api/class-tracing

Start tracing with screenshots and snapshots, perform actions, then stop and save the trace. The sync and async versions are shown as tabs.

```python
context.tracing.start(screenshots=True, snapshots=True)  

page = context.new_page()  

page.goto("https://playwright.dev")  

context.tracing.stop(path = "trace.zip")  

```

```python
await context.tracing.start(screenshots=True, snapshots=True)  

page = await context.new_page()  

await page.goto("https://playwright.dev")  

await context.tracing.stop(path = "trace.zip")  

```

--------------------------------

### Async: Handle GET and POST requests with fallback

Source: https://playwright.dev/python/docs/api/class-route

Async version of the GET/POST handler example. Uses await with route.fallback() and async function definitions.

```python
# Handle GET requests.  
async def handle_get(route):  
    if route.request.method != "GET":  
        await route.fallback()  
        return  
  # Handling GET only.  
  # ...  
  
# Handle POST requests.  
async def handle_post(route):  
    if route.request.method != "POST":  
        await route.fallback()  
        return  
  # Handling POST only.  
  # ...  
  
await page.route("**/*", handle_get)  
await page.route("**/*", handle_post)  
```

--------------------------------

### install

Source: https://playwright.dev/python/docs/clock

Initializes the clock and allows you to pause, fast forward, run for a duration, and resume time. Must be called before any other clock related calls.

```APIDOC
## install

### Description
Initializes the clock and allows you to control time with `pauseAt`, `fastForward`, `runFor`, and `resume`. Must be called before any other clock related calls.

### Method
install

### Notes
- Overrides native global classes and functions related to time.
- Calling `install` after other clock related calls results in undefined behavior.
```

--------------------------------

### Async: redirected_from with redirect

Source: https://playwright.dev/python/docs/api/class-request

Async example showing how to get the original request URL after a redirect. The website http://example.com redirects to https://example.com.

```python
response = await page.goto("http://example.com")

print(response.request.redirected_from.url) # "http://example.com"
```

--------------------------------

### Sync: redirected_from with redirect

Source: https://playwright.dev/python/docs/api/class-request

Sync example showing how to get the original request URL after a redirect. The website http://example.com redirects to https://example.com.

```python
response = page.goto("http://example.com")

print(response.request.redirected_from.url) # "http://example.com"
```

--------------------------------

### credentials.install() - Install virtual WebAuthn authenticator

Source: https://playwright.dev/python/docs/api/class-credentials

Installs the virtual WebAuthn authenticator into the context, overriding navigator.credentials.create() and navigator.credentials.get() in all current and future pages. Call this before the page first touches navigator.credentials; until then, no interception is in place.

```python
credentials.install()  


```

--------------------------------

### Async Python: install, pause_at, fast_forward

Source: https://playwright.dev/python/docs/clock

Async Python test using page.clock.install, pause_at, and fast_forward to control both Date.now and timers. Install the clock at an earlier time, pause at a specific time, then fast-forward to simulate time passing.

```python
# Initialize clock with some time before the test time and let the page load  

# naturally. `Date.now` will progress as the timers fire.  

await page.clock.install(time=datetime.datetime(2024, 2, 2, 8, 0, 0))  

await page.goto("http://localhost:3333")  

  

# Pretend that the user closed the laptop lid and opened it again at 10am.  

# Pause the time once reached that point.  

await page.clock.pause_at(datetime.datetime(2024, 2, 2, 10, 0, 0))  

  

# Assert the page state.  

await expect(page.get_by_test_id("current-time")).to_have_text("2/2/2024, 10:00:00 AM")  

  

# Close the laptop lid again and open it at 10:30am.  

await page.clock.fast_forward("30:00")  

await expect(page.get_by_test_id("current-time")).to_have_text("2/2/2024, 10:30:00 AM")  


```

--------------------------------

### Create a locator and click it

Source: https://playwright.dev/python/docs/writing-tests

Creates a locator for a link with role 'link' and name 'Get started', then clicks it. Playwright waits for the element to be actionable before performing the action.

```python
# Create a locator.
get_started = page.get_by_role("link", name="Get started")

# Click it.
get_started.click()
```

--------------------------------

### test_webview2.py: Basic WebView2 test

Source: https://playwright.dev/python/docs/webview2

A simple Playwright test that navigates to the Playwright website and asserts that the 'Get Started' text is visible. Uses the page fixture from conftest.py.

```python
from playwright.sync_api import Page, expect  

  

def test_webview2(page: Page):  

    page.goto("https://playwright.dev")  

    get_started = page.get_by_text("Get Started")  

    expect(get_started).to_be_visible()  

```

--------------------------------

### Launch browser and drive automation (Sync)

Source: https://playwright.dev/python/docs/api/class-playwright

Typical example using the sync API to launch a browser, create a page, navigate to a URL, and close the browser. Uses the sync_playwright context manager.

```python
from playwright.sync_api import sync_playwright, Playwright  

def run(playwright: Playwright):  
    chromium = playwright.chromium # or "firefox" or "webkit".  
    browser = chromium.launch()  
    page = browser.new_page()  
    page.goto("http://example.com")  
    # other actions...  
    browser.close()  

with sync_playwright() as playwright:  
    run(playwright)  
```

--------------------------------

### Record trace with Playwright Async API

Source: https://playwright.dev/python/docs/trace-viewer

Async API example for recording a trace with Playwright. Start tracing before creating or navigating a page, then stop and export to trace.zip.

```python
browser = await chromium.launch()

context = await browser.new_context()

# Start tracing before creating / navigating a page.
await context.tracing.start(screenshots=True, snapshots=True, sources=True)

page = await context.new_page()
await page.goto("https://playwright.dev")

# Stop tracing and export it into a zip archive.
await context.tracing.stop(path = "trace.zip")
```

--------------------------------

### Sync: Create context with viewport, resize page, emulate high-DPI

Source: https://playwright.dev/python/docs/emulation

Shows how to set viewport size when creating a browser context, resize an individual page, and emulate high-DPI with device_scale_factor. Use in sync tests.

```python
# Create context with given viewport  
context = browser.new_context(  
  viewport={ 'width': 1280, 'height': 1024 }  
)  
  
# Resize viewport for individual page  
page.set_viewport_size({"width": 1600, "height": 1200})  
  
# Emulate high-DPI  
context = browser.new_context(  
  viewport={ 'width': 2560, 'height': 1440 },  
  device_scale_factor=2,  
)  
```

--------------------------------

### Record trace with Playwright Sync API

Source: https://playwright.dev/python/docs/trace-viewer

Sync API example for recording a trace with Playwright. Start tracing before creating or navigating a page, then stop and export to trace.zip.

```python
browser = chromium.launch()

context = browser.new_context()

# Start tracing before creating / navigating a page.
context.tracing.start(screenshots=True, snapshots=True, sources=True)

page = context.new_page()
page.goto("https://playwright.dev")

# Stop tracing and export it into a zip archive.
context.tracing.stop(path = "trace.zip")
```

--------------------------------

### Provide client certificates in browser.new_context()

Source: https://playwright.dev/python/docs/release-notes

Sets up a client certificate for the specified origin when creating a new browser context. The certificate and key files are provided as paths, and the server can verify the client as per TLS Client Authentication.

```python
context = browser.new_context(  

    client_certificates=[  

        {  

            "origin": "https://example.com",  

            "certPath": "client-certificates/cert.pem",  

            "keyPath": "client-certificates/key.pem",  

        }  

    ],  

)  
```

--------------------------------

### Sync WebStorage usage with page.local_storage

Source: https://playwright.dev/python/docs/api/class-webstorage

Sync API example for using page.local_storage to set, get, list, remove, and clear items. Requires a page instance and a valid origin.

```python
page.goto("https://example.com")  

page.local_storage.set_item("token", "abc")  

token = page.local_storage.get_item("token")  

all = page.local_storage.items()  

page.local_storage.remove_item("token")  

page.local_storage.clear()  

```

--------------------------------

### Async: Create context with viewport, resize page, emulate high-DPI

Source: https://playwright.dev/python/docs/emulation

Async version of the viewport example. Use in async tests with await.

```python
# Create context with given viewport  
context = await browser.new_context(  
  viewport={ 'width': 1280, 'height': 1024 }  
)  
  
# Resize viewport for individual page  
await page.set_viewport_size({"width": 1600, "height": 1200})  
  
# Emulate high-DPI  
context = await browser.new_context(  
  viewport={ 'width': 2560, 'height': 1440 },  
  device_scale_factor=2,  
)  
```

--------------------------------

### Get properties of JSHandle (Sync)

Source: https://playwright.dev/python/docs/api/class-jshandle

Returns a map of own property names to JSHandle instances. The example creates a handle for an object with window and document properties, retrieves them, and disposes the handle.

```python
handle = page.evaluate_handle("({ window, document })")  

properties = handle.get_properties()  

window_handle = properties.get("window")  

document_handle = properties.get("document")  

handle.dispose()  

```

--------------------------------

### Async input_value example

Source: https://playwright.dev/python/docs/api/class-locator

Asynchronous usage of locator.input_value() to get the value of an input, textarea, or select element. Throws if the element is not one of those types, unless it is inside a label with an associated control.

```python
value = await page.get_by_role("textbox").input_value()
```

--------------------------------

### Launch asyncio REPL

Source: https://playwright.dev/python/docs/library

Starts the asyncio REPL for async Python experimentation.

```bash
python -m asyncio  

```

--------------------------------

### Sync input_value example

Source: https://playwright.dev/python/docs/api/class-locator

Synchronous usage of locator.input_value() to get the value of an input, textarea, or select element. Throws if the element is not one of those types, unless it is inside a label with an associated control.

```python
value = page.get_by_role("textbox").input_value()
```

--------------------------------

### set_input_files - Async Python

Source: https://playwright.dev/python/docs/api/class-locator

Asynchronous Python examples for uploading files, directories, removing selections, and uploading buffers using locator.set_input_files().

```python
# Select one file  
await page.get_by_label("Upload file").set_input_files('myfile.pdf')  

# Select multiple files  
await page.get_by_label("Upload files").set_input_files(['file1.txt', 'file2.txt'])  

# Select a directory  
await page.get_by_label("Upload directory").set_input_files('mydir')  

# Remove all the selected files  
await page.get_by_label("Upload file").set_input_files([])  

# Upload buffer from memory  
await page.get_by_label("Upload file").set_input_files(  
    files=[  
        {"name": "test.txt", "mimeType": "text/plain", "buffer": b"this is a test"}  
    ],  
)
```

--------------------------------

### Get properties of JSHandle (Async)

Source: https://playwright.dev/python/docs/api/class-jshandle

Returns a map of own property names to JSHandle instances asynchronously. The example creates a handle for an object with window and document properties, retrieves them, and disposes the handle.

```python
handle = await page.evaluate_handle("({ window, document })")  

properties = await handle.get_properties()  

window_handle = properties.get("window")  

document_handle = properties.get("document")  

await handle.dispose()  

```

--------------------------------

### Async download with expect_download

Source: https://playwright.dev/python/docs/api/class-download

Async example of waiting for a download event and saving the file using expect_download and save_as.

```python
# Start waiting for the download  

async with page.expect_download() as download_info:  

    # Perform the action that initiates download  

    await page.get_by_text("Download file").click()  

download = await download_info.value  

  

# Wait for the download process to complete and save the downloaded file somewhere  

await download.save_as("/path/to/save/at/" + download.suggested_filename)  
```

--------------------------------

### Incorrect filter by child/descendant (Sync)

Source: https://playwright.dev/python/docs/locators

Incorrect example showing that the filtering locator must be relative to the original locator. This will not work because the filtering locator starts matching from the <ul> element, not from the <li>.

```python
# ✖ WRONG
expect(
    page.get_by_role("listitem").filter(
        has=page.get_by_role("list").get_by_role("heading", name="Product 2")
    )
).to_have_count(1)
```

--------------------------------

### Create and navigate a page (Sync)

Source: https://playwright.dev/python/docs/pages

Creates a new page in the context, navigates explicitly to a URL, fills an input, clicks a link, and prints the resulting URL. Use this for basic page interaction in synchronous code.

```python
page = context.new_page()  

# Navigate explicitly, similar to entering a URL in the browser.  
page.goto('http://example.com')  
# Fill an input.  
page.locator('#search').fill('query')  

# Navigate implicitly by clicking a link.  
page.locator('#submit').click()  
# Expect a new url.  
print(page.url)  
```

--------------------------------

### Sync Python: install, pause_at, fast_forward

Source: https://playwright.dev/python/docs/clock

Sync Python test using page.clock.install, pause_at, and fast_forward to control both Date.now and timers. Install the clock at an earlier time, pause at a specific time, then fast-forward to simulate time passing.

```python
# Initialize clock with some time before the test time and let the page load  

# naturally. `Date.now` will progress as the timers fire.  

page.clock.install(time=datetime.datetime(2024, 2, 2, 8, 0, 0))  

page.goto("http://localhost:3333")  

  

# Pretend that the user closed the laptop lid and opened it again at 10am.  

# Pause the time once reached that point.  

page.clock.pause_at(datetime.datetime(2024, 2, 2, 10, 0, 0))  

  

# Assert the page state.  

expect(page.get_by_test_id("current-time")).to_have_text("2/2/2024, 10:00:00 AM")  

  

# Close the laptop lid again and open it at 10:30am.  

page.clock.fast_forward("30:00")  

expect(page.get_by_test_id("current-time")).to_have_text("2/2/2024, 10:30:00 AM")  


```

--------------------------------

### Type text and delete with Shift (Async)

Source: https://playwright.dev/python/docs/api/class-keyboard

Async version of the previous example: types 'Hello World!', moves cursor, holds Shift, selects six characters, releases Shift, and presses Backspace. The result text will be 'Hello!'.

```python
await page.keyboard.type("Hello World!")

await page.keyboard.press("ArrowLeft")

await page.keyboard.down("Shift")

for i in range(6):

    await page.keyboard.press("ArrowLeft")

await page.keyboard.up("Shift")

await page.keyboard.press("Backspace")

# result text will end up saying "Hello!"
```

--------------------------------

### Record using custom setup with async API (page.pause())

Source: https://playwright.dev/python/docs/codegen

Use this asynchronous Playwright script to start codegen recording in a custom setup, e.g., when you need to configure the browser context with route interception. It launches a headed Chromium browser, sets up a context with a route handler, and calls page.pause() to open the codegen controls window. Requires running in headed mode (headless=False).

```python
import asyncio  
from playwright.async_api import async_playwright  

async def main():  
    async with async_playwright() as p:  
        # Make sure to run headed.  
        browser = await p.chromium.launch(headless=False)  

        # Setup context however you like.  
        context = await browser.new_context() # Pass any options  
        await context.route('**/*', lambda route: route.continue_())  

        # Pause the page, and start recording manually.  
        page = await context.new_page()  
        await page.pause()  

asyncio.run(main())  
```

--------------------------------

### Record using custom setup with sync API (page.pause())

Source: https://playwright.dev/python/docs/codegen

Use this synchronous Playwright script to start codegen recording in a custom setup, e.g., when you need to configure the browser context with route interception. It launches a headed Chromium browser, sets up a context with a route handler, and calls page.pause() to open the codegen controls window. Requires running in headed mode (headless=False).

```python
from playwright.sync_api import sync_playwright  

with sync_playwright() as p:  
    # Make sure to run headed.  
    browser = p.chromium.launch(headless=False)  

    # Setup context however you like.  
    context = browser.new_context() # Pass any options  
    context.route('**/*', lambda route: route.continue_())  

    # Pause the page, and start recording manually.  
    page = context.new_page()  
    page.pause()  
```

--------------------------------

### Use devices dictionary to emulate a device (Sync)

Source: https://playwright.dev/python/docs/api/class-playwright

Shows how to use the devices dictionary to get device descriptors and pass them to browser.new_context(). Uses the sync API.

```python
from playwright.sync_api import sync_playwright, Playwright  

def run(playwright: Playwright):  
    webkit = playwright.webkit  
    iphone = playwright.devices["iPhone 6"]  
    browser = webkit.launch()  
    context = browser.new_context(**iphone)  
    page = context.new_page()  
    page.goto("http://example.com")  
    # other actions...  
    browser.close()  

with sync_playwright() as playwright:  
    run(playwright)  
```

--------------------------------

### Use devices dictionary to emulate a device (Async)

Source: https://playwright.dev/python/docs/api/class-playwright

Shows how to use the devices dictionary to get device descriptors and pass them to browser.new_context(). Uses the async API.

```python
import asyncio  
from playwright.async_api import async_playwright, Playwright  

async def run(playwright: Playwright):  
    webkit = playwright.webkit  
    iphone = playwright.devices["iPhone 6"]  
    browser = await webkit.launch()  
    context = await browser.new_context(**iphone)  
    page = await context.new_page()  
    await page.goto("http://example.com")  
    # other actions...  
    await browser.close()  

async def main():  
    async with async_playwright() as playwright:  
        await run(playwright)  
asyncio.run(main())  
```
Tokens:
Raw