Oxylabs Review 2026: 7 Benchmark Tests, Pricing and Costs
Try Gologin for freeOxylabs 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.

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.

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.

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.

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.


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.

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.

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.

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.

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.

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.

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.

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.

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.

| 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 |

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

| 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.

| 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 |

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.

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.


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.


