When a site's anti-bot blocks your scraper, you can buy your way past it in three different shapes: a scraping API, a web unlocker, or an anti-bot API. They are often listed side by side, but they aren't three brands of the same thing. What separates them is one question: who owns the HTTP client? Who opens the connection, holds the IP, keeps the cookies and decides what the next request is. Answer that, and most of the trade-offs in control, debugging, cost and lock-in follow from it.
This post explains the three models, compares them on the things that matter in production, and says when each one is the right call, including when it isn't ours.
Key Takeaways
- A scraping API owns the whole fetch: you send a URL, the provider returns the page or extracted data.
- A web unlocker is a managed unlocking layer you reach as a proxy endpoint or a REST call. The provider re-sends your request from its own infrastructure and handles blocks along the way.
- An anti-bot API leaves the HTTP client, proxies, session and site logic with you, and generates only the payload the anti-bot expects: sensor data, tokens, cookies or headers.
- The more of the client you hand over, the less you build and the less you can see or control when something breaks.
- There is no universal winner. Many teams use an anti-bot API for a few high-volume protected targets and a scraping API or unlocker for the long tail.
The three models
Scraping API: the provider owns the fetch
You send a URL and some options, and the provider fetches the page with its own IPs, its own HTTP client or browser and its own retries, handling the anti-bot protection along the way. You get back HTML, a rendered page or, with some providers, structured data. Some providers, for example, describe their scraping API as one that avoids bans and can also automate a browser and extract data.
It is the fastest way from "I need this data" to having it, and the model that asks the least of your team. The price is that the provider decides how the request looks, and you see only what comes back.
Web unlocker: a managed layer between you and the site
A web unlocker sits where a proxy would sit. You send your request to its endpoint, either as a proxy or as a REST call, and the provider re-sends it from its own infrastructure, choosing IPs, fingerprints and headers and retrying until it gets through. One provider's documentation, for example, describes its unlocker solving CAPTCHAs and anti-bot challenges automatically and retrying failed attempts with other configurations.
One detail shows what is happening underneath: when you use an unlocker as a proxy endpoint, you either trust the provider's certificate or turn off certificate verification in your client. The unlocker terminates TLS and opens its own connection to the site. Your client talks to the unlocker; the unlocker's client talks to the site.
You keep your own scraping logic, which URLs to request and what to do with the responses, while the provider owns the connection that reaches the site.
Anti-bot API: you keep the client, the API generates the payload
An anti-bot API (also called a bypass API or payload API) takes the opposite approach. Your scraper keeps making every request to the site with your own HTTP client, through your own proxies, in your own session. When the site's anti-bot wants proof that a browser is present, you send the API the inputs that challenge needs (the vendor's script, the relevant cookies, your IP and your User-Agent), and it returns the payload a real browser would have produced. You post that payload to the site yourself.
That is how Hyper Solutions works for Akamai, DataDome, Incapsula/Imperva and Kasada. The API never talks to the target site. It only turns challenge inputs into the payload, and your code does everything else.
Read across a row to see who you depend on when that part breaks. The anti-bot API is the only model where the HTTP client stays yours.
| Part of the scraper | Scraping API | Web unlocker | Anti-bot API |
|---|---|---|---|
| HTTP client and TLS fingerprint | Provider | Provider | You |
| IPs and proxies | Provider | Provider | You |
| Cookies and session | Provider | Configurable | You |
| Request sequence and site logic | Provider | You | You |
| Anti-bot solve | Provider | Provider | API (payload only) |
| Retries | Provider | Provider | You |
| Parsing the response | Provider (optional) | You | You |
| Billing unit | Varies by provider | Varies; per successful request at some providers | Per solve, plus your own proxy bandwidth |
| Vendor coverage | Aims at any site | Aims at any site | The systems it was built for |
How they compare in production
Control and debugging
With an anti-bot API you can see every byte that leaves your scraper: header order, TLS handshake, cookies, the exact request sequence. When a request is blocked, you diff it against a real browser and fix the difference; our powhttp guide shows that loop. Nothing between you and the site hides the cause.
With an unlocker or a scraping API you see the response the provider hands back. When success drops, the cause sits in infrastructure you can't inspect, and the fix is a support ticket or a different option flag. For a team without the time to debug on the wire, that is a feature. For a team that needs to know why, it is a ceiling.
Proxies, IPs and bandwidth
Unlockers and scraping APIs include the IPs. You don't manage proxies, and while you can usually pick a country, you can't pick the IP: each request gets whatever address is in the provider's pool at that moment.
An anti-bot API needs your own proxies, and it needs them used correctly: the IP you send to the API has to be the IP the site sees, so each session runs on one sticky IP (why). In return you pick the provider, the country and the session length, and you can measure the traffic. Request-based sessions are small: in a hotel-search scraper we built, clearing Akamai cost 520 KB of proxy traffic per session and each search after that 12.5 KB, through Massive residential proxies.
Latency and scale
An anti-bot API adds one API call per challenge solve; everything else is your own requests going straight to the site. There is no browser to start, so one machine can run hundreds of sessions.
With an unlocker or scraping API, every request goes through the provider's infrastructure, including whatever retries it runs before answering. That can be perfectly fine for batch jobs and harder to live with when you need tight, predictable timing on multi-step flows.
Cost structure
Compare how each provider counts before you compare prices. One unlocker provider's documentation, for example, says it charges only for successful requests. Hyper Solutions bills per solve: you pay when you generate a payload, not for every request your session sends to the site. How many solves a session needs depends on the vendor and the site; some only check a cookie, others want a fresh payload on each protected call. Your proxy bandwidth is a separate line on your own bill, and how the scraper is built decides most of it: in a residential proxy bandwidth benchmark, a request-based scraper used about 22 times less proxy traffic than a default headless browser for the same hotel searches.
So the cheaper model depends on your traffic. Many requests per solved session on a few protected sites favour paying per solve plus your own bandwidth. Few requests spread across many different sites favour paying per successful request. Check which options change a provider's price (rendering, premium IPs) and what counts as a success.
Site logic, sessions and multi-step flows
Real scrapers rarely fetch one URL. They load a page, call a search endpoint, page through results, carry tokens and cookies from one step to the next. When you own the client, that flow is ordinary code: one session, one cookie jar, one IP, requests in the order a browser makes them.
Unlockers and scraping APIs vary in how much of that they let you keep. Some offer sticky IPs, reusable cookies and custom headers; check the specific product, because a flow that depends on session state needs it end to end.
Implementation effort
This is where the anti-bot API costs you. You need a browser-grade TLS client, Chrome's exact header order, consistent sessions and sticky proxies (core requirements), plus the specific flow for each challenge. It is technical work and not beginner-friendly. Our docs, the examples repository and the AI coding agent plugins shorten the learning curve, but they don't remove it.
A scraping API asks for almost none of this. An unlocker sits in between: your scraping logic stays, the hard part of the connection doesn't.
Maintenance and lock-in
Anti-bot vendors update their scripts. With an anti-bot API, keeping up with those updates is the API provider's job; occasionally a change needs a new input from you, like the SBSD context field, and that gets documented. Changes to the site itself, such as new endpoints or new parameters, are yours in every model except a scraping API that also parses for you.
Lock-in follows the same line as ownership. An unlocker is easy to swap because it looks like a proxy. A scraping API with built-in extraction is the hardest to leave, because your pipeline depends on its output format. With an anti-bot API your scraper is your own code, and the API is one call per challenge.
Coverage
Unlockers and scraping APIs aim to work on any site. An anti-bot API covers the systems it was built for. Ours covers Akamai Bot Manager, DataDome, Incapsula/Imperva and Kasada; for a target protected by something else, an unlocker or scraping API may simply be the practical option.
When a browser is still the answer
Some targets are better served by a real browser in any model: flows that depend on long-lived logged-in browser state, or pages whose data only exists after heavy client-side rendering. Request-based scraping pays off most where the data comes from a handful of JSON calls, which is more often than people expect.
Which one should you use?
A scraping API fits when you need data from many different sites at modest volume per site, you'd rather not run scraping infrastructure, or you want rendering and extraction handled for you.
A web unlocker fits when you already have scraping logic and parsers, your targets are diverse, and you want blocks handled per request without building anything per site, accepting less visibility into what happens on the wire.
An anti-bot API fits when your important targets run Akamai, DataDome, Incapsula or Kasada, volume on those targets is high, and you need control: your own proxies, your own sessions, predictable timing and the ability to debug a failure down to the header.
Mixing is normal. A team can run its high-volume protected targets request-based with an anti-bot API and send the long tail of other sites through an unlocker or scraping API. The question per target is the same: who should own the HTTP client here?
What the anti-bot API route looks like
If you go this way, the shape of the work is the same for every vendor:
- Make the scraper look like Chrome on the wire: a browser-grade TLS client, exact header order, one sticky IP and one cookie jar per session.
- Record the target in a clean browser and identify which challenges it runs.
- When a challenge appears, send its inputs to the API, post the returned payload to the site, and keep going in the same session.
The vendor guides walk through step 3 with code: Akamai, DataDome, Incapsula and Kasada.
FAQ
What is a web unlocker?
A web unlocker is a managed service you send requests through, as a proxy endpoint or a REST call. The provider re-sends each request from its own infrastructure, choosing IPs, fingerprints and headers, handling CAPTCHAs and anti-bot challenges, and retrying until it gets a response. Providers sell similar products under names like web unlocker or web unblocker.
Is a web unlocker the same as a scraping API?
They overlap, but no. With a web unlocker your scraper still decides what to request and parses the result; the unlocker handles the connection. A scraping API owns the whole fetch, often including browser rendering, and some return structured data instead of raw HTML.
What is an anti-bot API?
An API that generates the payloads an anti-bot system expects from a real browser, such as Akamai sensor data, DataDome challenge payloads, Incapsula reese84 tokens or Kasada tokens, while your own HTTP client makes every request to the site. It is also called a bypass API or payload API.
Is an anti-bot API a web unlocker alternative?
For targets protected by Akamai, DataDome, Incapsula or Kasada, it can be: it handles the same anti-bot layer while your own HTTP client, proxies and session keep making every request. For a long tail of different sites, an unlocker is often the simpler tool, and many teams use both.
Can I use my own proxies with an anti-bot API?
You have to. Your code makes the requests, so they go through your proxies. Use sticky session proxies so the IP you send to the API matches the IP the site sees for the whole session.
Which model is cheapest?
It depends on how your traffic is shaped. Providers count differently: per successful request, per solve, per gigabyte of proxy traffic. Model a realistic month of your own traffic against each provider's billing unit rather than comparing headline prices.
Do I still need a headless browser?
Not for most anti-bot challenges if you use an anti-bot API, and not directly if you use an unlocker or scraping API. You may still want a browser for flows that depend on long-lived browser state or heavy client-side rendering.
Keep your scraper, solve the anti-bot layer
If your targets run Akamai, DataDome, Incapsula or Kasada and you want to keep your own HTTP client, proxies and sessions, the Hyper Solutions API generates the payloads and leaves the rest to you. The product pages for Akamai, DataDome, Incapsula and Kasada cover what each API solves. Every account starts with a free one-week trial, so you can test it on your own target: create an account.
Solve Akamai, DataDome, Incapsula and Kasada in one request
Skip the browser. Generate the sensor data, tokens and cookies you just read about over plain HTTP, with a free one-week trial.