Olostep Review 2026: 7 Benchmark Tests, Pricing and Real Costs

Olostep is a web scraping API built for AI work: you send a URL and get the page back as Markdown, HTML, text or JSON, with JavaScript rendered and a residential IP on every request. Around the Scrape endpoint sit Crawl, Map, Batch, Search, Answers and Parsers, plus Python and Node.js SDKs, a CLI and an MCP server. Its pitch is price: “Most cost-effective web data API on the market”, from $9 a month.

This Olostep review covers its features, credit system and pricing, then runs Olostep and Gologin on the same seven targets, with the same runs, the same retry rule and the same success check. Gologin enters as a stack: Gologin Web Unlocker for page retrieval plus Gologin Cloud Browser for jobs that need a live session.

Every number below comes from a logged run, including Gologin’s losses.

Olostep vs Gologin: Key Takeaways

• Retrieval success: close to a draw. With up to 3 retries on HTTP 502, 503 and 504, Web Unlocker returned the full page in 50 of 50 runs across tests 1 to 5, Olostep in 49 of 50. On the first attempt only, Olostep led 44 to 43.
• Speed: Web Unlocker was faster on the static page (0.98 s against 4.54 s), the JavaScript page and Indeed (5.85 s against 16.54 s). Olostep was faster on Walmart, 4.56 s against 10.19 s.
• Site running DataDome: both returned the Amway grid with retries, Olostep 9/10 at 35.92 s and Web Unlocker 10/10 at 34.12 s. Olostep needed its fullest setup; three simpler setups got 0/15.
• Cost: Olostep wins on volume. A page is 1 credit: $1.80 per 1,000 on Starter, $0.50 on Standard ($99). Web Unlocker is $0.98 on its $49 plan and $0.75 on $149. Olostep billed 18 pages without the content on tests 2, 4 and 7, and 15 scroll pages that stopped at 10 quotes.
• Infinite scroll: Olostep’s scroll actions returned the first 10 quotes in all 17 runs. Gologin Cloud Browser loaded 50 quotes 10/10 at 13.88 s.
• Escalation: Cloud Browser opened the Amway grid 10/10 at 12.77 s. Olostep’s fullest setup got 6/10 at 53.41 s, with three runs that ended in HTTP 504 after 4 attempts.

	Olostep	Gologin Web Unlocker (+ Cloud Browser for #6, #7)
Success, tests 1 to 5, with retries	49/50	50/50
Success, tests 1 to 5, first attempt	44/50	43/50
Median time, hardest target (#4 DataDome)	35.92 s	34.12 s
Cost per 1K pages, entry plan	$1.80	$0.98
Cost per 1K pages, about $100 a month	$0.50	$0.98
Sessions and interaction	actions inside one request	Cloud Browser, hourly
Charged responses	every HTTP 200	successful pages only
Free start	500 successful requests, no card	1,000 requests, 7 days, no card

What Is Olostep?

Olostep calls itself “Web Data Infrastructure for AI”: an API that turns public web pages into clean data for language models, agents and data pipelines. You authenticate with a Bearer key, POST a URL and get the page in the formats you ask for. Every request is rendered in a browser and goes out on a residential IP, so there are no render or proxy tiers to pick.

Product	What it does	When you use it
Scrape (/v1/scrapes)	One URL to Markdown, HTML, text, JSON or a screenshot	Real-time page retrieval
Batch	Up to 100,000 URLs per job, results by polling or webhook	Large overnight jobs
Crawl and Map	Follows or lists the links on a site	Whole-site collection
Search and Answers	Web search with content, or an answer with sources	Research for agents
Parsers and llm_extract	Pages to typed JSON by a parser or a JSON schema	Structured data
SDKs, CLI, MCP	Python, Node.js, CLI and an MCP server; LangChain, n8n, Zapier and more	Agent and no-code workflows

Olostep also has an Agents API, which “is currently available to select customers”, and lists “AI-powered Browser Automations” on the $399 Scale plan. Neither is a browser session you drive from Playwright, and we did not test them.

How We Tested Olostep and Gologin

Olostep’s configuration ladder ran on 11 November 2026. The head-to-head ran the same day, both tools from one machine, first without retries and then with them; tests 6 and 7 ran on 12 November. Each tool got 10 runs per target, at least 10 seconds apart, with a fresh cache-busting parameter (cb=timestamp) on every URL.

#	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	amway.com Skin Care category	at least 10 prices, no challenge

• Direct requests first: a plain request got a Cloudflare “Security Check” from Indeed (HTTP 403), a DataDome device check from Amway (HTTP 403) and a “Robot or human?” page from Walmart (HTTP 200 without the product).
• Configuration rule: Olostep started with the default request and stepped up through remove_css_selectors=none, a US IP and a 5 s wait action only when the marker failed. Every step is in our log.
• 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. We applied the same rule to both tools: 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. Olostep returns credits_consumed with every response; we logged it per request and checked the balance on GET /user/credits/info.

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, formats=("markdown", "html"), **params):
    body = {"url_to_scrape": fresh(url), "formats": list(formats), **params}
    start = time.perf_counter()
    response = requests.post("https://api.olostep.com/v1/scrapes", 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

Olostep ran on the Starter plan ($9 a month, 5,000 credits, plus 500 trial credits). All our tests used 163 credits.

Olostep Features and Full API Parameters

The Scrape endpoint is the core of Olostep. You POST url_to_scrape and a list of formats; one request can return Markdown and HTML together for 1 credit.

curl -X POST "https://api.olostep.com/v1/scrapes" -H "Authorization: Bearer YOUR_API_KEY" -H "Content-Type: application/json" -d '{"url_to_scrape": "https://example.com", "formats": ["markdown", "html"]}'

• Rendering and IPs: the pricing page says “All requests are JS rendered + utilizing residential IP addresses”, and the docs say the API “Handles dynamic content: js-rendered sites, login flows via actions, PDFs” (Olostep docs).
• Cost: “Scrape costs 1 credit by default”; parsers cost 1 to 5 credits, and “llm_extract costs 10 credits per scrape”.
• Cost signal: every response carries credits_consumed, “the source of truth for billing”, and an estimated cost_usd.
• Actions: wait, click, fill_input and scroll, run before the page is captured.
• Geo-targeting: country, with 11 countries listed plus RANDOM: US, CA, IT, IN, GB, JP, MX, AU, ID, UA and RU.
• Content cleanup: remove_css_selectors removes navigation, footers, scripts and similar parts by default; none keeps the whole page.
• Time limit: HTTP 504 when “The scrape did not finish within the ~55-second wait budget”; the docs call it “safe to retry”.
• Cache: live scrape by default; max_age lets you accept a cached copy up to 7 days old.

Parameter	Type	Default	What it does	Cost effect
url_to_scrape	string	none	Target URL	none
formats	list	none	html, markdown, text, json, raw_pdf, screenshot	1 credit per request
wait_before_scraping	int, ms	none	Delay before capture	none measured
actions	list	none	wait, click, fill_input, scroll	none measured
country	string	none	Residential IP country, 11 plus RANDOM	none measured
remove_css_selectors	string	default	default, none or a list of selectors	none
parser	object	none	Parser id for JSON output	1 to 5 credits
llm_extract	object	none	JSON schema for extraction	10 credits
links_on_page	object	none	Links, filtered or ranked by a query	none stated
screen_size	object	default	Mobile, desktop or a custom size	none stated
max_age	int, s	0	Accept a cached copy	none stated

• Every setup we used cost 1 credit: default, remove_css_selectors=none, a US IP and a 5 s wait action all showed credits_consumed 1. Errors (HTTP 502 and 504) showed 0.
• No-answer cases: twice a request returned nothing within our 180 s client timeout; neither was charged.

Olostep 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, markdown_of, result_of, scrape
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 = result_of(response).get("html_content") or ""
    found = static_page(markdown) or static_page(html)
    print(f"Config        : {params or 'default'}")
    print(f"HTTP status   : {response.status_code}")
    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"Credits       : {credits_of(response)}")
    return response, elapsed, found, html or markdown

with_retries(run)

Every run returned the title and price, in Markdown and HTML.

10/10 successful, median 4.54 s, 1 credit each, slowest 5.96 s, no retries needed. The first attempt round gave the same 10/10 at 4.46 s.

Test #2: JavaScript-rendered page

We sent quotes.toscrape.com/js/ with the default request.

from common import credits_of, markdown_of, result_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 = result_of(response).get("html_content") or ""
    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"Credits       : {credits_of(response)}")
    return response, elapsed, found, html or markdown

with_retries(run)

The rendered quotes came back in every run of this round.

10/10 successful, median 4.61 s, 1 credit each, slowest 5.47 s. The first attempt round got 8/10 at 4.46 s, and the ladder 4/5: in 3 of 25 default runs Olostep returned HTTP 200 with the page as served, before its JavaScript ran, and no quotes. Each of those cost 1 credit, and a retry rule on 5xx does not catch them.

Test #3: Site behind Cloudflare

We sent an indeed.com job search for python developer in New York.

from common import credits_of, markdown_of, result_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 = result_of(response).get("html_content") or ""
    found = job_search(markdown) or job_search(html)
    print(f"HTTP status   : {response.status_code}")
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    print(f"Credits       : {credits_of(response)}")
    return response, elapsed, found, html or markdown

with_retries(run)

The job list came back in every run, 16 job cards in the saved page.

10/10 successful, median 16.54 s, 1 credit each, slowest 20.10 s. Without retries it was also 10/10, at 16.63 s, and the ladder 5/5. 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, which answers a plain request with a DataDome device check.

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

TARGET = "https://www.amway.com/en_US/Shop/Beauty/Skin-Care/c/105"
WAIT_5S = [{"type": "wait", "milliseconds": 5000}]

def run(**params):
    response, elapsed = scrape(TARGET, **params)
    markdown = markdown_of(response)
    html = result_of(response).get("html_content") or ""
    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"Credits       : {credits_of(response)}")
    return response, elapsed, found, html or markdown

with_retries(lambda: run(remove_css_selectors="none", country="US", actions=WAIT_5S))

Nine runs returned the product grid with prices.

9/10 successful, median 35.92 s, 1 credit each, slowest 76.74 s. Three runs needed retries after HTTP 504; one ran out of attempts after four 504 responses and 236 s. On the first attempt only, it was 6/10 at 31.99 s.

The ladder before it: the default request, remove_css_selectors=none and the same with a US IP got 0/5 each; the wait action made it 2/5. Failed runs that came back as HTTP 200 were billed 1 credit each: 14 credits on test #4 bought no product grid. In 14 of the 15 billed Amway misses across tests 4 and 7, the page was DataDome’s “Access is temporarily restricted” instead of products.

Test #5: Marketplace product page

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

from common import credits_of, markdown_of, result_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 = result_of(response).get("html_content") or ""
    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"Credits       : {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 4.56 s, 1 credit each, slowest 14.24 s; 10/10 at 5.22 s on the first attempt too, and 5/5 in the ladder. This was Olostep’s best result against Web Unlocker.

Test #6: Infinite scroll

Olostep has no browser product we could drive, so we used scroll and wait actions inside one request.

from common import credits_of, result_of, scrape
from markers import quote_count

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

def scrolls(times, wait_ms):
    step = [{"type": "scroll", "direction": "down", "amount": 5000}, {"type": "wait", "milliseconds": wait_ms}]
    return step * times

def run(times=10, wait_ms=1000, **params):
    response, elapsed = scrape(TARGET, actions=scrolls(times, wait_ms), **params)
    count = quote_count(result_of(response).get("html_content") or "")
    print(f"HTTP status   : {response.status_code}")
    print(f"Quotes loaded : {count}")
    print(f"Marker found  : {count >= 50}")
    print(f"Elapsed       : {elapsed:.2f}s")
    print(f"Credits       : {credits_of(response)}")
    return response, elapsed, count >= 50

run(times=20, wait_ms=1500, remove_css_selectors="none")

Every run returned the first 10 quotes only.

0/17 across three setups: 10 scrolls with a 1 s wait (median 24.15 s), the same with remove_css_selectors=none (25.00 s) and 20 scrolls with a 1.5 s wait (44.52 s), 1 credit each. The actions made the request longer but loaded no new quotes; one run ended in HTTP 504 and one gave no answer within 180 s, both free.

Test	Target	Configuration	Success	Median s	Slowest s	Units per success
#1 Static	books.toscrape.com	default	10/10	4.54	5.96	1 credit
#2 JavaScript	quotes.toscrape.com/js/	default	10/10	4.61	5.47	1 credit
#3 Cloudflare	indeed.com	default	10/10	16.54	20.10	1 credit
#4 DataDome	amway.com	css none, US, 5 s wait	9/10	35.92	76.74	1 credit
#5 Marketplace	walmart.com	default	10/10	4.56	14.24	1 credit
#6 Scroll	quotes.toscrape.com/scroll	scroll actions	0/17	none	none	1 credit per page with 10 quotes
#7 Escalation	amway.com	css none, US, 5 s wait	6/10	53.41	136.41	1 credit

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	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 0.98 s, 1 request each, slowest 15.70 s; one run needed a retry after HTTP 503. On the first attempt only, it was 8/10 at 2.42 s: two 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.00 s, 1 request each, slowest 14.52 s; one run needed a retry. On the first attempt only, it was 9/10 at 2.34 s with one HTTP 503.

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)

Every run returned the job list.

10/10 successful, median 5.85 s, 1 request each, slowest 9.48 s; one run needed a retry. Without retries it was also 10/10, at 6.32 s, almost three times faster than Olostep on this page.

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 34.12 s, 1 request each, slowest 52.08 s, no retries needed. On the first attempt only, it was 8/10 at 23.30 s, with one HTTP 503 and one 504 gateway timeout, both 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 10.19 s, 1 request each, slowest 19.24 s, more than twice Olostep’s 4.56 s. On the first attempt only, it was 8/10 at 20.07 s: one HTTP 503 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.88 s including the connection, slowest 17.16 s, about 0.004 browser hours each.

Test #7: Escalation to Cloud Browser on Amway

Amway was the slowest Web Unlocker target and one of its three 8/10 targets on the first attempt, so test #7 opened it in Cloud Browser and waited up to 30 s for 10 prices, 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 category_page

TARGET = "https://www.amway.com/en_US/Shop/Beauty/Skin-Care/c/105"
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 category_page(html):
                    break
                page.wait_for_timeout(1000)
                html = page.content()
            browser.close()
        elapsed = time.perf_counter() - start
    finally:
        stop_session(profile)
    found = category_page(html)
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    return html, elapsed, found

Every run loaded the product grid.

10/10 successful, median 12.77 s, slowest 35.50 s, about 0.004 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	0.98	15.70	1 request
#2 JavaScript	quotes.toscrape.com/js/	Web Unlocker, default	10/10	3.00	14.52	1 request
#3 Cloudflare	indeed.com	Web Unlocker, default	10/10	5.85	9.48	1 request
#4 DataDome	amway.com	Web Unlocker, default	10/10	34.12	52.08	1 request
#5 Marketplace	walmart.com	Web Unlocker, default	10/10	10.19	19.24	1 request
#6 Scroll	quotes.toscrape.com/scroll	Cloud Browser, US residential	10/10	13.88	17.16	0.004 h
#7 Escalation	amway.com	Cloud Browser, new profile per run	10/10	12.77	35.50	0.004 h

Olostep Pricing and Credit System Explained

Olostep pricing is simple: a scrape is 1 credit, with JavaScript rendering and a residential IP included, and plans differ by credits and concurrency. Parsers cost 1 to 5 credits and llm_extract 10. Every setup we used, including actions and a country, cost 1 credit.

The site says failed requests are not charged, and our HTTP 502 and 504 responses showed 0 credits. A 200 still counts, whatever it holds: we paid for 3 JavaScript pages returned before rendering, 14 Amway pages without products on test #4, 1 on test #7, and 15 scroll pages that stopped at 10 quotes. In all, our tests used 163 credits.

Plan	Monthly price	Units included	Price per unit	Concurrency	Overage
Trial	$0	500 successful requests	free	low rate limits	none
Starter	$9	5,000 credits	$1.80 per 1K	20	top-ups
Standard	$99	200,000 credits	$0.50 per 1K	200	top-ups
Scale	$399	1,000,000 credits	$0.40 per 1K	500	top-ups
Enterprise	custom	custom	custom	custom	custom

Top-ups are credit packs valid for 6 months, from $5 for 2,000 credits ($2.50 per 1K) to $1,000 for 2,000,000 ($0.50 per 1K). Plans are pro-rated when you switch.

Scenario (test)	Units per request	Cheapest plan $ (Starter)	Comparable plan $ (Standard, $99)
Static (#1)	1	$1.80	$0.50
JavaScript (#2)	1	$1.80	$0.50
Cloudflare (#3)	1	$1.80	$0.50
DataDome (#4)	1	$1.80	$0.50
Marketplace (#5)	1	$1.80	$0.50
Scroll (#6), 10 quotes only	1	$1.80	$0.50
DataDome, escalation setup (#7)	1	$1.80	$0.50
Any page with llm_extract	10	$18.00	$5.00

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, so our 13.88 s scroll comes to about $0.35 per 1,000 pages and the 12.77 s Amway run to about $0.32, plus proxy traffic above the plan allowance at $1/GB.

Olostep Pros

• Low price at volume: $0.50 per 1,000 pages on Standard, with rendering and residential IPs included.
• Strong first attempt: 44 of 50 runs on tests 1 to 5 without retries, one more than Web Unlocker.
• Fast on Walmart: 10/10 at 4.56 s, against 10.19 s for Web Unlocker.
• One flat credit: every setup we used, including a country and actions, cost 1 credit, and the response shows it.
• Built for AI pipelines: Markdown and HTML in one call, batches of up to 100,000 URLs, an MCP server, SDKs and many agent integrations.

Olostep Cons

• Empty pages are charged: 33 credits went to pages without the content, from unrendered JavaScript pages to DataDome pages.
• Slow on simple pages and Indeed: 4.54 s on a static page and 16.54 s on Indeed, against 0.98 s and 5.85 s.
• Hard targets need tuning: Amway took remove_css_selectors=none, a US IP and a wait action; simpler setups got 0/15.
• Scrolling did not load content: 0/17 on the infinite scroll page.
• Long failures: an HTTP 504 comes after about 56 s, so a run with three retries can take 4 minutes and still fail.

Olostep Limitations

• No browser session product: actions run inside one request; the Agents API is for select customers and browser automations start at the $399 plan.
• 11 countries: country targeting covers 11 countries plus RANDOM; no state or city.
• About 55 seconds per request: longer pages end in HTTP 504.
• Batch limit for new accounts: batches are capped at 100 items until Olostep lifts the limit.
• Credits on 200 responses: the API cannot tell you that a page was a challenge or an unrendered shell; your parser has to.

Olostep vs Gologin: Head-to-Head Results

The two products cover the same first step: send a URL, get a rendered page from a residential IP. Olostep sells it at 1 credit with AI-friendly formats and bulk jobs around it. Gologin sells it at one flat price per successful page and adds Cloud Browser for jobs that need a real session.

Aspect	Olostep	Gologin stack
What you send	URL, formats, optional actions and country	URL (Web Unlocker) or a Playwright session (Cloud Browser)
Rendering	always on	included in Web Unlocker
Price unit	credit, 1 per page	page (Web Unlocker), hour (Cloud Browser)
Interaction	actions inside one call	full browser session
Output	Markdown, HTML, text, JSON, screenshot	HTML, Markdown, text and JSON

Olostep alternative: when Gologin is a better choice

Scenario	Better fit	From our tests or the docs
Infinite scroll and multi-step pages	Cloud Browser	10/10 against 0/17 on test #6
Sites running DataDome	Web Unlocker or Cloud Browser	10/10 without tuning; Cloud Browser 10/10 at 12.77 s on test #7
Speed on simple and Cloudflare pages	Web Unlocker	0.98 s and 5.85 s against 4.54 s and 16.54 s
Paying only for usable pages	Web Unlocker	challenged and empty pages are free
City or state targeting	Web Unlocker	documented on the product page; 11 countries on Olostep

Test	Olostep success	Olostep median s	Gologin success	Gologin median s
#1 Static	10/10	4.54	10/10	0.98
#2 JavaScript	10/10	4.61	10/10	3.00
#3 Cloudflare	10/10	16.54	10/10	5.85
#4 DataDome	9/10	35.92	10/10	34.12
#5 Marketplace	10/10	4.56	10/10	10.19
#6 Scroll	0/17	none	10/10	13.88
#7 Escalation	6/10	53.41	10/10	12.77

Test, first attempt only (11 Nov)	Olostep	Web Unlocker
#1 Static	10/10, 4.46 s	8/10, 2.42 s
#2 JavaScript	8/10, 4.46 s	9/10, 2.34 s
#3 Cloudflare	10/10, 16.63 s	10/10, 6.32 s
#4 DataDome	6/10, 31.99 s	8/10, 23.30 s
#5 Marketplace	10/10, 5.22 s	8/10, 20.07 s

Scenario	Olostep, cheapest plan	Olostep, comparable plan	Gologin, entry plan	Gologin, comparable plan
Static (#1)	$1.80	$0.50	$0.98	$0.75
JavaScript (#2)	$1.80	$0.50	$0.98	$0.75
Cloudflare (#3)	$1.80	$0.50	$0.98	$0.75
DataDome (#4)	$1.80	$0.50	$0.98	$0.75
Marketplace (#5)	$1.80	$0.50	$0.98	$0.75
Scroll (#6)	$1.80, 10 quotes	$0.50, 10 quotes	$0.35	$0.31
DataDome in a browser (#7)	$1.80	$0.50	$0.32	$0.28

Feature	Olostep	Gologin stack
Pricing model	1 credit per page; parsers 1 to 5, llm_extract 10	per page, flat; browser per hour
JS rendering	always on	included
Geo-targeting level	11 countries plus RANDOM	country, state, city (product page)
Proxy tiers	residential on every request	managed; residential on Cloud Browser
Sticky session	not documented	Web Unlocker sticky sessions; Cloud Browser session
Output formats	Markdown, HTML, text, JSON, raw PDF, screenshot	HTML, Markdown, text, JSON
Structured extraction	parsers and llm_extract	not documented
Browser-level control	no (Agents API for select customers)	Gologin Cloud Browser
Batch and webhooks	up to 100,000 URLs, webhooks	batch and async with webhooks (product page)
Failure signalling	HTTP 502 and 504, credits_consumed in the body	HTTP 503 and 504, failed pages free
Charged responses	every HTTP 200	successful pages only
Free start	500 successful requests	1,000 requests, 7 days

Tests 1 to 5 ended almost level: 49 to 50 with retries and 44 to 43 on the first attempt. Web Unlocker was faster on three of the five pages, Olostep on Walmart, and the Amway times were close. Gologin won tests 6 and 7 outright, where a real browser did what one request with actions could not.

On cost, Olostep Starter at $1.80 per 1,000 is dearer than Web Unlocker Growth at $0.98, but Olostep Standard at $0.50 is cheaper than any Web Unlocker plan we priced. Count the billed misses before you compare: on Amway, Olostep paid 1 credit for each DataDome page as well as for each product grid.

When the Unlocker Fails: Escalation to Cloud Browser

With retries, Web Unlocker missed no page on tests 1 to 5, so test #7 took the target where it was slowest and missed 2 runs in 10 on the first attempt: Amway. Through Gologin Cloud Browser, with a new profile and US residential proxy per run, the product grid loaded 10/10 at a median of 12.77 s, faster than either retrieval API on this page. That is about 3.5 browser hours per 1,000 runs, $0.32 on Professional.

Olostep has no browser product we could drive, so its side ran its fullest working setup from test #4: remove_css_selectors=none, a US IP and a 5 s wait, with the same retries. It got 6/10 at a median of 53.41 s. Three runs ended after four HTTP 504 responses, about 235 s each, and one returned the page without products.

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 simply a real browser to settle, as on tests 6 and 7.

Frequently Asked Questions

Is Olostep worth it in 2026?

For high-volume page retrieval for AI pipelines, yes: it returned 49 of 50 pages on tests 1 to 5 with retries, at $0.50 per 1,000 on Standard, and it was the fastest tool on Walmart. It was slower than Web Unlocker on simple pages and Indeed, needed tuning on Amway and could not load an infinite scroll. Try it on the 500 free requests first.

How much does Olostep cost per 1,000 pages?

A scrape is 1 credit: $1.80 per 1,000 on Starter ($9 for 5,000), $0.50 on Standard ($99 for 200,000) and $0.40 on Scale ($399 for 1,000,000). llm_extract costs 10 credits, $18.00 per 1,000 on Starter. Gologin Web Unlocker is $0.98 per 1,000 on its $49 plan and $0.75 on $149.

Does Olostep charge for failed requests?

Not for errors: our HTTP 502 and 504 responses showed 0 credits. A 200 response is charged even when the page is wrong: we paid 1 credit each for 3 JavaScript pages returned before rendering, 15 Amway pages without products and 15 scroll pages with 10 quotes. Web Unlocker does not bill challenged or empty pages.

Does Olostep render JavaScript and use residential proxies?

Yes, on every plan: “All requests are JS rendered + utilizing residential IP addresses”, at 1 credit. In our runs 3 of 25 default requests to the JavaScript page still came back unrendered. The country parameter covers 11 countries plus RANDOM.

Can Olostep handle infinite scroll or logged-in pages?

It offers wait, click, fill_input and scroll actions inside one request, and the docs mention login flows. On our infinite scroll page the scroll actions returned 10 quotes in all 17 runs. For pages that need a live session, Gologin Cloud Browser loaded 50 quotes 10/10 with plain Playwright.

Olostep 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 came out nearly even.

What Olostep does better or cheaper than the Gologin stack:

• Price at volume: $0.50 per 1,000 on Standard, against $0.75 to $0.98 on Web Unlocker.
• First attempt: 44 of 50 without retries, against 43.
• Walmart: 4.56 s against 10.19 s, 10/10 on both rounds.
• AI tooling: Markdown and HTML in one call, batches of 100,000 URLs, parsers, llm_extract and an MCP server.

Where the Gologin stack was weaker in this test:

• Service errors: without retries, Web Unlocker lost runs to HTTP 503 on four of five targets.
• Walmart speed: more than twice as slow as Olostep.
• Entry price: $49 to start, against $9.

What the Gologin stack does better than Olostep:

• Speed on simple and Cloudflare pages: 0.98 s and 5.85 s against 4.54 s and 16.54 s.
• Billing: challenged and empty pages are free; Olostep billed 33 credits for them.
• A real browser: Cloud Browser went 10/10 on scrolling and 10/10 on Amway, where Olostep got 0/17 and 6/10.

Choose Olostep if you need large volumes of public pages as Markdown or JSON for an AI pipeline at the lowest price per page, with batch jobs and agent integrations.

Choose Gologin if you need faster pages on simple and Cloudflare sites, no charge for challenged or empty pages, city-level targeting, or a real browser session for scrolling and multi-step pages.

Conclusion

Olostep is a strong, low-priced scraping API: on 11 November 2026 it matched Web Unlocker on retrieval, 49 to 50 with retries and 44 to 43 without, and beat it on Walmart. It was slower on simple pages and Indeed, billed pages without the content, and its in-request actions could not do what a browser does: 0/17 on infinite scroll and 6/10 on the Amway escalation. Gologin Web Unlocker returned every page with retries at one 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.