> ## Documentation Index
> Fetch the complete documentation index at: https://docs.zenrows.com/llms.txt
> Use this file to discover all available pages before exploring further.
> ## Agent Instructions
> The Zenrows API (Fetch, Extract via extract=auto, and Batch) is described in OpenAPI 3.1 at https://www.zenrows.com/openapi.json and listed in the RFC 9727 API catalog at https://www.zenrows.com/.well-known/api-catalog. Use the spec for exact parameter names and types.
# Turn any web page into LLM-ready markdown
> Turn any web page into clean markdown or plain text with Zenrows Fetch, ready for an LLM, a RAG index or an AI agent.
Send any URL to Fetch with `response_type=markdown` and get back the page as clean markdown: headings, lists, links and tables kept, scripts and styling dropped. It's the fastest way to give an LLM, a RAG pipeline or an agent the content of a page.
**Uses:** [Fetch](/fetch/api-reference) with [`response_type`](/fetch/features/markdown) and [Adaptive Stealth Mode](/fetch/features/adaptive-stealth-mode) (`mode=auto`)
## Ask your AI agent
With the [Zenrows MCP server](/mcp/overview) connected to Claude, Cursor or any MCP client, paste this prompt. Your agent picks the right Zenrows tools and settings on its own.
```text theme={"dark"}
Use Zenrows to read https://www.scrapingcourse.com/ecommerce/product/abominable-hoodie/
as markdown, then summarize the product in three bullet points: name, price, and what it's made for.
```
## Fetch a page as markdown
Set `response_type=markdown`. Pair it with `mode=auto` so Zenrows renders JavaScript and switches to premium proxies only when the page needs them, and bills only the configuration that succeeds.
```python Python (Requests) theme={"dark"}
import requests
params = {
"apikey": "YOUR_ZENROWS_API_KEY",
"url": "https://www.scrapingcourse.com/ecommerce/product/abominable-hoodie/",
"mode": "auto",
"response_type": "markdown",
}
response = requests.get("https://api.zenrows.com/v1/", params=params, timeout=180)
response.raise_for_status()
markdown = response.text
print(markdown)
```
```javascript Node.js theme={"dark"}
const params = new URLSearchParams({
apikey: "YOUR_ZENROWS_API_KEY",
url: "https://www.scrapingcourse.com/ecommerce/product/abominable-hoodie/",
mode: "auto",
response_type: "markdown",
});
const response = await fetch(`https://api.zenrows.com/v1/?${params}`, {
signal: AbortSignal.timeout(180_000),
});
if (!response.ok) throw new Error(`${response.status}: ${await response.text()}`);
const markdown = await response.text();
console.log(markdown);
```
```bash cURL theme={"dark"}
curl "https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Fwww.scrapingcourse.com%2Fecommerce%2Fproduct%2Fabominable-hoodie%2F&mode=auto&response_type=markdown"
```
```bash CLI theme={"dark"}
zenrows fetch https://www.scrapingcourse.com/ecommerce/product/abominable-hoodie/ --output markdown
```
The CLI uses `mode=auto` by default, so it needs no extra flag. Install it with `npm install -g @zenrows/cli`, see the [CLI guide](/cli/fetch/introduction).
## Example output
The product section of the response, trimmed:
```markdown theme={"dark"}
# Abominable Hoodie
$69.00
This is a variable product called a Abominable Hoodie
## Description
It took CoolTech™ weather apparel know-how and lots of wind-resistant fabric to get the Abominable Hoodie just right.
• Blue heather hoodie.
• Relaxed fit.
• Moisture-wicking.
• Machine wash/dry.
```
## Get plain text instead
When you need words only, for example to count tokens, classify text or feed a model that ignores formatting, set `response_type=plaintext`. Everything else stays the same.
```python Python (Requests) theme={"dark"}
import requests
params = {
"apikey": "YOUR_ZENROWS_API_KEY",
"url": "https://www.scrapingcourse.com/ecommerce/product/abominable-hoodie/",
"mode": "auto",
"response_type": "plaintext",
}
response = requests.get("https://api.zenrows.com/v1/", params=params, timeout=180)
response.raise_for_status()
print(response.text)
```
## Send the page to an LLM
Markdown drops straight into a prompt. This example keeps the content between clear delimiters so the model knows where the page starts and ends:
```python Python (Requests) theme={"dark"}
import requests
params = {
"apikey": "YOUR_ZENROWS_API_KEY",
"url": "https://www.scrapingcourse.com/ecommerce/product/abominable-hoodie/",
"mode": "auto",
"response_type": "markdown",
}
markdown = requests.get("https://api.zenrows.com/v1/", params=params, timeout=180).text
prompt = f"""Answer using only the page below.
{markdown}
Question: What sizes and colors is this product available in?"""
# Send `prompt` to the model of your choice, for example with the Anthropic or OpenAI SDK.
print(prompt[:500])
```
## Customize it
| Change | How |
| - | - |
| Plain text instead of markdown | `response_type=plaintext`, see [Plain text](/fetch/features/plaintext) |
| A PDF of the page | `response_type=pdf`, see [PDF](/fetch/features/pdf) |
| Content from a specific country | Add `proxy_country=us` (any ISO code), see [Proxy country](/fetch/features/proxy-country) |
| Wait for content that loads late | Use `js_render=true` with `wait_for=` instead of `mode=auto`, see [Wait for selector](/fetch/features/wait-for) |
| Structured fields instead of a page | Use `extract=auto`, see [Get structured JSON from any page](/academy/extract/auto-extraction) |
| Hundreds or thousands of pages | Send the URLs as one job, see [Scrape a list of URLs](/academy/scrape-from-a-list-of-urls) |
## Troubleshooting
* **The markdown is missing content you see in your browser**: the content loads after the first render. Switch to `js_render=true` and add `wait_for` with a selector of the missing element.
* **The markdown starts with navigation links**: that's the page's own menu. Start reading from the first `# ` heading, or use [Extract](/academy/extract/auto-extraction) to get only the fields you need.
* **The request takes long to return**: set your HTTP client timeout to 180 seconds or more, so `mode=auto` has time to escalate when a page needs it.
## Related recipes
Crawl a whole site and turn every page into markdown chunks.
Skip parsing: get product, listing or article fields as JSON.
Let Adaptive Stealth Mode pick the right configuration per page.
Give Claude, Cursor or your own agent live web access.
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.