What does FetchLayer's web unblocker API return, and what does it cost?
FetchLayer Sesame (Sesame · Web Unblocker) is our web unblocker API: send any public URL and get the page back as JSON, as readable content sized for a model, Markdown, visible text, HTML, its links, its metadata or a screenshot, including pages that turn an ordinary request away. From 1 credit, and most requests cost exactly that: a simple page, one that fills in its content after it loads or one that turns ordinary requests away is 1 credit. 5 credits applies only to the very hardest pages, rare in practice, and only when it was actually needed. You are charged at the level the page needed, and a request that returns no page is not billed. Set maxEffort to advanced and a request never costs more than 1 credit; a page that needs more comes back unsuccessful and is not charged. Credits cost $1.99 per 1,000 pay-as-you-go, or $25 a month buys 15,000, with 30 free to start. Both routes are also tools on our MCP server at https://mcp.fetchlayer.dev, for Claude, ChatGPT, Cursor and other MCP clients.
What is Sesame?
FetchLayer Sesame is our web unblocker: the same API, key and credits as before, under its own name. Existing routes, MCP tool names and integrations are unchanged.
What is a web unblocker?
One HTTP endpoint that fetches any public URL and hands back the page — as HTML, visible text, Markdown or an image. It gets the pages an ordinary fetch cannot: the ones that come back empty, and the ones that turn a plain request away. You send a URL with a Bearer token; you get the page, and a receipt saying what it cost.
What does a page cost?
From 1 credit, and most requests cost exactly that: a simple page, one that fills in its content after it loads or one that turns ordinary requests away is 1 credit. 5 credits applies only to the very hardest pages, rare in practice, and only when it was actually needed. You are charged at the level the page needed. The exact figure is on every response as pagesFetched, so you never have to guess. A request that comes back with no page is not billed at all.
Can I cap what a request is allowed to cost?
Yes, and that is what maxEffort is for: a ceiling on how hard a single request may work for the page before it gives up. Sweeping ten thousand URLs where most are plain HTML? Set the lowest ceiling and re-run only the failures without it. A capped request says so in notes, so it is never mistaken for a broken page. Set maxEffort to advanced and a request never costs more than 1 credit; a page that needs more comes back unsuccessful and is not charged.
How long can one request take?
There is a hard 120-second ceiling on a single request. Work that cannot finish inside what is left of it is abandoned before it starts rather than cut off halfway — so you are never billed for effort that produced nothing. A 404 comes straight back: the page is not there, and working harder cannot change that.
What happens when nothing works?
A 503, and it is not billed — a request that produced no page costs nothing, so a hard target is never something you pay to discover. The body carries the reason it gave up, and lowering maxEffort and re-running is how you narrow down which pages in a batch are the expensive ones.
Are the hard pages as fast as the easy ones?
No, and it is worth planning for. A page that gives up its content immediately comes back in well under a second. The most stubborn ones take considerably longer, and in a large burst some will run out the 120-second ceiling and come back unread rather than wrong. Expect a small slow tail rather than a uniform latency, and retry that tail rather than sizing every timeout for it.
How do I know the charge is right?
You read it rather than trust it. Every response that returns a page carries a usage block: what the request cost, the effort level that served the page (which is what sets the price), bytes transferred and the wall-clock total. A request that cost more than you expected tells you which level it needed, on the response, at the time.
How do I avoid saving a block page by mistake?
A blocked request that answers 200 with a "please verify" page is the failure that quietly poisons a dataset. Two parameters stop it: expectText names text that must appear, and waitForSelector names an element that must be present. If what you asked for never appears, the request is reported unsuccessful rather than answered with the wrong content.
What will it refuse to fetch?
Public http and https addresses only, checked before a request is made rather than after. Reserved address space is refused — loopback, private ranges, link-local and cloud metadata — along with every spelling of it: integer forms such as http://2852039166/, IPv4-mapped, NAT64 and 6to4. Ports are allowlisted to 80, 443, 8080 and 8443. Credentials before the hostname are rejected. Every redirect hop is re-validated against the same rules as the first, so a public address cannot redirect into a private one.
What is not implemented?
Two things, said plainly rather than left to be discovered. Nothing drives the page for you — no click, scroll or type; waitForSelector, waitMs and waitUntil are the whole vocabulary for waiting. And there is no per-target-host rate limiting: if you need to be gentle with one site, pace it yourself.
Can my AI agent use it?
Yes. Both routes are MCP tools on the same FetchLayer MCP server, named web_unblocker_fetch and web_unblocker_screenshot. Ask for output: "readable" and the page arrives as its main content in compact markdown, about 8,000 tokens or fewer where the HTML runs to 100,000 or more, with totalTokens and shownTokens saying how much came back. Tool calls use the same key and are billed exactly like REST.
Used by developers at
Individual developers or teams — not official partnerships