Zyte APIHeadless Browser

The managed headless browser for web data extraction

Zyte manages the stealth browser infrastructure, proxy routing, TLS fingerprinting, and CAPTCHA management, so you write scraping logic, not browser operations.

Get started with CDP Read the docs

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.connect_over_cdp(ZYTE_CDP_URL)
    page = browser.new_page()
    page.goto("https://books.toscrape.com")
    page.fill("#search", "history")
    page.press("#search", "Enter")
    page.click("article.product_pod:nth-child(1) h3 a")
    page.go_back()
    page.click("article.product_pod:nth-child(2) h3 a")
    print(page.title())

How it works

Headless browsers that unblock, click, scroll, type and do more.

One browser infrastructure, two ways in

Drive the browser yourself

CDP API

Connect your existing Playwright or Puppeteer script to a Zyte-hosted browser.

Full browser automation: multi-step flows, interception
State is kept across steps for the life of the session
Works with the scripts you already have
Capture screenshots at any point in your script
Billed per every 15s, at the domain's tier price

Start with CDP See CDP examples

Paid plan and a one-minute business verification done in your dashboard

Fetch a rendered page

REST API

Send a URL, get the rendered HTML back. One request, one response.

A browser renders the page for you, server side
Run a list of actions during the fetch: click, scroll, wait
No if/else or while loops, and a 60-second timeout
Capture a full-page screenshot in the same response
Billed per website tier plus some CPU time bill on top if actions executed

Start with REST See REST examples

$5 free credit - 30 day trial - no subscription required

What people build with it

Find your job, then pick your path

If your task needs the page after it renders, the REST API covers it. If it needs the browser to keep going after that, you want CDP.

Dismiss a cookie banner or overlay, then take the page

A fixed sequence of clicks and waits before the content is readable.

Screenshot a page

Ask for it in the response, or capture it in your script.

$38.50$42.00

Set a location or delivery postcode, then collect the prices it changes

The choice has to stick as you move through the site, so every page after it reflects the same selection.

Scroll a feed until it stops loading more

You cannot know in advance how many scrolls it takes, so the script has to decide when to stop.

Click through a multi-step flow

Search, filter, open a result, take the detail. Each step depends on the last.

Total

£105.51£—

Read what a page calculates once you interact with it

Delivery costs, availability, totals that only appear after a selection.

Render a JavaScript-heavy page and take the HTML

The page builds itself client side and a plain HTTP fetch returns nothing useful.

Give an AI agent a browser it can drive

Browser agents already speak CDP. Point yours at our endpoint instead of launching Chromium locally, and it gets proxies and ban handling without you running the infrastructure.

Skip the proxy and ban-handling setup

Every browser starts with Zyte's proxy routing and stealth fingerprint already set for the target site, so you get anti-ban out of the box instead of building and maintaining it yourself.

Move an existing script over without a rewrite

Point your current Playwright or Puppeteer script at our WebSocket endpoint instead of launching a browser locally. Navigation, selectors and interactions all stay the same.

Code snippets

Examples

Both paths use the same API key. Pick your access path, then your language.

Replace the API key with yours, then sign upPaid plan and a one-minute business verification done in your dashboard

# Drive a Zyte-hosted browser over CDP with Playwright: scroll the page and read the results.
# Replace the API key with yours. Sign up at app.zyte.com/account/signup/zyteapi
import base64
import os
from playwright.sync_api import sync_playwright

CDP_ENDPOINT = "https://browser.zyte.com/"

API_KEY = os.environ.get("ZYTE_API_KEY", "YOUR_ZYTE_API_KEY")
auth = base64.b64encode(f"{API_KEY}:".encode()).decode()
headers = {"Authorization": f"Basic {auth}"}

with sync_playwright() as p:
    browser = p.chromium.connect_over_cdp(CDP_ENDPOINT, headers=headers)
    page = browser.new_page()
    page.goto("https://quotes.toscrape.com/scroll")

    # Scroll with the mouse wheel until no new quotes load - no in-page JS.
    quotes = page.locator(".quote")
    count = 0
    while True:
        page.mouse.wheel(0, 10000)
        page.wait_for_timeout(500)
        new_count = quotes.count()
        if new_count == count:
            break
        count = new_count

    print(count)
    browser.close()

Comparison

Which one should I use?

If you only need the page content after it renders, use the REST API. If you need to control the browser, use CDP. Either way, Zyte runs the browsers, proxies and ban handling for you.

	Feature	CDP APIStart with CDP	REST APIStart with REST	Self-hosted headless	Other hosted browsers
Controlling the browserHow much of the browser you can drive, and how far a single run can go.	Rendered page in a single request	No	Yes
	Interactive browser operations during your session: click, scroll, wait, fill	Yes	Yes	Yes
	Multi-step flows	Yes	No	Yes	Yes
	Your own logic, loops and branching	Yes	No	Yes	Yes
	Network request interception	Yes	Yes	Yes
	Session state kept across steps	Yes		Yes	Yes
Fitting your stackWhat you have to write, and what you can bring with you.	Bring existing Playwright or Puppeteer scripts	Yes	No	Yes	Yes
	Call it from any language over HTTP	No	Yes	No
	Scrapy integration				No
	Usage and spend in one dashboard	Yes	Yes		Yes
Getting past blocksWho deals with proxies, fingerprints and retries when a site pushes back.	Ban handling and retries built in	Yes	Yes
	Proxy type chosen per site	Yes	Yes
	Residential proxies included	Yes	Yes
	Unique human-like browser fingerprint (stealth functionality)	Yes	Yes
Running the browsersWho owns the machines, the patching and the bill when nothing is running.	No browser fleet to run or patch	Yes	Yes	No	Yes
	Scales without capacity planning	Yes	Yes	No
	No idle cost between runs	Yes	Yes	No

Loved by developers

Awards, five-star reviews and thousands of happy customers

We set everything up once, and it continued to work for years without a hitch. The reliability is impressive - it always works, and for a scraping tool, that's very important.

Alexandr N.G2

After implementation, I don't notice it's there - but I do know that it works, because we have no problems scraping Javascript, no issues with bans or errors, and we're able to crawl everything intended.

Ravenna C.G2

Their scraping API and IP rotation is the industry leader. We have had very little blocks or failures. Pricing is fair and support has been impeccable when needed.

Ray H.G2

FAQ

Headless Browser FAQ

A paid subscription and a verified business account. CDP API is only available to businesses. Browser CDP is not available on pay as you go, and we verify your business once per organisation before access is granted. The REST API has neither requirement, so you can start there on pay as you go and add CDP later.

Playwright and Puppeteer both work, connecting over CDP. Playwright works in Python and JavaScript, Puppeteer is JavaScript only. Scrapy works too, through scrapy-playwright, and there is a Scrapy example in the code snippets on this page. Selenium is not currently supported, as the connection uses CDP over WebSockets, which Playwright and Puppeteer support but Selenium does not.

Yes, 60 seconds. Each REST call is a single request and response, so everything has to finish inside it. If you need longer, or need to keep a session open across steps, use CDP.

In the US. Sessions currently run from a single US region, so requests reach the target site from there, and scripts running close to US infrastructure will see lower latency.