7-day Trial

Oxylabs Review 2026: 7 Benchmark Tests, Pricing and Costs

Picture of Anthony Heath

Try Gologin for free

Oxylabs is one of the largest web data vendors, and its newest product is Web API: one endpoint, /v1/scrape, that takes a URL and returns the page as Markdown, HTML, JSON or a screenshot, with proxies, rendering and access challenges handled on Oxylabs’ side. For pages that need a live session, the same account sells Agent Browser, a cloud browser you drive over CDP.

This Oxylabs review covers the Web API features, the credit system and Oxylabs pricing, then runs Oxylabs and Gologin on the same seven targets, with the same runs, the same retry rule and the same success check. Each side brings two layers: Oxylabs Web API and Agent Browser against Gologin Web Unlocker and Gologin Cloud Browser.

Every number below comes from a logged run on 16 November 2026, including Gologin’s losses.

Oxylabs vs Gologin: Key Takeaways

  • First attempt: Oxylabs Web API returned the full page in 50 of 50 runs on tests 1 to 5 without a single retry. Web Unlocker got 31 of 50: 18 runs ended in HTTP 503 and one Walmart page came back without the product.
  • With retries: a draw at 49 to 49. With up to 3 retries on HTTP 502, 503 and 504, Web Unlocker missed one Indeed run after four 503 responses; Oxylabs missed one Amway run with an HTTP 500 that it did not charge.
  • Speed: Web Unlocker was faster on the static page (2.01 s against 2.55 s), the JavaScript page (3.51 s against 10.34 s) and Amway (20.76 s against 35.24 s). Oxylabs was faster on Walmart, 3.59 s against 12.12 s, and slightly faster on Indeed.
  • Cost: a page on Oxylabs costs $1.00 per 1,000 without JavaScript and $1.50 with it on Starter ($15). Web Unlocker is $0.98 on Growth ($49) and $0.75 on Professional ($149), rendering included, so JavaScript pages cost less on Gologin.
  • Configuration: the Oxylabs default request did not render the quotes page or the Amway prices: 0/5 on each, billed. With run_js set to true both went 10/10. Web Unlocker returned both with its default request.
  • Infinite scroll: both browsers loaded 50 quotes in 10 of 10 runs: Oxylabs Agent Browser at a median of 10.22 s, Gologin Cloud Browser at 13.93 s.
  • Escalation on Indeed: Cloud Browser opened the job list 10/10 at 10.93 s. Agent Browser got 6/10 at 7.10 s; three runs stopped on a Cloudflare “Just a moment…” page, and its challenge handler is not enabled on self-service accounts.
  • Browser cost: Agent Browser bills traffic at $8/GB, about $25 per 1,000 Amway pages and $12 per 1,000 Indeed sessions in our runs. Cloud Browser bills time: $0.27 to $0.35 per 1,000 pages at $0.09 an hour. Neither is the universal best web scraping API.
Oxylabs (Web API + Agent Browser) Gologin (Web Unlocker + Cloud Browser)
Success, tests 1 to 5, first attempt 50/50 31/50
Success, tests 1 to 5, with retries 49/50 49/50
Median time, hardest target (#3 Indeed, with retries) 22.30 s 23.73 s
Cost per 1K pages, entry plan $1.00 to $1.50 (Starter, $15) $0.98 (Growth, $49)
Cost per 1K pages, about $100 a month $0.90 to $1.40 (Basic, $100) $0.75 (Professional, $149)
Browser, escalation test #7 (Indeed) 6/10, 7.10 s 10/10, 10.93 s
Browser price unit traffic, $8/GB time, $0.09/hour
Free start $5 credit for any product 1,000 requests, 7 days, no card

What Is Oxylabs?

Oxylabs sells proxies and web data tools from one account and one balance. Its product page lists “177M+” proxies “across 195 countries”. Web API is the scraping layer on top: you create a Web API instance in the dashboard, get a Bearer key and POST a URL to /v1/scrape. Oxylabs handles the proxy, the headless browser and the access challenge, and returns the page in the formats you ask for.

Product What it does When you use it
Web API /scrape One URL to Markdown, HTML, JSON or a PNG screenshot Any public page, real-time
Dedicated scrapers /v1/scrape/{target}/{collection} for Amazon, Google, Walmart and more, parsed JSON Known targets without a parser
AI parsing JSON from a prompt or a schema in the same request Structured data
Search Web search results through the same API Research for agents
Agent Browser Cloud Chromium over CDP with residential IPs and geotargeting Clicks, scrolling, logins
Web Unblocker and proxies Proxy-style access and IP pools Your own scrapers

The oxylabs web scraper api is the first product we tested. The second is Agent Browser, which connects from Playwright or Puppeteer with a username and password and supports country, state and city targeting, session recording and an MCP server. The Oxylabs amazon scraper and the other dedicated scrapers use the same key, but we tested generic URLs only.

Oxylabs Web API scrape product page, the web scraper API reviewed here

How We Tested Oxylabs and Gologin

All runs took place on 16 November 2026, both tools from one machine: first the Oxylabs configuration ladder, then 10 first-attempt runs per tool and target, then 10 more with retries, then the browser tests. Runs were at least 10 seconds apart, and every URL carried a fresh cache-busting parameter (cb=timestamp).

# Scenario Target Success marker
1 Static HTML books.toscrape.com product page title and £ price
2 JavaScript-rendered quotes.toscrape.com/js/ at least 10 quotes
3 Site behind Cloudflare indeed.com job search, New York heading and a job card, no challenge
4 Site running DataDome amway.com Skin Care category at least 10 prices, no challenge
5 Marketplace product walmart.com item 5689919121 product title and price
6 Infinite scroll quotes.toscrape.com/scroll at least 50 quotes
7 Escalation indeed.com job search, New York heading and a job card, no challenge
  • Configuration rule: Oxylabs started with the default request, then stepped up to run_js true and then to a US location only when the marker failed in 3 of 5 runs. Agent Browser started with the default connection and stepped up to its page handler.
  • Retries: the Gologin product team told us to expect first-attempt errors on hard targets and to retry 502 and 503 responses 2 to 3 times. Both tools got the same rule: up to 3 retries on HTTP 502, 503 and 504, a 3 s pause, and the time of every attempt counted in the run.
  • Success and cost: a run counts only when one shared parser finds the marker in the body, never on HTTP 200 alone. Oxylabs has no balance endpoint, so we read the spend in its dashboard before and after the tests and matched it to our logged calls.
  • Escalation target: test #7 uses the target where Web Unlocker scored lowest on tests 1 to 5, which was Indeed.
python -m venv .venv && source .venv/bin/activate && pip install requests beautifulsoup4 playwright python-dotenv
import time
import requests
from common import fresh, key

RETRY_ON = (502, 503, 504)

def scrape(url, output=("markdown", "html"), **params):
    body = {"url": fresh(url), "output": list(output), **params}
    start = time.perf_counter()
    response = requests.post("https://webapi.oxylabs.io/v1/scrape", json=body, timeout=180,
                             headers={"Authorization": f"Bearer {key('COMPETITOR_API_KEY')}"})
    return response, time.perf_counter() - start

def with_retries(call, retries=3, pause=3):
    attempt, waited = 0, 0.0
    while True:
        attempt += 1
        response, elapsed, found, body = call()
        waited += elapsed
        if response.status_code not in RETRY_ON or attempt > retries:
            return response, waited, found, attempt
        time.sleep(pause)
        waited += pause

Oxylabs ran on the $5 welcome credit. All our tests, Web API and Agent Browser together, used $0.60 of it.

Oxylabs Features and Full API Parameters

The /v1/scrape endpoint is the core of Oxylabs Web API. You POST url and an output list; one request can return Markdown and HTML together, and it is billed as one result.

curl https://webapi.oxylabs.io/v1/scrape -H "Authorization: Bearer YOUR_API_KEY" -H "Content-Type: application/json" -d '{"url": "https://example.com", "output": ["markdown", "html"]}'
  • Rendering: run_js “Executes the page’s own JavaScript before the content is captured”. Without it, the API picks “the optimal execution path” itself (Oxylabs docs).
  • Rendering costs more: custom domains are $1.50 per 1,000 results with JavaScript and $1.00 without on Starter, and the dashboard billed our run_js calls at the JavaScript rate.
  • Output: Markdown “Optimized for ingestion into LLM context windows”, raw HTML, a base64 PNG screenshot (run_js required) and JSON.
  • AI parsing: a prompt or a JSON schema in the json field, at $3.00 per 1,000 parsed pages on top of the result.
  • Geo-targeting: location takes any two-letter ISO country code; device switches between desktop and mobile.
  • Delivery: real-time by default, plus async jobs, batch and delivery to cloud storage.
  • Timeouts: the docs advise a client timeout of 150 seconds, because a rendered scrape runs “in seconds, not milliseconds”.
  • Errors: retry 408, 429 and 5xx about 3 times with backoff; “500 REQUEST_FAILED_AFTER_TOO_MANY_RETRIES” means “All upstream engines failed. Not charged.”
  • Response details: each result carries metadata with the target’s own status code and whether JavaScript ran.
Parameter Type Default What it does Cost effect
url string none Target URL, http or https none
output array html markdown, html, json, screenshot, several at once one result per request
run_js boolean optimal path Renders the page in a headless browser $1.50 instead of $1.00 per 1K on Starter
location string none Two-letter country code none measured
device string desktop Desktop or mobile user agent and viewport none stated
json object none prompt or schema for AI parsing $3.00 per 1K parsed pages
check_empty_geo boolean none Checks the geo of the returned page none stated
  • One request, one result: every call that returned HTTP 200 counted as one result in the dashboard, Markdown and HTML together.
  • Default is not always rendered: on the quotes page and on Amway, the default request came back without JavaScript, and those results were billed.

Oxylabs Review: Hands-On Testing Results

Test #1: Static HTML page

We sent the books.toscrape.com product page with the default request.

from common import credits_of, html_of, markdown_of, run_js_of, scrape, target_code
from markers import static_page

TARGET = "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html"

def run(**params):
    response, elapsed = scrape(TARGET, **params)
    markdown = markdown_of(response)
    html = html_of(response)
    found = static_page(markdown) or static_page(html)
    print(f"Config        : {params or 'default'}")
    print(f"HTTP status   : {response.status_code} (target {target_code(response)}, run_js {run_js_of(response)})")
    print(f"Markdown      : {len(markdown):,} chars")
    print(f"HTML          : {len(html):,} chars")
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    print(f"Cost          : ${credits_of(response)}")
    return response, elapsed, found, html or markdown

with_retries(run)

Every run returned the title and price, without JavaScript.

Oxylabs review test #1: terminal output for the static books.toscrape.com page, one non-JS result

10/10 successful, median 2.55 s, slowest 3.97 s, one non-JS result each, no retries needed. The first attempt round gave the same 10/10 at 3.35 s.

Book product page with title and price returned by Oxylabs Web API

Test #2: JavaScript-rendered page

The default request returned the page as served, before its JavaScript ran, so we stepped up to run_js true.

from common import credits_of, html_of, markdown_of, scrape
from markers import js_quotes

TARGET = "https://quotes.toscrape.com/js/"

def run(**params):
    response, elapsed = scrape(TARGET, **params)
    markdown = markdown_of(response)
    html = html_of(response)
    found = js_quotes(markdown) or js_quotes(html)
    print(f"HTTP status   : {response.status_code}")
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    print(f"Cost          : ${credits_of(response)}")
    return response, elapsed, found, html or markdown

with_retries(lambda: run(run_js=True))

With rendering on, the 10 quotes came back in every run.

Oxylabs terminal output for quotes.toscrape.com/js/ with run_js true, billed at the JS rate

10/10 successful, median 10.34 s, slowest 15.55 s, one JavaScript result each. The first attempt round was 10/10 at 10.32 s. The ladder before it: the default request got 0/5 in about 2 s per call, every one HTTP 200 without quotes and billed as a result.

JavaScript-rendered quotes page returned by Oxylabs with run_js

Oxylabs default response for the quotes page before its JavaScript ran, billed as a result

Test #3: Site behind Cloudflare

We sent an indeed.com job search for python developer in New York with the default request.

from common import credits_of, html_of, markdown_of, run_js_of, scrape
from markers import job_search

TARGET = "https://www.indeed.com/jobs?q=python+developer&l=New+York%2C+NY"

def run(**params):
    response, elapsed = scrape(TARGET, **params)
    markdown = markdown_of(response)
    html = html_of(response)
    found = job_search(markdown) or job_search(html)
    print(f"HTTP status   : {response.status_code} (run_js {run_js_of(response)})")
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    print(f"Cost          : ${credits_of(response)}")
    return response, elapsed, found, html or markdown

with_retries(run)

The job list came back in every run. Here the default path rendered the page by itself, and it was billed at the JavaScript rate.

Oxylabs terminal output for an Indeed job search behind Cloudflare, rendered by default

10/10 successful, median 22.30 s, slowest 24.85 s, no retries needed. The first attempt round was also 10/10, at 33.23 s, with one run that took 111.97 s. For job data without writing a parser, Gologin also has a ready Indeed scraper.

Indeed job cards for python developer in New York parsed from Oxylabs HTML

Test #4: Site running DataDome

We sent the Amway Skin Care category. The default request came back as the real Amway page, but without the prices, which load with JavaScript, so we stepped up to run_js true.

from common import credits_of, html_of, markdown_of, scrape
from markers import category_page

TARGET = "https://www.amway.com/en_US/Shop/Beauty/Skin-Care/c/105"

def run(**params):
    response, elapsed = scrape(TARGET, **params)
    markdown = markdown_of(response)
    html = html_of(response)
    found = category_page(markdown) or category_page(html)
    print(f"HTTP status   : {response.status_code}")
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    print(f"Cost          : ${credits_of(response)}")
    return response, elapsed, found, html or markdown

with_retries(lambda: run(run_js=True))

Nine runs returned the product grid with prices.

Oxylabs terminal output for the Amway category page running DataDome with run_js true

9/10 successful, median 35.24 s, slowest 50.81 s. The miss was “500 REQUEST_FAILED_AFTER_TOO_MANY_RETRIES” after 34.66 s, not charged; our shared rule retries only 502, 503 and 504, while the Oxylabs docs advise retrying a 500 too. On the first attempt round it was 10/10 at 23.16 s.

Amway Skin Care product grid with prices returned by Oxylabs

The ladder before it: the default request got 0/5. Each answer was HTTP 200 with the Amway page title and layout but fewer than 10 prices, and each was billed as a non-JS result.

Amway page without rendered prices that Oxylabs returned by default and billed

Test #5: Marketplace product page

We sent the Walmart product page for item 5689919121 with the default request.

from common import credits_of, html_of, markdown_of, scrape
from markers import product_page

TARGET = "https://www.walmart.com/ip/5689919121"

def run(**params):
    response, elapsed = scrape(TARGET, **params)
    markdown = markdown_of(response)
    html = html_of(response)
    found = product_page(markdown) or product_page(html)
    print(f"HTTP status   : {response.status_code}")
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    print(f"Cost          : ${credits_of(response)}")
    return response, elapsed, found, html or markdown

with_retries(run)

Every run returned the product title and price.

Oxylabs terminal output for a Walmart product page, one non-JS result

10/10 successful, median 3.59 s, slowest 4.29 s, one non-JS result each; 10/10 at 3.92 s on the first attempt too. This was Oxylabs’ best result against Web Unlocker, more than three times faster.

Walmart product title and price parsed from Oxylabs HTML

Test #6: Infinite scroll with Oxylabs Agent Browser

We connected to Agent Browser from Playwright with a US location, the way the Oxylabs docs show, and scrolled until 50 quotes were on the page.

import time
from playwright.sync_api import sync_playwright
from common import key

TARGET = "https://quotes.toscrape.com/scroll"
ENDPOINT = "wss://{}:{}@hb.oxylabs.io?p_cc=US"

def run():
    start = time.perf_counter()
    with sync_playwright() as p:
        browser = p.chromium.connect_over_cdp(ENDPOINT.format(key("OXYLABS_AB_USER"), key("OXYLABS_AB_PASS")), timeout=90000)
        context = browser.contexts[0] if browser.contexts else browser.new_context()
        page = context.new_page()
        page.goto(TARGET, timeout=90000)
        quotes = page.locator("div.quote")
        for _ in range(20):
            if quotes.count() >= 50:
                break
            page.mouse.wheel(0, 5000)
            page.wait_for_timeout(1000)
        count = quotes.count()
        browser.close()
    print(f"Quotes loaded : {count}")
    print(f"Marker found  : {count >= 50}")
    print(f"Elapsed       : {time.perf_counter() - start:.2f}s")
    return count

run()

The loop stopped at 50 quotes in every run.

Oxylabs Agent Browser terminal output for the infinite scroll test, 50 quotes loaded

10/10 successful, median 10.22 s including the connection, slowest 38.53 s. The dashboard billed the quotes.toscrape.com traffic of all Agent Browser sessions at about $0.01, roughly $1 per 1,000 scroll sessions at $8/GB.

Quotes page scrolled to 50 quotes in Oxylabs Agent Browser

Test Target Configuration Success Median s Slowest s Units per success
#1 Static books.toscrape.com Web API, default 10/10 2.55 3.97 1 non-JS result
#2 JavaScript quotes.toscrape.com/js/ Web API, run_js 10/10 10.34 15.55 1 JS result
#3 Cloudflare indeed.com Web API, default (rendered) 10/10 22.30 24.85 1 JS result
#4 DataDome amway.com Web API, run_js 9/10 35.24 50.81 1 JS result
#5 Marketplace walmart.com Web API, default 10/10 3.59 4.29 1 non-JS result
#6 Scroll quotes.toscrape.com/scroll Agent Browser, US 10/10 10.22 38.53 traffic, about 0.1 MB
#7 Escalation indeed.com Agent Browser, US 6/10 7.10 7.95 traffic, about 1.5 MB per session

Gologin Web Unlocker and Cloud Browser: Same Targets, Same Method

What is the Gologin stack

Gologin Web Unlocker is the page retrieval API inside the Gologin stack. You send one GET request with a URL; it renders the JavaScript, comes in on a residential IP from the country, state or city you pick and returns HTML, Markdown, text or JSON at one flat price per page. It is listed as built for AI agents and offers sticky sessions and batch jobs with webhooks. Gologin Cloud Browser is the second layer: a cloud browser with a residential IP, billed by the hour and driven from Playwright or Puppeteer with a profile id, the same job a scraping browser does.

Feature Web Unlocker Cloud Browser
Unit page browser hour
Entry price $49 for 50k pages $4.50 for 50 hours
JavaScript rendering included, same price full browser
Geo-targeting country, state, city per profile proxy
Batch and async yes, with webhooks not documented
Failed requests free billed by time
Interaction none clicks, scroll, login
Free start 1,000 requests, 7 days 3 runs of 15 min

Gologin Web Unlocker product page, the Oxylabs alternative used in this benchmark

Test #1: Static HTML page

We sent the same books.toscrape.com URL with the default request, which returns HTML.

from common import unlocker
from markers import static_page

TARGET = "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html"

def run(**params):
    response, elapsed = unlocker(TARGET, **params)
    body = response.text if response.status_code == 200 else ""
    found = static_page(body)
    print(f"HTTP status   : {response.status_code}")
    print(f"Body          : {len(body):,} chars")
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    return response, elapsed, found, body

with_retries(run)

Every run returned the title and price.

Gologin Web Unlocker terminal output for the static books.toscrape.com page

10/10 successful, median 2.01 s, 1 request each, slowest 17.42 s; two runs needed retries after HTTP 503. On the first attempt only, it was 7/10 at 1.69 s: three runs ended in HTTP 503 “Service temporarily unavailable” and were not charged.

Book product page with title and price returned by Gologin Web Unlocker

Test #2: JavaScript-rendered page

We sent quotes.toscrape.com/js/ with the same default request, no rendering option.

from common import unlocker
from markers import js_quotes

TARGET = "https://quotes.toscrape.com/js/"

def run(**params):
    response, elapsed = unlocker(TARGET, **params)
    body = response.text if response.status_code == 200 else ""
    found = js_quotes(body)
    print(f"HTTP status   : {response.status_code}")
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    return response, elapsed, found, body

with_retries(run)

The rendered quotes were in the body in every run.

Gologin Web Unlocker terminal output for the JavaScript-rendered quotes page

10/10 successful, median 3.51 s, 1 request each, slowest 5.82 s, no retries needed. On the first attempt only, it was also 10/10, at 1.57 s, about six times faster than Oxylabs with run_js.

Rendered quotes page returned by Gologin Web Unlocker with the default request

Test #3: Site behind Cloudflare

We sent the indeed.com search URL with the default request.

from common import unlocker
from markers import job_search

TARGET = "https://www.indeed.com/jobs?q=python+developer&l=New+York%2C+NY"

def run(**params):
    response, elapsed = unlocker(TARGET, **params)
    body = response.text if response.status_code == 200 else ""
    found = job_search(body)
    print(f"HTTP status   : {response.status_code}")
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    return response, elapsed, found, body

with_retries(run)

Nine runs returned the job list.

Gologin Web Unlocker terminal output for Indeed: two HTTP 503 responses, then the page

9/10 successful, median 23.73 s, 1 request each, slowest 38.24 s. Nine of the ten runs needed at least one retry after HTTP 503, and one ran out of attempts after four 503 responses. On the first attempt only, it was 3/10 at 5.77 s, the weakest Web Unlocker result in this test.

Indeed job list returned by Gologin Web Unlocker

Test #4: Site running DataDome

We sent the Amway Skin Care category URL with the default request.

from common import unlocker
from markers import category_page

TARGET = "https://www.amway.com/en_US/Shop/Beauty/Skin-Care/c/105"

def run(**params):
    response, elapsed = unlocker(TARGET, **params)
    body = response.text if response.status_code == 200 else ""
    found = category_page(body)
    print(f"HTTP status   : {response.status_code}")
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    return response, elapsed, found, body

with_retries(run)

Every run returned the product grid with prices.

Gologin Web Unlocker terminal output for the Amway category page running DataDome

10/10 successful, median 20.76 s, 1 request each, slowest 54.67 s, no retries needed. On the first attempt only, it was 5/10 at 28.08 s, with five HTTP 503 responses, all free.

Amway Skin Care product grid with prices returned by Gologin Web Unlocker

Test #5: Marketplace product page

We sent the Walmart product URL with the default request.

from common import unlocker
from markers import product_page

TARGET = "https://www.walmart.com/ip/5689919121"

def run(**params):
    response, elapsed = unlocker(TARGET, **params)
    body = response.text if response.status_code == 200 else ""
    found = product_page(body)
    print(f"HTTP status   : {response.status_code}")
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    return response, elapsed, found, body

with_retries(run)

Every run returned the product title and price.

Gologin Web Unlocker terminal output for the Walmart product page

10/10 successful, median 12.12 s, 1 request each, slowest 17.47 s, more than three times Oxylabs’ 3.59 s. On the first attempt only, it was 6/10 at 23.48 s: three HTTP 503 responses and one page without the product. For ready product data, Gologin also has a Walmart scraper.

Walmart product title and price parsed from Gologin Web Unlocker HTML

Test #6: Infinite scroll with Gologin Cloud Browser

We connected to Cloud Browser from Playwright with a profile id that has a Gologin US residential proxy and scrolled until 50 quotes were on the page.

from playwright.sync_api import sync_playwright
from common import key

TARGET = "https://quotes.toscrape.com/scroll"
ENDPOINT = "wss://cloudbrowser.gologin.com/connect?token={}&profile={}"

def run():
    with sync_playwright() as p:
        browser = p.chromium.connect_over_cdp(ENDPOINT.format(key("GOLOGIN_CLOUD_BROWSER_TOKEN"), key("GOLOGIN_PROFILE_ID")))
        page = browser.contexts[0].pages[0]
        page.goto(TARGET)
        quotes = page.locator("div.quote")
        for _ in range(20):
            if quotes.count() >= 50:
                break
            page.mouse.wheel(0, 5000)
            page.wait_for_timeout(1000)
        count = quotes.count()
        browser.close()
    print(f"Quotes loaded : {count}")
    print(f"Marker found  : {count >= 50}")
    return count

run()

The loop stopped at 50 quotes in every run.

Gologin Cloud Browser terminal output for the infinite scroll test through Playwright

10/10 successful, median 13.93 s including the connection, slowest 14.91 s, about 0.004 browser hours each. Agent Browser was faster at the median; Cloud Browser had the tighter spread.

Quotes page scrolled to 50 quotes in Gologin Cloud Browser

Test #7: Escalation to Cloud Browser on Indeed

Indeed was the lowest Web Unlocker target on tests 1 to 5, 3/10 on the first attempt and 9/10 with retries, so test #7 opened it in Cloud Browser and waited up to 30 s for the job list, with a new profile and US residential proxy per run.

import time
from playwright.sync_api import sync_playwright
from common import fresh, key, stop_session
from markers import job_search

TARGET = "https://www.indeed.com/jobs?q=python+developer&l=New+York%2C+NY"
ENDPOINT = "wss://cloudbrowser.gologin.com/connect?token={}&profile={}"

def run(profile):
    start = time.perf_counter()
    try:
        with sync_playwright() as p:
            browser = p.chromium.connect_over_cdp(ENDPOINT.format(key("GOLOGIN_CLOUD_BROWSER_TOKEN"), profile))
            page = browser.contexts[0].pages[0]
            page.goto(fresh(TARGET), wait_until="domcontentloaded", timeout=90000)
            html = page.content()
            for _ in range(30):
                if job_search(html):
                    break
                page.wait_for_timeout(1000)
                html = page.content()
            browser.close()
        elapsed = time.perf_counter() - start
    finally:
        stop_session(profile)
    found = job_search(html)
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    return html, elapsed, found

Every run loaded the job list.

Gologin Cloud Browser terminal output for the Indeed job search with a new profile per run

10/10 successful, median 10.93 s, slowest 13.31 s, about 0.003 browser hours each, with no reconnects.

Indeed job list loaded in Gologin Cloud Browser

Test Target Configuration Success Median s Slowest s Units per success
#1 Static books.toscrape.com Web Unlocker, default 10/10 2.01 17.42 1 request
#2 JavaScript quotes.toscrape.com/js/ Web Unlocker, default 10/10 3.51 5.82 1 request
#3 Cloudflare indeed.com Web Unlocker, default 9/10 23.73 38.24 1 request
#4 DataDome amway.com Web Unlocker, default 10/10 20.76 54.67 1 request
#5 Marketplace walmart.com Web Unlocker, default 10/10 12.12 17.47 1 request
#6 Scroll quotes.toscrape.com/scroll Cloud Browser, US residential 10/10 13.93 14.91 0.004 h
#7 Escalation indeed.com Cloud Browser, new profile per run 10/10 10.93 13.31 0.003 h

Oxylabs Pricing and Credit System Explained

Oxylabs pricing is one subscription for every product: a monthly plan buys a dollar balance, and each product draws from it at its own rate. Web API bills per 1,000 results, with a higher rate when JavaScript runs; Agent Browser bills per GB of traffic. Unused balance expires at the end of the cycle, and self-service purchases are not refundable.

The dashboard splits the spend by product, by billing type and by target domain. Our whole test cost $0.60: Web API $0.18 for 141 results, of which 75 with JavaScript at $1.50 per 1,000 and 66 without at $1.00, and Agent Browser $0.42 for 53.1 MB. The 141 results match our successful calls exactly, so the HTTP 500 was not charged. Ten of them were the default answers from tests 2 and 4 without the content.

Oxylabs dashboard spending before the benchmark tests

Plan Monthly price Units included Price per unit Concurrency Overage
Welcome credit $0 $5 balance, once JS $1.50, non-JS $1.00 per 1K not stated none
Starter $15 up to 10K JS results JS $1.50, non-JS $1.00 per 1K until HTTP 429 not stated
Basic $100 up to 71K JS results JS $1.40, non-JS $0.90 per 1K until HTTP 429 not stated
Flexible $500 up to 384K JS results JS $1.30, non-JS $0.80 per 1K until HTTP 429 not stated
Enterprise from $2,500 2.05M+ JS results JS $1.22, non-JS $0.75 per 1K custom custom

Other rates on the same balance: AI parsing $3.00 per 1,000 parsed pages, Google with JavaScript from $1.35, Amazon without JavaScript from $0.50, and Agent Browser at $8 per GB on the welcome credit and Starter, $7.50 on Basic, $5.50 on Flexible and $4 on Enterprise.

Scenario (test) Units per request Cheapest plan $ (Starter) Comparable plan $ (Basic, $100)
Static (#1) 1 non-JS result $1.00 $0.90
JavaScript (#2) 1 JS result $1.50 $1.40
Cloudflare (#3) 1 JS result $1.50 $1.40
DataDome (#4) 1 JS result $1.50 $1.40
Marketplace (#5) 1 non-JS result $1.00 $0.90
Scroll (#6), Agent Browser quotes traffic about $1 about $0.94
Indeed in a browser (#7), Agent Browser about 1.5 MB per session about $12 per 1K sessions about $11
Any page with AI parsing result + parsed page $4.00 to $4.50 $3.90 to $4.40

Oxylabs dashboard after the tests: $0.60 spent, Web API $0.18 and Agent Browser $0.42

The Targets tab shows where the browser money went. Amway cost $0.25 in Agent Browser traffic for 10 sessions, about $25 per 1,000 pages. Indeed cost about $0.12 across indeed.com, its asset host and the Cloudflare challenge host, including the three runs that stopped on the challenge. Skipping images in Playwright would cut that traffic; we left both browsers at their defaults.

Oxylabs spending by target domain, with Amway and Indeed Agent Browser traffic

Gologin prices differently. Web Unlocker charges one flat price per returned page: $0.98 per 1,000 on Growth ($49 for 50k) and $0.75 on Professional ($149 for 200k), with rendering and city-level targeting included and failed pages free. Cloud Browser bills browser time: $4.50 for 50 hours on Professional and $0.09 for each extra hour, so our 10.93 s Indeed run comes to about $0.27 per 1,000 pages and the 13.93 s scroll to about $0.35, whatever the page weighs.

Oxylabs Pros

  • Best first attempt: 50 of 50 runs on tests 1 to 5 without retries, against 31 for Web Unlocker.
  • Fast on Walmart and static pages: 3.59 s on Walmart against 12.12 s, and medians under 4 s on both pages without JavaScript.
  • Low entry price: $5 of free credit for any product, then $15 a month.
  • Clear billing: the dashboard splits spend by product, JS and non-JS rate and target domain, and it matched our own count to the result.
  • Wide product range: dedicated scrapers, AI parsing, async and batch delivery and Agent Browser on one balance.

Oxylabs Cons

  • Default does not always render: the quotes page and the Amway prices came back unrendered, 0/5 on each, and were billed.
  • Rendering costs 50% more: $1.50 per 1,000 against $1.00, and three of our five targets needed it.
  • Slow with JavaScript: 10.34 s on the quotes page against 3.51 s on Web Unlocker, and 35.24 s on Amway against 20.76 s.
  • Browser billed by traffic: about $25 per 1,000 Amway pages at $8/GB, including the traffic of challenge pages.
  • Long tails: one Indeed request took 111.97 s on the first attempt round.

Oxylabs Limitations

  • Page handler on request: Agent Browser’s challenge handler is off for self-service accounts; all 10 runs with it ended in “400 Bad Request” on the handshake.
  • Restricted targets: some site categories in Agent Browser need a KYC process with an account manager.
  • Session caps: 100 concurrent Agent Browser sessions, 10 new sessions per second and 5 persistent sessions by default.
  • Balance expires: unused credit does not roll over, and self-service purchases are non-refundable.
  • Country only on Web API: location takes a country code; state and city targeting is listed for Agent Browser.

Oxylabs vs Gologin: Head-to-Head Results

The two stacks split the work the same way: a request API for pages and a cloud browser for sessions. They differ in what they charge for. Oxylabs bills a result for every HTTP 200, at a higher rate when JavaScript runs, and bills its browser by traffic. Gologin bills one flat price per successful page, rendered or not, and bills its browser by time.

Aspect Oxylabs Gologin stack
What you send POST with url, output, run_js, location GET with a URL (Web Unlocker) or a Playwright session (Cloud Browser)
Rendering optimal path by default, run_js true to force it included in Web Unlocker
Price unit result per 1K, JS rate and non-JS rate page (Web Unlocker), hour (Cloud Browser)
Browser product Agent Browser, billed per GB Cloud Browser, billed per hour
Output Markdown, HTML, JSON, screenshot HTML, Markdown, text and JSON

Oxylabs alternative: when Gologin is a better choice

Scenario Better fit From our tests or the docs
JavaScript pages at volume Web Unlocker $0.98 per 1K with rendering against $1.50; 3.51 s against 10.34 s
Sites running DataDome Web Unlocker 10/10 at 20.76 s against 9/10 at 35.24 s
Pages behind Cloudflare in a browser Cloud Browser 10/10 against 6/10 on test #7
Heavy pages in a browser Cloud Browser billed by time: about $0.27 per 1K on Indeed, against traffic at $8/GB
City or state targeting in a request API Web Unlocker documented on the product page; country only on Oxylabs Web API
Test Oxylabs success Oxylabs median s Gologin success Gologin median s
#1 Static 10/10 2.55 10/10 2.01
#2 JavaScript 10/10 10.34 10/10 3.51
#3 Cloudflare 10/10 22.30 9/10 23.73
#4 DataDome 9/10 35.24 10/10 20.76
#5 Marketplace 10/10 3.59 10/10 12.12
#6 Scroll 10/10 10.22 10/10 13.93
#7 Escalation 6/10 7.10 10/10 10.93
Test, first attempt only (16 Nov) Oxylabs Web Unlocker
#1 Static 10/10, 3.35 s 7/10, 1.69 s
#2 JavaScript 10/10, 10.32 s 10/10, 1.57 s
#3 Cloudflare 10/10, 33.23 s 3/10, 5.77 s
#4 DataDome 10/10, 23.16 s 5/10, 28.08 s
#5 Marketplace 10/10, 3.92 s 6/10, 23.48 s
Scenario Oxylabs, cheapest plan Oxylabs, comparable plan Gologin, entry plan Gologin, comparable plan
Static (#1) $1.00 $0.90 $0.98 $0.75
JavaScript (#2) $1.50 $1.40 $0.98 $0.75
Cloudflare (#3) $1.50 $1.40 $0.98 $0.75
DataDome (#4) $1.50 $1.40 $0.98 $0.75
Marketplace (#5) $1.00 $0.90 $0.98 $0.75
Scroll (#6) about $1 about $0.94 $0.35 $0.31
Indeed in a browser (#7) about $12 per 1K sessions about $11 $0.27 $0.24
Feature Oxylabs Gologin stack
Pricing model per 1K results, JS and non-JS rates; browser per GB per page, flat; browser per hour
JS rendering optimal path or run_js true, at the JS rate included
Geo-targeting level country on Web API; city and state on Agent Browser country, state, city (product page)
Proxy tiers managed by the API managed; residential on Cloud Browser
Sticky session Agent Browser sessions and persistent profiles Web Unlocker sticky sessions; Cloud Browser session
Output formats Markdown, HTML, JSON, screenshot HTML, Markdown, text, JSON
Structured extraction dedicated scrapers and AI parsing not documented
Browser-level control Agent Browser over CDP Gologin Cloud Browser
Batch and webhooks async, batch, cloud storage delivery batch and async with webhooks (product page)
Failure signalling HTTP 408, 429, 500, 503; target code in metadata HTTP 503 and 504, failed pages free
Charged responses every HTTP 200 successful pages only
Free start $5 credit 1,000 requests, 7 days

Tests 1 to 5 ended level with retries, 49 to 49, but Oxylabs won the first attempt by a wide margin, 50 to 31, because Web Unlocker lost 18 runs to HTTP 503. Web Unlocker was faster on three of five pages, Oxylabs on Walmart and, by 1.4 s, on Indeed. In the browser tests both scrolled 10/10, and Cloud Browser won the Indeed escalation 10 to 6.

On cost, Oxylabs and Web Unlocker are almost even on pages without JavaScript at entry level, $1.00 against $0.98. Every page that needs rendering costs 50% more on Oxylabs, and its browser costs more on heavy pages because it is billed by traffic.

When the Unlocker Fails: Escalation to Cloud Browser

With retries, Web Unlocker’s weakest page was Indeed: 9/10, and only 3/10 on the first attempt. Test #7 opened the same search in Gologin Cloud Browser, with a new profile and US residential proxy per run. The job list loaded 10/10 at a median of 10.93 s, faster than either request API on this page. That is about 3 browser hours per 1,000 runs, $0.27 at $0.09 an hour.

Oxylabs’ side ran Agent Browser on the same URL with a US location. It got 6/10 at a median of 7.10 s: three runs stopped on a Cloudflare “Just a moment…” page and one lost the page while reading it. The documented fix is the page handler, which “completes the supported challenges it finds”, but on our self-service account all 10 runs with it ended in HTTP 400 at connection.

Oxylabs Agent Browser runs on Indeed: 6 of 10 found the job list

Cloudflare verification page that Oxylabs Agent Browser stopped on at Indeed

As extra data, we also opened the frozen Amway target in both browsers: Agent Browser 10/10 at 6.26 s, Cloud Browser 10/10 at 12.13 s. Agent Browser was faster there, at about $25 per 1,000 pages in traffic against $0.30 in Cloud Browser time.

The rule from our runs: Web Unlocker for pages you can fetch in one request, Cloud Browser when the page needs scrolling, clicks, a login, or a real browser to settle, as on tests 6 and 7. Oxylabs splits the same jobs between Web API and Agent Browser, but its browser price grows with the weight of each page.

Frequently Asked Questions

Is Oxylabs worth it in 2026?

For page retrieval with few failures, yes: Oxylabs Web API returned 50 of 50 pages on tests 1 to 5 on the first attempt and was the fastest tool on Walmart at 3.59 s. Rendered pages cost $1.50 per 1,000 and were slower than Web Unlocker, and Agent Browser got 6/10 on Indeed. Start with the $5 free credit.

Is Oxylabs legit?

Yes. Oxylabs is an established proxy and web data vendor with public documentation, published prices and a dashboard that showed every cent of our $0.60 test spend by product and target. Its error 500 was not charged, as the docs say. The welcome credit is $5, and self-service purchases are not refundable.

How much does Oxylabs cost per 1,000 pages?

On Starter ($15), a custom page costs $1.00 per 1,000 without JavaScript and $1.50 with it; on Enterprise, $0.75 and $1.22. AI parsing adds $3.00 per 1,000. Agent Browser bills $8 per GB, about $25 per 1,000 Amway pages in our test. Gologin Web Unlocker is $0.98 on its $49 plan.

Does Oxylabs charge for failed requests?

Not for errors: the HTTP 500 we got was not charged, and the dashboard counted only HTTP 200 results. A 200 is charged even without the data: 10 default answers on the quotes page and Amway came back unrendered and were billed. Web Unlocker does not bill challenged or empty pages.

What is the difference between Oxylabs Agent Browser and Gologin Cloud Browser?

Both are cloud browsers you drive from Playwright over CDP. Agent Browser bills traffic at $8 per GB and was faster in our runs, 10.22 s on scrolling. Cloud Browser bills time at $0.09 an hour, about $0.27 per 1,000 Indeed pages, and went 10/10 on Indeed where Agent Browser got 6/10.

Oxylabs Review Verdict: Which One Should You Use?

There is no single best web scraping API for every target, and on page retrieval these two tools ended level once retries were in.

What Oxylabs does better or cheaper than the Gologin stack:

  • First attempt: 50 of 50 runs without retries, against 31 of 50.
  • Walmart and static pages: 3.59 s against 12.12 s on Walmart, and 10/10 on every first-attempt round.
  • Entry price: $5 free credit and $15 a month, against $49.
  • Products on one balance: dedicated scrapers, AI parsing, screenshots and async delivery next to the generic API.

Where the Gologin stack was weaker in this test:

  • Service errors: without retries, Web Unlocker lost 18 runs to HTTP 503, 7 of them on Indeed.
  • Walmart speed: 12.12 s against 3.59 s.
  • Indeed with retries: 9/10, with 9 of 10 runs needing at least one retry.
  • Scroll speed: Cloud Browser took 13.93 s against 10.22 s in Agent Browser.

What the Gologin stack does better than Oxylabs:

  • Rendered pages: Web Unlocker returned the JavaScript page in 3.51 s at $0.98 per 1,000, against 10.34 s at $1.50 on Oxylabs.
  • Sites running DataDome: Web Unlocker went 10/10 at 20.76 s with the default request.
  • Billing: Web Unlocker does not bill empty pages; Oxylabs billed 10 unrendered results.
  • Browser on Indeed: Cloud Browser went 10/10 against 6/10, at about $0.27 per 1,000 pages instead of traffic at $8 per GB.

Choose Oxylabs if you need the most pages on the first attempt, fast static and Walmart pages, dedicated Amazon or Google scrapers, or a $15 start.

Choose Gologin if you need JavaScript pages and DataDome sites at a flat $0.75 to $0.98 per 1,000, no charge for empty pages, or a browser for Cloudflare pages and heavy sites billed by time instead of traffic.

Conclusion

Oxylabs is a strong scraping API: on 16 November 2026 it returned all 50 retrieval pages on the first attempt and matched Web Unlocker at 49 to 49 with retries. It was slower on rendered pages, billed rendering at 50% more and billed unrendered default answers, and Agent Browser stopped on the Cloudflare challenge in 3 of 10 Indeed runs. Gologin Web Unlocker needed retries for its HTTP 503s, but returned rendered pages faster at a lower flat price, and Cloud Browser went 10/10 on both browser tests.

Gologin Web Unlocker gives you 1,000 free requests for 7 days with no credit card, enough to repeat these tests on your own pages.

Also Read