Web Page to Markdown Extractor

Convert public web pages into clean Markdown, readable text, metadata, links, images, and optional HTML for AI agents, RAG, support automation, research, and no-code workflows.

Use it when you have public URLs and need LLM-ready page content without maintaining a scraper, browser script, or HTML cleanup pipeline.

At a glance

• Markdown extraction: Convert public HTTP/HTTPS pages into Markdown, plain text, metadata, links, images, and optional HTML.
• AI-ready content: Prepare pages for prompts, embeddings, RAG, summarization, classification, and agent context.
• Render control: Use fast HTTP mode by default, browser mode for JavaScript-heavy pages, or auto mode for fallback.
• Predictable runs: Limit pages, timeout per page, HTML bytes, images, links, and source HTML output.
• Inspectable outcomes: Successful pages are saved as dataset rows; failed or deferred URLs are recorded in the RUN_SUMMARY key-value record without charging a page-result event.

Ready-to-run examples

Open an example, review the input, and run it as-is or adjust the URLs:

• Extract OpenAI Docs Page: Convert a public documentation page into Markdown for AI context.
• Extract Apify Actors Docs: Turn an Apify platform docs page into structured text.
• Extract Next.js Docs Page: Test developer documentation extraction.
• Extract GitHub README Page: Convert a public GitHub README-style page.
• Extract Markdown With Images: Include image URLs and alt text in the output.

What can it do?

Web Page to Markdown Extractor turns public URLs into clean, LLM-ready page content.

• Convert public web pages to Markdown with readable text, page title, description, and metadata.
• Extract links and images for research, crawling, source inspection, and content workflows.
• Choose HTTP, browser, or auto rendering depending on whether the page needs JavaScript.
• Save error rows for failed URLs so large batches remain auditable.
• Use it as a URL-to-Markdown API for AI agents, RAG, support automation, research, and no-code workflows.

What data can you extract?

Field	Description
url	Original input URL
finalUrl	Final URL after redirects or rendering
statusCode	HTTP/browser response status when available
title	Extracted page title
description	Meta description or article excerpt
markdown	Clean Markdown content
text	Plain text content
links	Normalized links and anchor text
images	Normalized image URLs and alt text
metadata	Meta tags and extraction flags
renderModeUsed	http or browser
attemptedRenderModes	Extraction modes attempted for the successful page
status	Always success for a paid dataset row
warnings	Non-fatal warnings, including HTML or Markdown truncation
html	Optional truncated HTML
error	Compatibility field; null for successful rows

For a batch-level view of failed and deferred URLs, open RUN_SUMMARY in the default key-value store. PENDING_URLS is saved before the run deadline; copy those URLs into resumeUrls to retry them in a later run.

Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

Event	What is charged	Price
start	One-time fee charged when a run starts. Covers fixed startup cost.	$0.005

Event	What is charged	Free / no discount	Starter / Bronze	Scale / Silver	Business / Gold	Custom / Platinum	Custom / Diamond
result	One public page converted using HTTP extraction	$0.18526 / 1,000	$0.1611 / 1,000	$0.12566 / 1,000	$0.09666 / 1,000	$0.06444 / 1,000	$0.04511 / 1,000
browser_result	One public page converted using JavaScript browser rendering	$5.75 / 1,000	$5 / 1,000	$3.9 / 1,000	$3 / 1,000	$2 / 1,000	$1.4 / 1,000

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

The start event is charged only after input validation. Only a successfully saved page row is charged as result or browser_result; failed and deferred URLs do not trigger a page-result charge.

Input example

The required input is startUrls.

{
  "startUrls": [
    { "url": "https://example.com" }
  ],
  "renderMode": "http",
  "maxPages": 10,
  "includeLinks": true,
  "includeImages": false,
  "includeHtml": false,
  "timeoutSecs": 20,
  "onlyMainContent": false,
  "maxRunSeconds": 270
}

Input configuration

Setting	JSON key	Use it for	Example
Start URLs	startUrls	Public HTTP or HTTPS pages to convert into Markdown.	[{"url":"https://example.com"}]
Render mode	renderMode	Choose fast HTTP extraction, browser rendering, or auto fallback.	http
Maximum pages	maxPages	Cap how many input URLs are processed.	10
Include links	includeLinks	Extract normalized links from each page.	true
Include images	includeImages	Extract image URLs and alt text.	false
Include source HTML	includeHtml	Store truncated page HTML for debugging.	false
Wait for selector	waitForSelector	Optional CSS selector to wait for in browser mode.	main
Timeout per page (seconds)	timeoutSecs	Maximum time spent fetching or rendering one page.	20
Maximum HTML bytes per page	maxBytes	Truncate oversized pages before conversion.	1000000
Content selector	contentSelector	Optional CSS selector for the exact content region to convert.	article
Prefer main article content	onlyMainContent	Prefer the readable article region when it can be identified.	true
Maximum Markdown characters	maxCharacters	Cap the converted Markdown field; output includes a warning when capped.	50000
Maximum work time	maxRunSeconds	Save completed pages and a pending checkpoint before the platform timeout.	270
Resume URLs from a checkpoint	resumeUrls	Retry URLs copied from a previous PENDING_URLS record before startUrls.	["https://example.com"]

Output example

{
  "url": "https://example.com/",
  "finalUrl": "https://example.com/",
  "statusCode": 200,
  "title": "Example Domain",
  "description": "This domain is for use in documentation examples without needing permission.",
  "markdown": "This domain is for use in documentation examples...",
  "text": "This domain is for use in documentation examples...",
  "links": [
    { "url": "https://iana.org/domains/example", "text": "Learn more" }
  ],
  "images": [],
  "metadata": { "viewport": "width=device-width, initial-scale=1" },
  "renderModeUsed": "http",
  "attemptedRenderModes": ["http"],
  "status": "success",
  "warnings": [],
  "error": null
}

Render modes

HTTP

Use HTTP mode for normal articles, documentation, blog posts, help pages, and static websites.

HTTP mode is fastest and usually cheapest.

Browser

Use browser mode when the page needs JavaScript before content appears.

Browser mode is useful for client-rendered sites but costs more and takes longer.

Auto

Auto mode tries HTTP extraction first and can use browser rendering when the page appears to be JavaScript-heavy or nearly empty after HTTP extraction.

Tips for best results

• Start with one URL before running a large batch.
• Use HTTP mode unless you know the page needs JavaScript.
• Set includeHtml only when you need it.
• Set includeImages only when image URLs matter.
• Use waitForSelector for browser pages that load content slowly.
• Keep timeoutSecs realistic; long timeouts can raise costs.
• Use maxBytes to control very large pages.

Common workflows

• Turn public documentation pages into Markdown for LLM prompts.
• Extract help-center pages into a support knowledge base.
• Convert public product pages into readable summaries.
• Collect article text for monitoring or research.
• Build a URL enrichment step in a no-code automation.
• Prepare website content for embeddings and vector search.

Integrations

You can connect this actor to:

• Make scenarios for URL enrichment
• Zapier workflows for content handoff
• n8n automations for AI pipelines
• Airtable bases for research tracking
• Google Sheets exports for editorial review
• Apify webhooks for event-driven processing
• Vector databases after dataset export

API usage

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/web-page-to-markdown-extractor').call({
  startUrls: [{ url: 'https://example.com' }],
  renderMode: 'http',
  maxPages: 1
});
console.log(run.defaultDatasetId);

Python

from apify_client import ApifyClient

client = ApifyClient('APIFY_TOKEN')
run = client.actor('fetch_cat/web-page-to-markdown-extractor').call(run_input={
    'startUrls': [{'url': 'https://example.com'}],
    'renderMode': 'http',
    'maxPages': 1,
})
print(run['defaultDatasetId'])

cURL

curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~web-page-to-markdown-extractor/runs?token=APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://example.com"}],"renderMode":"http","maxPages":1}'

MCP and AI agents

Use this actor from MCP-compatible AI tools through Apify MCP.

MCP server URL pattern:

https://mcp.apify.com?tools=fetch_cat/web-page-to-markdown-extractor

Add it to Claude Code with:

$claude mcp add apify-web-page-markdown https://mcp.apify.com?tools=fetch_cat/web-page-to-markdown-extractor

Example MCP JSON configuration:

{
  "mcpServers": {
    "apify-web-page-markdown": {
      "url": "https://mcp.apify.com?tools=fetch_cat/web-page-to-markdown-extractor"
    }
  }
}

Example prompts:

• "Convert this public URL into Markdown and summarize it."
• "Extract the links from this documentation page."
• "Fetch these three article URLs and prepare text for a knowledge base."

Limits and scope

This actor processes public pages only.

It does not log in, accept private cookies, submit forms, perform social engagement, or automate arbitrary browser tasks.

Some websites block automated access. Failed or challenge pages are not charged as page results and are listed in RUN_SUMMARY; a run fails when none of the requested pages can be converted.

FAQ

Can this actor access pages behind a login?

No. It is designed for public URLs only and does not accept private cookies or account sessions.

Should I use HTTP or browser mode?

Use HTTP first. Switch to browser mode only for pages where important content is rendered by JavaScript.

Troubleshooting

Why is the Markdown empty?

The page may require JavaScript rendering, block automated requests, or contain mostly media. Try renderMode: browser with a small maxPages value.

Why did browser mode cost more?

Browser rendering starts a real browser and waits for page content. Use it only for pages that need JavaScript.

How do I inspect failed URLs in a mixed batch?

Open RUN_SUMMARY in the default key-value store. Successful pages stay in the dataset, while failed or deferred URLs are listed in the summary without a page-result charge.

Legality

Use this actor only for public web pages you are allowed to access and process. Respect website terms, copyright, robots policies where applicable, privacy laws, and platform rules.

Do not use it to access private account data, bypass authentication, or collect sensitive personal information.

Related actors

Other Anna actors can complement this utility:

• Website Content Crawler Lite
• Website Contact Finder
• Bing Search Results Scraper

Support

If a URL does not extract as expected, open an issue or report a bug from the Actor page. Include the Apify run ID or run URL, input JSON, expected output, actual output, and one reproducible public URL.

Privacy and data handling

This Actor only requests the permissions needed to run the input you provide. It uses your input (such as URLs, search terms, identifiers, filters, and limits) only to fetch the requested public data from the relevant source site or API for this Actor, then writes results to your Apify dataset/key-value store.

Data may pass through Apify platform services and Apify Proxy during the run, and requests are sent only to the target site or public data provider required for this Actor's results. FetchCat does not send your inputs or outputs to advertising networks, data brokers, or model-training services, and does not retain run data outside Apify storage after the run except when you explicitly share run details for transient support debugging.

You are responsible for using this Actor lawfully, respecting the target site's terms, and avoiding unnecessary personal or sensitive data in inputs. Review the output before storing, sharing, or combining it with other data.