Playwright API Testing 101 — A Practical Guide to APIRequestContext for GET and POST

Playwright is best known for browser automation, but it also has API testing built in. With APIRequestContext, you can write GET, POST, PUT, and DELETE tests without installing anything extra. This article covers how to get started with API testing using nothing but Playwright’s own built-in feature — from basic requests to combining it with your UI tests.

It’s easy to assume API testing always means reaching for a separate library. If you’re already working in a pytest-playwright setup, you can start writing API tests without adding requests at all.

Working on a Playwright-based UI test project, you’ll sometimes run into situations like these:

• You need to set up a large volume of test data via API as a precondition for UI tests
• You want to verify the result of a UI action precisely, by checking the API response
• You’d rather not add a separate library (like requests) purely for API testing

Playwright’s APIRequestContext feature lets you handle all of this with the same tool, inside the same test code.

Where This Article Fits

This is an introductory article for anyone writing their first Playwright API test, focused on the basics of making GET, POST, and similar requests. More advanced, production-oriented topics — authentication flows, token retrieval, security verification — are covered in a separate, dedicated article.

requests vs. Playwright’s APIRequestContext

The requests library is the standard choice for API testing in Python, but there are good reasons to reach for Playwright’s own API testing feature instead when you’re already working in a Playwright-based project.

① A Basic GET Request

Here’s the basic form, using the playwright fixture that pytest-playwright provides, to send an independent API request.

from playwright.sync_api import Playwright

def test_get_user(playwright: Playwright) -> None:
    # Create a dedicated API request context with a base_url
    request_context = playwright.request.new_context(
        base_url="https://jsonplaceholder.typicode.com"
    )

    response = request_context.get("/users/1")

    assert response.status == 200
    assert response.ok  # True for any status in the 200–299 range

    body = response.json()
    assert body["id"] == 1

    # Explicitly dispose of the context once you're done with it
    request_context.dispose()

Reusing it via a fixture

# conftest.py
import pytest
from playwright.sync_api import Playwright, APIRequestContext

@pytest.fixture
def api_context(playwright: Playwright):
    context = playwright.request.new_context(
        base_url="https://jsonplaceholder.typicode.com"
    )
    yield context
    context.dispose()  # Automatically disposed after the test finishes

# test_users.py
def test_get_user(api_context):
    response = api_context.get("/users/1")
    assert response.status == 200

② POST, PUT, and DELETE Requests

Other HTTP methods can be called just as intuitively from the same APIRequestContext.

def test_create_user(api_context):
    # POST: create a new resource
    response = api_context.post("/users", data={
        "name": "Taro Yamada",
        "email": "taro@example.com",
    })
    assert response.status == 201
    created = response.json()
    assert created["name"] == "Taro Yamada"


def test_update_user(api_context):
    # PUT: full update
    response = api_context.put("/users/1", data={
        "name": "Updated Name",
        "email": "updated@example.com",
    })
    assert response.status == 200


def test_delete_user(api_context):
    # DELETE: remove a resource
    response = api_context.delete("/users/1")
    assert response.status == 200

③ Verifying the Response

Here’s a summary of the main properties and methods you can pull off a response object.

def test_response_details(api_context):
    response = api_context.get("/users/1")

    # Status code
    assert response.status == 200

    # Partial-match header check (an exact match tends to fail once a charset is added)
    content_type = response.headers.get("content-type", "")
    assert "application/json" in content_type

    # Confirm required fields are present
    body = response.json()
    for field in ["id", "name", "email"]:
        assert field in body, f"'{field}' is missing from the response"

④ Combining UI and API Tests

The biggest strength of Playwright’s API testing is that the browser context and the API request context can share cookies and session state. You get this by using context.request — the request property that belongs to your browser context — instead of playwright.request.

def test_ui_login_then_verify_via_api(page, context):
    # ① Log in via the UI
    page.goto("/login")
    page.get_by_label("Email").fill("test@example.com")
    page.get_by_label("Password").fill("Password123")
    page.get_by_role("button", name="Log in").click()
    page.wait_for_url("**/dashboard")

    # ② Use the same session (cookies) to check the profile via the API
    # context.request shares cookies with the browser
    response = context.request.get("/api/profile")
    assert response.status == 200
    profile = response.json()
    assert profile["email"] == "test@example.com"

Common Mistakes Seen in Practice

FAQ

📋 Summary

If you’re already using Playwright for UI tests, you don’t need to learn a new tool just to test APIs. Start with a simple GET request and try weaving it into your existing test code.