Any page, as markdown
your model can read
Send a URL, get the content back. Proxies, retries, and CAPTCHAs are handled on our side, and you choose whether the response is clean markdown or the full HTML document.
Free tier, no card · One POST · No browser to run
HTML in, markdown out
<div class="jsx-3f1a hdr__wrap sticky">
<nav role="navigation" aria-label="Main">
<ul class="nav nav--h"><li><a>Home</a>
<script>window.__DATA__={"ab":"v3","uid":null}</script>
<div id="consent-banner" data-gdpr="1">
<img src="/px.gif?t=1755..." width="1">
<article class="post post--full">
<h1 class="post__title t-xl">Why context windows
still matter</h1>
<p class="lede">Bigger is not the same
as cheaper.</p>
<aside class="promo promo--inline">...{
"content": "
# Why context windows still matter
Bigger is not the same as cheaper. Every
token you retrieve is a token you pay to
read, and most of an HTML page is markup.
## What to strip
- Navigation and footers
- Scripts, styles, and tracking pixels
- Consent banners and inline promos
See the [full benchmark](/benchmark).
",
"url": "https://example.com/article",
"response_type": "markdown"
}{
"content": "<!doctype html><html lang=\"en\">
<head><meta charset=\"utf-8\"><title>Why
context windows still matter</title>
<script type=\"application/ld+json\">
{\"@type\":\"Article\",\"datePublished\":
\"2026-08-11\"}</script></head><body>
<article class=\"post post--full\">...
",
"url": "https://example.com/article",
"response_type": "full"
}
The same fetch, both ways. Switch the tab to see what
response_type changes.
Quickstart
One POST, no browser
A key in a header and two fields in the body. Nothing to install and no headless Chrome to babysit.
curl --request POST \
--url 'https://api.serply.io/v1/request' \
--header 'Content-Type: application/json' \
--header 'X-Api-Key: YOUR_API_KEY' \
--data '{
"url": "https://example.com/article",
"response_type": "markdown"
}'response_type
Two formats, one endpoint
Pick per request. The same URL can come back as reading material or as a document to parse.
"response_type": "markdown"
Content a model can read
Headings, prose, lists, and links survive. Navigation, scripts, styling, and tracking pixels do not. This is the format to send to an LLM, because everything left in it is content you actually wanted to retrieve.
- RAG and vector store ingestion
- Deep research agents
- Summarisation and extraction
"response_type": "full"
The page exactly as served
The complete HTML document, unmodified. Use it when you need a specific element, an attribute, embedded JSON-LD, or a byte-for-byte record of what the page looked like at fetch time.
- Targeted element extraction
- Structured data and microdata
- Archiving and audit trails
The parts that break, handled
Fetching a page is easy until it is not. These are the three reasons a scraper that worked last month does not work today.
CAPTCHAs
Requests go out from Serply's infrastructure, which clears most challenges before you ever see a response. There is nothing to solve on your side.
Blocking and rate limits
Proxy rotation and retries happen behind the endpoint, so a run does not die halfway through because one address got tired of you.
Markup churn
Markdown output is derived from page structure, not from selectors you wrote. A redesign that renames every class does not silently empty your pipeline.
Use cases
What people fetch with it
RAG ingestion
Turn a list of URLs into clean documents ready to chunk and embed. Boilerplate stripping is already done, so your pipeline starts at splitting rather than at cleanup.
Deep research agents
Pair with /v1/search: find the sources, then fetch each one as markdown. An agent gets readable text back on the same call it would have spent parsing HTML.
MCP tools
Wrapped as an MCP tool, this becomes a browse capability for Claude, Cursor, or any MCP client - a model can read a page it was linked to instead of guessing at it.
Competitor and content monitoring
Fetch the same pages on a schedule and diff the markdown. Because formatting noise is gone, a diff shows a copy change rather than a class name that moved.
Knowledge base sync
Pull public documentation, changelogs, and help centres into an internal index, and keep it current without maintaining a parser per site.
Structured data extraction
Take the full HTML when you need JSON-LD, Open Graph tags, prices, or a specific attribute, and let the CAPTCHA and proxy handling stay someone else's problem.
Most of these start with a search. Pair this endpoint with Google Search to find the sources first, or see the MCP server example to hand both to an agent as tools.
FAQ
Common questions
What does the endpoint return?
A JSON object with three fields: content, url, and response_type. content holds the page as markdown or as full HTML depending on what you asked for, url is the page that was fetched, and response_type echoes your choice.
How are CAPTCHAs handled?
Serply fetches the page from its own infrastructure with proxy rotation and retries, and clears most CAPTCHA challenges along the way. You send a URL and get content back. There is no challenge to solve on your side and no browser to keep running.
When should I use markdown instead of full HTML?
Use markdown whenever the consumer is a language model. HTML spends most of its bytes on navigation, scripts, and styling that a model has to read and discard, and that waste comes out of your context window. Use full HTML when you need a specific element, an attribute, or embedded structured data.
Can I fetch any website?
Most publicly accessible pages, yes. Pages behind a login, a paywall, or an explicit block are out of scope, and you remain responsible for honouring each site's terms of service and applicable law.
How does this fit into an AI pipeline?
The usual shape is search then fetch. Call /v1/search for the sources, then call /v1/request with response_type set to markdown on each result. What comes out is document text ready to chunk, embed, or hand straight to a model - no HTML cleanup step in between.
Which languages are supported?
Any language that can send an HTTP POST with a JSON body. It is a plain REST endpoint with a key in a header, so cURL, Python, JavaScript, Ruby, Go, PHP, and Java all work with no SDK to install.
Fetch your first page
Create a key and send one POST before deciding anything. No card, no sales call.