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

Getting a page back is easy until the page sits behind Cloudflare or DataDome, and then the question is what each page costs. This Crawlbase review runs the Crawlbase Crawling API, a web scraping API, and Gologin on the same seven targets, with the same runs and the same success check.

Crawlbase sells one retrieval API with two tokens and a credit multiplier per site. Gologin enters as a stack: Gologin Web Unlocker for page retrieval plus Gologin Cloud Browser for anything that needs a live session.

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

Crawlbase vs Gologin: Key Takeaways

• Retrieval success: Crawlbase returned the full page in 41 of 50 runs across tests 1 to 5, Web Unlocker in 46 of 50. Most of the gap is one target, the DataDome category page.
• DataDome target: Crawlbase got 3/10 on the Amway category page at best, with JavaScript rendering and US geo-targeting at 2 credits. Web Unlocker got 9/10 at a median of 20.80 s with the default request.
• Walmart product page: Crawlbase won here, 10/10 at a median of 11.28 s against 8/10 for Web Unlocker, at 4.5 credits per page because of the site multiplier.
• Infinite scroll: Crawlbase reached 50 quotes with scroll_interval=20 in 10/10 runs at 18.12 s. Gologin Cloud Browser did it 10/10 at 7.37 s through Playwright.
• Cost on hard pages: Walmart rendered by Crawlbase cost 9 credits, $4.46 per 1,000 on Starter. Web Unlocker is $0.98 per 1,000 for any page.
• Neither is the universal winner: Crawlbase is faster and cheaper on static pages and won Walmart. The Gologin stack won the DataDome page, the JavaScript page (0.98 s against 8.24 s) and the scroll test.

	Crawlbase	Gologin Web Unlocker (+ Cloud Browser for #6, #7)
Success, tests 1 to 5	41/50	46/50
Median time, hardest target (#4 DataDome)	23.19 s	20.80 s
Cost per 1K, hardest target	$0.99	$0.98
JS rendering	JavaScript token, 2x credits	included
Sessions and interaction	cookies_session (300 s), scroll up to 60 s	Cloud Browser, hourly
Failed requests charged	no (docs)	no (docs)
Free trial	1,000 to 5,000 credits, no card	1,000 requests, 7 days, no card

What Is Crawlbase?

Crawlbase (Crawlbase LLC, operating since 2017) is a web data company whose core product, the Crawling API, takes a URL and returns the page as HTML, JSON or Markdown. You pick a Normal token for pages that do not need a browser and a JavaScript token for pages that do.

It is built for teams that want pages without running proxies or browsers, such as price monitoring.

The buyer is usually a developer or data team paying by credit, where harder sites cost more credits.

Product	What it does	When you use it
Crawling API, Normal token	Fetches HTML or JSON without a browser	Static pages
Crawling API, JavaScript token	Renders the page in a browser, supports scroll and click	Client-rendered pages
Enterprise Crawler	Asynchronous crawling of large URL lists with callbacks	High-volume pipelines
Smart AI Proxy	Rotating residential and datacenter IPs behind one endpoint	Your own scraper code
Web MCP Server	Live web data for AI agents over Model Context Protocol	AI agents and LLM pipelines

We ran the same tests on ScrapingBee in our ScrapingBee review.

How We Tested Crawlbase and Gologin

Tests ran on 29 and 30 October 2026 from one machine. 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	h1 and .price_color
2	JavaScript-rendered	quotes.toscrape.com/js/	at least 10 .quote elements
3	Site behind Cloudflare	indeed.com job search, New York	h1 and a job card, no challenge
4	Site running DataDome	amway.com Skin Care category	at least 10 prices, no DataDome markup
5	Marketplace product	walmart.com item 5689919121	product title and price
6	Infinite scroll	quotes.toscrape.com/scroll	at least 50 quotes
7	Escalation	walmart.com item 5689919121	product title and price

• Configuration rule: Crawlbase started on the cheapest setup (Normal token) and stepped up through the JavaScript token, ajax_wait and country=US only when the marker failed. Every step is in our log.
• Success and cost: a run counts only when one shared parser finds the marker in the body, never on HTTP 200 alone. Cost per 1,000 = price per credit x credits per request x 1,000; both vendors say failed requests are free, so there is no division by the success rate.

python -m venv .venv && source .venv/bin/activate && pip install requests beautifulsoup4 playwright python-dotenv

Crawlbase ran on its free tier; our account received 500 credits, which Crawlbase support confirmed as a restricted onboarding.

Crawlbase Features and Full API Parameters

• Two tokens: Normal fetches without a browser; JavaScript renders at double cost (Crawlbase docs).
• Site multipliers: each domain has a tier from Standard (1x) to Extreme II (20x).
• Status headers: cb_status and original_status separate a Crawlbase failure from a site refusal.
• Output formats: HTML, JSON and Markdown, plus screenshots and PDF on the JavaScript token.
• Built-in scrapers: structured data for sites such as Amazon.
• Geo-targeting: country by ISO code.
• Sticky sessions: cookies_session keeps cookies for 300 s after the last call.
• Interaction: scroll, page_wait, ajax_wait and css_click_selector on the JavaScript token.
• Async and storage: callbacks and Crawlbase Cloud Storage.
• Success-based billing: only cb_status 200 or 207 is charged.

Every parameter below is documented in the Crawlbase Crawling API parameters reference.

Parameter	Type	Default	What it does	Cost effect
token	string	none	Normal or JavaScript token	JavaScript token 2x
url	string	none	Target URL, encoded	none
country	ISO code	automatic	Routes through one country	none
device	desktop, tablet, mobile	desktop	Device user agent and viewport	none
user_agent	string	per target	Overrides the user agent	none
tor_network	boolean	false	Routes through Tor for .onion sites	none
request_headers	string	none	Headers forwarded to the target	none
cookies	string	none	Cookies sent to the target	none
cookies_session	string	none	Sticky cookie session, 300 s	none
get_headers	boolean	false	Returns the target’s headers	none
get_cookies	boolean	false	Returns the target’s Set-Cookie	none
javascript	boolean	false	Switches to the JavaScript key	2x
page_wait	integer, ms	0	Waits before capture	none stated
ajax_wait	boolean	false	Waits for network idle	none stated
css_click_selector	string	none	Clicks before capture	none stated
scroll	boolean	false	Scrolls to the bottom	billed by time
scroll_interval	integer, s	10	Scroll time, max 60	1 per 5 s after 8 s
screenshot	boolean	false	Returns a JPEG URL	JavaScript token
mode, width, height	string, px	none	Viewport screenshot size	none
pdf	boolean	false	Returns a PDF	JavaScript token
async	boolean	false	Returns a request id	none
callback	URL	none	Webhook for async results	none
store	boolean	false	Saves to Cloud Storage	none stated
format	html, json, md	html	Response format	none
md_readability	boolean	false	Main content only in Markdown	none
pretty	boolean	false	Indented JSON	none
scraper	string	none	Built-in structured scraper	none stated
autoparse	boolean	false	Picks a scraper automatically	none stated
custom_success_codes	integers	none	Extra statuses treated as success	charged
post_content_type	string	form	Body type for POST	none

• country=US: gave the best test #4 result, 3/10, against 0/10 on the Normal token.
• scroll_interval: the default 10 s returned too few quotes on test #6; 20 s passed.

Crawlbase Review: Hands-On Testing Results

Test #1: Static HTML page

We sent the books.toscrape.com product page with the Normal token and no other parameters.

from common import crawlbase, crawlbase_cost
from markers import static_page

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

def run(js=False, **params):
    response, elapsed = crawlbase(TARGET, js=js, **params)
    found = static_page(response.text)
    print(f"HTTP status   : {response.status_code} (cb_status {response.headers.get('cb_status')})")
    print(f"Target status : {response.headers.get('original_status')}")
    print(f"Complexity    : {response.headers.get('x-domain-complexity')}")
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    print(f"Credits       : {crawlbase_cost(response, js)}")
    return response, elapsed, found

run()

Every run returned the page.

10/10 successful, median 2.13 s, 1 credit each. The slowest run took 15.33 s, seven times the median, so the test went to 10 runs.

Test #2: JavaScript-rendered page

We sent quotes.toscrape.com/js/ with the Normal token, then the JavaScript token.

from common import crawlbase, crawlbase_cost
from markers import js_quotes

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

def run(js=False, **params):
    response, elapsed = crawlbase(TARGET, js=js, **params)
    found = js_quotes(response.text)
    print(f"HTTP status   : {response.status_code} (cb_status {response.headers.get('cb_status')})")
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    print(f"Credits       : {crawlbase_cost(response, js)}")
    return response, elapsed, found

run(js=True)

The JavaScript token returned the quotes every time.

10/10 successful, median 8.24 s, 2 credits each. The Normal token got 0/5: Crawlbase answered cb_status 200 with the unrendered page and charged 1 credit for each of those five empty results.

Test #3: Site behind Cloudflare

We sent an indeed.com job search, which answers a plain request with a Cloudflare challenge.

from common import crawlbase, crawlbase_cost
from markers import job_search

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

def run(js=False, **params):
    response, elapsed = crawlbase(TARGET, js=js, **params)
    found = job_search(response.text)
    print(f"HTTP status   : {response.status_code} (cb_status {response.headers.get('cb_status')})")
    print(f"Target status : {response.headers.get('original_status')}")
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    print(f"Credits       : {crawlbase_cost(response, js)}")
    return response, elapsed, found

run(js=True)

Eight of ten runs returned the job list.

8/10 successful, median 19.81 s, 2 credits each. The Normal token got 0/5, mostly cb_status 705 (the target returned 403), not charged.

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 crawlbase, crawlbase_cost
from markers import category_page

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

def run(js=False, **params):
    response, elapsed = crawlbase(TARGET, js=js, **params)
    found = category_page(response.text)
    print(f"HTTP status   : {response.status_code} (cb_status {response.headers.get('cb_status')})")
    print(f"Target status : {response.headers.get('original_status')}")
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    print(f"Credits       : {crawlbase_cost(response, js)}")
    return response, elapsed, found

run(js=True, country="US")

Most runs ended in HTTP 520.

3/10 successful, median 23.19 s, 2 credits each, after the Normal token (0/10), the JavaScript token (2/5) and ajax_wait (1/5).

Three Normal-token runs came back as cb_status 200 with a loading spinner instead of products and were charged 1 credit each.

Test #5: Marketplace product page

We sent the Walmart product page for item 5689919121 with the Normal token.

from common import crawlbase, crawlbase_cost
from markers import product_page

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

def run(js=False, **params):
    response, elapsed = crawlbase(TARGET, js=js, **params)
    found = product_page(response.text)
    print(f"HTTP status   : {response.status_code} (cb_status {response.headers.get('cb_status')})")
    print(f"Complexity    : {response.headers.get('x-domain-complexity')}")
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    print(f"Credits       : {crawlbase_cost(response, js)}")
    return response, elapsed, found

run()

Every run returned the product title and price.

10/10 successful, median 11.28 s, 4.5 credits each, because Crawlbase rates walmart.com as complex_ii.

Test #6: Infinite scroll

Crawlbase has no browser product, so we used the scroll options of the JavaScript token.

from bs4 import BeautifulSoup
from common import crawlbase, crawlbase_cost

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

def run(scroll_interval=10):
    response, elapsed = crawlbase(TARGET, js=True, scroll="true", scroll_interval=scroll_interval)
    quotes = len(BeautifulSoup(response.text, "html.parser").select("div.quote"))
    print(f"HTTP status   : {response.status_code} (cb_status {response.headers.get('cb_status')})")
    print(f"Quotes loaded : {quotes}")
    print(f"Marker found  : {quotes >= 50}")
    print(f"Elapsed       : {elapsed:.2f}s")
    print(f"Credits       : {crawlbase_cost(response, True)} + scroll time")
    return response, elapsed, quotes >= 50

run(scroll_interval=20)

With 20 seconds of scrolling every run returned 60 quotes.

10/10 successful, median 18.12 s, 4.2 credits a run by the request log, not the 2 the headers show, because scroll time is billed on top. The default scroll_interval of 10 s got 0/5 and still cost 44 credits.

Test	Target	Configuration	Success	Median s	Slowest s	Units per success
#1 Static	books.toscrape.com	Normal token	10/10	2.13	15.33	1 credit
#2 JavaScript	quotes.toscrape.com/js/	JavaScript token	10/10	8.24	128.71	2 credits
#3 Cloudflare	indeed.com	JavaScript token	8/10	19.81	134.33	2 credits
#4 DataDome	amway.com	JavaScript token, country=US	3/10	23.19	27.22	2 credits
#5 Marketplace	walmart.com	Normal token	10/10	11.28	47.77	4.5 credits
#6 Scroll	quotes.toscrape.com/scroll	JavaScript token, scroll_interval=20	10/10	18.12	68.43	4.2 credits
#7 Escalation	walmart.com	JavaScript token	10/10	18.81	26.88	9 credits

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

What is the Gologin stack

Gologin Web Unlocker is a page retrieval API: one GET request returns the rendered HTML at one flat price per page, JavaScript included. It is stateless. 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
Failed requests	free	billed by time
Interaction	none	clicks, scroll, login
Connection	HTTP GET	Playwright, Puppeteer
IPs	managed	residential, per profile
Free start	1,000 requests	3 runs of 15 min

Test #1: Static HTML page

We sent the same books.toscrape.com URL with the default request.

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():
    response, elapsed = unlocker(TARGET)
    found = static_page(response.text)
    print(f"HTTP status   : {response.status_code}")
    print(f"Body          : {len(response.content):,} bytes")
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    return response, elapsed, found

run()

Every run returned the title and price.

10/10 successful, median 3.12 s, 1 request each, about one second slower than Crawlbase.

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():
    response, elapsed = unlocker(TARGET)
    found = js_quotes(response.text)
    print(f"HTTP status   : {response.status_code}")
    print(f"Body          : {len(response.content):,} bytes")
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    return response, elapsed, found

run()

The rendered quotes were in the body every time.

10/10 successful, median 0.98 s, 1 request each, with the slowest run at 7.86 s.

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():
    response, elapsed = unlocker(TARGET)
    found = job_search(response.text)
    print(f"HTTP status   : {response.status_code}")
    print(f"Body          : {len(response.content):,} bytes")
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    return response, elapsed, found

run()

Nine runs returned the job list.

9/10 successful, median 11.47 s, 1 request each. One run ended in HTTP 504 and was not charged. 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 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():
    response, elapsed = unlocker(TARGET)
    found = category_page(response.text)
    print(f"HTTP status   : {response.status_code}")
    print(f"Body          : {len(response.content):,} bytes")
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    return response, elapsed, found

run()

Nine runs returned the product grid with prices.

9/10 successful, median 20.80 s, 1 request each. The slowest run took 84.83 s, and one run returned HTTP 200 with the page skeleton and no products.

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():
    response, elapsed = unlocker(TARGET)
    found = product_page(response.text)
    print(f"HTTP status   : {response.status_code}")
    print(f"Body          : {len(response.content):,} bytes")
    print(f"Marker found  : {found}")
    print(f"Elapsed       : {elapsed:.2f}s")
    return response, elapsed, found

run()

Eight runs returned the title and price.

8/10 successful, median 10.61 s, 1 request each. Two runs ended in HTTP 503, not charged, which makes Walmart Web Unlocker’s weakest target and the one for test #7.

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.

10/10 successful, median 7.37 s, about 0.002 browser hours each. The same profile without a proxy also got 10/10 at 7.97 s.

Test #7: Escalation to Cloud Browser on Walmart

We opened the Walmart URL in Cloud Browser and waited for the price, with a new profile and US residential proxy per run.

from playwright.sync_api import sync_playwright
from common import fresh, key, new_profile, stop_session
from markers import product_page

TARGET = "https://www.walmart.com/ip/5689919121"
ENDPOINT = "wss://cloudbrowser.gologin.com/connect?token={}&profile={}"

def run():
    profile = new_profile("walmart-run")
    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")
            page.wait_for_selector('[itemprop="price"]', timeout=30000)
            html = page.content()
            browser.close()
    finally:
        stop_session(profile)
    print(f"Marker found  : {product_page(html)}")
    return html

run()

Each run returned the full product page.

10/10 successful, median 14.48 s, about 0.004 browser hours each. Our first setup reused one profile and got 0/10; a new profile per run fixed it.

Test	Target	Configuration	Success	Median s	Slowest s	Units per success
#1 Static	books.toscrape.com	Web Unlocker, default	10/10	3.12	4.75	1 request
#2 JavaScript	quotes.toscrape.com/js/	Web Unlocker, default	10/10	0.98	7.86	1 request
#3 Cloudflare	indeed.com	Web Unlocker, default	9/10	11.47	22.55	1 request
#4 DataDome	amway.com	Web Unlocker, default	9/10	20.80	84.83	1 request
#5 Marketplace	walmart.com	Web Unlocker, default	8/10	10.61	45.44	1 request
#6 Scroll	quotes.toscrape.com/scroll	Cloud Browser, US residential	10/10	7.37	10.21	0.002 h
#7 Escalation	walmart.com	Cloud Browser, new profile per run	10/10	14.48	15.45	0.004 h

Crawlbase Pricing and Credit System Explained

Crawlbase pricing is credit-based. A standard request is one credit, the JavaScript token doubles it, and Crawlbase sets a multiplier from 1x to 20x per domain. We paid 1 credit for books.toscrape.com, 2 for rendered pages including Amway, 4.5 for Walmart and 9 rendered.

Failed requests are free by the docs, and our HTTP 520 runs were not charged. Empty results with cb_status 200 were charged: unrendered JavaScript pages, Amway pages without products and scrolls that stopped early. New accounts get 1,000 to 5,000 free credits, no card.

Plan	Monthly price	Units included	Price per unit	Concurrency	Overage
Free	$0	1,000 to 5,000 credits	free	not published	none
Pay as you go	per use	none	$3.00 first 1K, $2.00 next 10K, $0.60 next 100K	not published	none
Starter	$99	200K credits	$0.50 per 1K	not published	pay as you go
Scale 500K	$199	500K credits	$0.40 per 1K	not published	pay as you go
Scale 1M	$349	1M credits	$0.35 per 1K	not published	pay as you go
Growth	$599	2M credits	$0.30 per 1K	not published	pay as you go

Scenario (test)	Units per request	Cheapest plan $ (pay as you go, $2.00 tier)	Comparable plan $ (Starter)
Static (#1)	1	$2.00	$0.50
JavaScript (#2)	2	$4.00	$0.99
Cloudflare (#3)	2	$4.00	$0.99
DataDome (#4)	2	$4.00	$0.99
Marketplace (#5)	4.5	$9.00	$2.23
Scroll (#6)	4.2	$8.40	$2.08
Marketplace rendered (#7)	9	$18.00	$4.46

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, failed pages free. Cloud Browser bills browser time: $4.50 for 50 hours on Professional, so our 14.48 s Walmart run comes to about $0.36 per 1,000 pages, plus proxy traffic above the plan allowance at $1/GB.

Crawlbase Pros

• Fast on static pages: 10/10 on test #1 at a median of 2.13 s, about one second ahead of Web Unlocker.
• Won the Walmart page: 10/10 on test #5 against 8/10 for Web Unlocker.
• Cheap easy pages on a subscription: $0.50 per 1,000 standard requests on Starter.
• Built-in scrapers and Markdown: the scraper and format=md parameters are in the API docs.

Crawlbase Cons

• Costs you cannot predict: Walmart cost 4.5 credits a page, 9 rendered, and scroll time doubled test #6 to 4.2 credits a run.
• Empty results charged: five runs on test #2, three on test #4 and five short scrolls on test #6 were billed without the content.
• Slow tails: the slowest successful runs took 128.71 s on test #2 and 134.33 s on test #3.
• Weak on our DataDome target: 3/10 at best, with the JavaScript token and country=US.

Crawlbase Limitations

• No browser product: no session to drive from Playwright; scroll and click run inside one call.
• Scroll is capped: scroll_interval stops at 60 s.
• Geo is country-level: the country parameter takes an ISO code; no city or state option is documented.
• No published concurrency numbers: limits “scale with your plan”.

Crawlbase vs Gologin: Head-to-Head Results

Both tools return pages by default but split the work differently. Crawlbase puts retrieval, rendering, scrolling and site scrapers into one credit-priced API. Gologin keeps retrieval in Web Unlocker at one price per page and moves live sessions to Cloud Browser.

Aspect	Crawlbase Crawling API	Gologin stack
What you send	URL plus token and options	URL (Web Unlocker) or a Playwright session (Cloud Browser)
Rendering	JavaScript token, 2x	included in Web Unlocker
Price unit	credit with site multiplier	page (Web Unlocker), hour (Cloud Browser)
Interaction	scroll and click options inside one call	full browser session
Structured output	built-in scrapers	HTML, other formats listed on the product page

Crawlbase alternative: when Gologin is a better choice

Scenario	Better fit	From our tests
Sites running DataDome	Web Unlocker	9/10 against 3/10 on test #4
JavaScript-heavy pages at volume	Web Unlocker	0.98 s against 8.24 s, 1 request against 2 credits
Pages that need scrolling or clicks	Cloud Browser	7.37 s against 18.12 s on test #6
Scraping Walmart and other high-multiplier marketplaces	Web Unlocker or Cloud Browser	$0.98 or $0.36 per 1,000 against $2.23 to $18.00
Logged-in or multi-step flows	Cloud Browser	not tested; documented session product

Test	Crawlbase success	Crawlbase median s	Gologin success	Gologin median s
#1 Static	10/10	2.13	10/10	3.12
#2 JavaScript	10/10	8.24	10/10	0.98
#3 Cloudflare	8/10	19.81	9/10	11.47
#4 DataDome	3/10	23.19	9/10	20.80
#5 Marketplace	10/10	11.28	8/10	10.61
#6 Scroll	10/10	18.12	10/10	7.37
#7 Escalation	10/10	18.81	10/10	14.48

Scenario	Crawlbase, cheapest plan	Crawlbase, comparable plan	Gologin, entry plan	Gologin, comparable plan
Static (#1)	$2.00	$0.50	$0.98	$0.75
JavaScript (#2)	$4.00	$0.99	$0.98	$0.75
Cloudflare (#3)	$4.00	$0.99	$0.98	$0.75
DataDome (#4)	$4.00	$0.99	$0.98	$0.75
Marketplace (#5)	$9.00	$2.23	$0.98	$0.75
Scroll (#6)	$8.40	$2.08	$0.18	$0.16
Marketplace in a browser (#7)	$18.00	$4.46	$0.36	$0.32

Feature	Crawlbase	Gologin stack
Pricing model	credits with multipliers	per page, flat; browser per hour
JS rendering	JavaScript token, 2x	included
Geo-targeting level	country	country, state, city (product page)
Proxy tiers	managed per site	managed; residential on Cloud Browser
Sticky session, minutes	5 (cookies_session)	Cloud Browser session
Output formats	HTML, JSON, Markdown	HTML; Markdown, text, JSON on the product page
Structured extraction	built-in scrapers	not documented
Screenshots	yes, JavaScript token	listed in the docs overview
Browser-level control	no	Gologin Cloud Browser
Batch and webhooks	async, callback	up to 1,000 URLs, webhooks (product page)
Failure signalling	cb_status, original_status	HTTP status
Failed requests charged	no	no
Free trial	1,000 to 5,000 credits	1,000 requests

Gologin won tests 2, 3, 4 and 6 and lost 1 and 5: Crawlbase was a second faster on the static page and returned Walmart 10/10 against 8/10. On test #4 both were slow: 23.19 s for Crawlbase’s three successes, 20.80 s for Web Unlocker’s nine.

On cost, Crawlbase Starter beats Web Unlocker’s entry plan on standard pages, $0.50 against $0.98 per 1,000. The order flips on Walmart, where the 4.5x multiplier puts Crawlbase at $2.23, and on browser jobs, where Cloud Browser comes to $0.18 and $0.36.

When the Unlocker Fails: Escalation to Cloud Browser

Walmart was Web Unlocker’s weakest target at 8/10, so test #7 ran it through Gologin Cloud Browser. With a new profile and US residential proxy per run, Cloud Browser returned the page 10/10 at a median of 14.48 s: about 4 browser hours per 1,000 pages, $0.36 on Professional before proxy traffic. Crawlbase has no browser product, so its side ran its most expensive working configuration, the JavaScript token: 10/10 at 18.81 s, 9 credits, $4.46 per 1,000 on Starter.

The setup mattered: one profile reused across runs got 0/10, with Walmart answering “Robot or human?”.

The rule: Web Unlocker for pages you can fetch in one request, Cloud Browser when the page needs scrolling, clicks or a login, as on test #6 (7.37 s against 18.12 s). Crawlbase does both inside one API, with scrolling capped at 60 s.

Frequently Asked Questions

Is Crawlbase worth it in 2026?

For static pages and Walmart, yes: it returned both 10/10, at $0.50 and $2.23 per 1,000 on Starter. On sites behind Cloudflare and DataDome it was weaker, 8/10 on Indeed and 3/10 on Amway, and every rendered page costs double. Test your own targets on the free credits before you pick a plan.

How much does Crawlbase cost per 1,000 pages?

It depends on the site. On Starter ($99 for 200K credits) a standard page costs $0.50 per 1,000, a JavaScript page $0.99 and a Walmart page $2.23, or $4.46 rendered. Pay as you go is four times higher. Gologin Web Unlocker is $0.98 per 1,000 for any page.

Does Crawlbase charge for failed requests?

Its docs say failed requests are free, and our HTTP 520 runs were not charged. Results with cb_status 200 but without the content are charged: we paid 1 credit each for five unrendered JavaScript pages and 44 credits for five scrolls that stopped short.

Is there a Crawlbase alternative for DataDome sites?

On the Amway category page, which runs DataDome, Crawlbase got 3/10 at best, with the JavaScript token and country=US, after 0/10 on the Normal token. Gologin Web Unlocker returned the full product grid 9/10 with the default request, at a median of 20.80 s.

Does Crawlbase have a browser product like Gologin Cloud Browser?

No. Crawlbase offers scroll, click and wait options on the JavaScript token, with scrolling capped at 60 s. On our infinite-scroll test it reached 50 quotes 10/10 at 18.12 s. Gologin Cloud Browser runs a full Playwright session and did it 10/10 at 7.37 s.

Crawlbase Review Verdict: Which One Should You Use?

There is no single best web scraping API across these seven targets.

What Crawlbase does better or cheaper than the Gologin stack:

• Walmart product pages: 10/10 on test #5 against 8/10 for Web Unlocker.
• Static pages: 2.13 s against 3.12 s on test #1, and $0.50 per 1,000 on Starter against $0.98.
• Built-in scrapers and Markdown: documented by Crawlbase; Web Unlocker’s API reference lists only url.

Where the Gologin stack was weaker in this test:

• Walmart through Web Unlocker: 8/10, two runs ended in HTTP 503.
• Cloud Browser on Walmart: a reused profile got 0/10 before a new profile per run reached 10/10.
• Indeed: one of ten Web Unlocker runs ended in HTTP 504.
• Amway: one Web Unlocker run returned HTTP 200 with the page skeleton and no products.
• Concurrency: our Web Unlocker key answered parallel requests with HTTP 429, about one request at a time.

What the Gologin stack does better or cheaper than Crawlbase:

• Web Unlocker on DataDome: 9/10 against 3/10 on test #4.
• Web Unlocker on JavaScript pages: 0.98 s against 8.24 s on test #2.
• Web Unlocker on high-multiplier sites: $0.98 per 1,000 on Walmart against $2.23 on Crawlbase Starter.
• Cloud Browser for interaction: 7.37 s against 18.12 s on test #6.

Choose Crawlbase if you need static pages or Walmart-type marketplace pages on a $99 subscription and want built-in scrapers in the same API.

Choose Gologin if you need pages from sites running DataDome, JavaScript-heavy pages at one flat price, or a real browser session for scrolling and multi-step pages.

Conclusion

Crawlbase is a solid retrieval API for static pages and marketplaces while the site’s multiplier stays low. Gologin Web Unlocker is the steadier choice on sites running DataDome and on JavaScript pages, and Cloud Browser covers the session jobs that Crawlbase fits into one call.

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.