Web Page to Markdown Extractor

Convert selected public web pages into Markdown and readable text with source metadata, links, optional images and optional truncated HTML. Choose HTTP, browser or automatic rendering and keep extraction warnings beside the result. Saved page text can feed your own research or retrieval tools, without guaranteeing that it is complete, current or suitable for a model without review.

Quick start

Begin with one public page in HTTP mode, inspect the returned text and warnings, then select browser or automatic rendering only when needed. The existing bounded input is:

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

Prefer a video guide? This short Apify walkthrough shows you how to set up and run an Actor. It uses a different Actor, but the setup steps are the same.

Ready-to-run examples

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

• Convert Apify documentation to Markdown: Retrieve a public documentation page with text, metadata and links.
• Extract a JavaScript-rendered page: Render a public page before converting its loaded content.
• Extract Markdown with image metadata: Include image URLs and alt text beside the converted page.

What you get

One successful page row with the submitted and final URL, extracted title and description, Markdown, plain text and requested link, image or HTML context. renderModeUsed, attemptedRenderModes and warnings explain how the row was produced. Failed and deferred URLs appear in run diagnostics instead of paid page rows.

Who is it for?

• Knowledge-base teams reviewing public documentation and support content before importing it.
• Research and editorial teams retaining source-linked page text for separate analysis.
• Search and retrieval developers preparing reviewed content for their own indexing or embedding pipeline.
• Automation builders passing structured page content into their existing no-code workflows.

How you can use the data

• Prepare a public documentation excerpt. Use the existing Apify documentation example and retain url, finalUrl, title and extracted Markdown. Review warnings and source freshness before using it as model context rather than assuming it is authoritative or complete.
• Build a reviewed support-content import. Supply your selected public help-page URLs with a small cap, keeping text and source metadata for your own knowledge base. This Actor extracts the selected pages rather than discovering every page or generating answers.
• Inspect links and images with the page. Enable the existing link or image controls and retain anchor or alt text beside normalized URLs. Those references support your own inventory and source checks, without downloading all assets or granting reuse rights.
• Hand content to an existing automation. Export the page rows to your own Make, Zapier, n8n, Airtable, spreadsheet or vector-database workflow. Summaries, classifications, embeddings and change notifications are downstream work, and extracted text may contain untrusted page content.

Input settings

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
Proxy configuration	proxyConfiguration	Optional standard proxy used by both HTTP and Chromium. Direct access is the default.	{"useApifyProxy":false}
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	Shared time allowance for fetching and 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"]

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, with one bounded retry for transient HTTP statuses. It then uses browser rendering when the response is a classified 401, 403, 429, block/challenge page, has no extractable Markdown, or is a small JavaScript application shell. The HTTP and browser attempts share the same per-page and whole-run deadline.

Output data

The existing illustrative Example Domain row shows shape rather than a fresh fetch:

{
  "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
}

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 unavailable, 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.

Download your results

Open your run's dataset, choose Export and select JSON, CSV or Excel. JSON keeps nested fields together. CSV and Excel are useful when you want to review the records in a spreadsheet.

See Apify's download and export guide for the available formats and field options.

Pricing

After input validation, the run charges one start event. Each successfully saved HTTP-converted page uses the result event, while a page saved after browser rendering uses browser_result. Unavailable, empty, failed and deferred URLs do not create page-result charges. A started run can retain its start charge even without results. The Actor checks the remaining allowance for the applicable page event before requesting another page or starting browser fallback.

Browser rendering has a different event rate and additional work, so use it where needed and keep page and work-time limits small. Platform usage, storage, proxies or transfer can also apply. See the live Pricing tab for current rates and discounts.

Tips for best results

• Start with one URL in HTTP mode. Inspect extracted content before expanding the batch.
• Choose browser rendering deliberately. Use it when essential text is generated by JavaScript.
• Keep source HTML optional. Enable it for inspection rather than assuming it is needed for every export.
• Request images only when useful. Image links and alt text can add source context without providing file rights.
• Use selectors carefully. contentSelector chooses an extraction region. waitForSelector instead requires a visible element before browser extraction. If it is absent from a completed valid page at the deadline, the URL produces no row and a visible warning in the log and RUN_SUMMARY.inputWarnings; the run can succeed empty. Check your target's actual markup (use body for a general page wait). Blocking, incomplete navigation and extraction failures are not selector warnings.
• Bound page size and time. Review HTML or Markdown truncation warnings and use realistic timeouts rather than assuming a long wait improves every result.
• Keep a consistent route. Existing proxy settings apply to both HTTP and browser attempts when enabled.

Limits and caveats

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. Auto mode can retry classified blocks and small JavaScript application shells in Chromium, using the same proxy choice and page deadline. Certificate validation stays enabled. TLS handshake failures remain actionable URL errors; Chromium fallback is not a proven recovery for them. Successful fallback rows identify both attempted modes and warn that browser-result pricing applies. An optional proxy can be enabled without changing the output contract. Targets returning HTTP 204, 401, 404 or 410 and completed conversions with no usable text are skipped with reasons in RUN_SUMMARY. A batch containing only those outcomes succeeds with an empty dataset. Unresolved challenges, rate limits and extraction errors remain failures when no useful rows are saved. Mixed batches preserve useful rows and report partial completion.

Input URLs and redirects must stay on supported public HTTP or HTTPS destinations. Private, local or reserved network addresses are rejected. Extraction is not an unrestricted browser task runner, a login session or a promise that a blocked source can be accessed.

HTML-byte and Markdown-character caps can truncate content and produce warnings. Extracted text, metadata and links reflect the public response, and page instructions or claims should be treated as untrusted source material. Copyright and reuse obligations remain with your downstream use.

The shared work deadline can defer URLs while preserving completed pages. Copy URLs from PENDING_URLS into resumeUrls for an explicit later run, supplying valid startUrls as required. Resume URLs are processed before start URLs under the shared page cap. A later run has its normal start charge and can charge converted pages again. Diagnostic persistence is best effort, so a checkpoint is not guaranteed after a storage problem. Restarting or resurrecting a run that already started processing does not repeat extraction. Use a new run with the pending URLs instead.

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.

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.

Automation and integrations

Save your settings for next time

Once you have an input that works for you, save it as an Apify task. This keeps your settings together so you can use them again without filling in the form from scratch.

Run on a schedule

Need fresh results regularly? You can schedule the Actor or a saved task to run at a time that suits you.

Each scheduled run collects the data again. If you want to compare results or highlight changes, add that step in your own workflow.

Send results to your other tools

Use n8n, Make or Zapier to connect this scraper to the rest of your workflow. For example, you could pass its results to an AI assistant or add records to a spreadsheet. Follow the Apify integration guides for your chosen tool.

For a custom connection, an Apify webhook can notify your app when a run finishes or fails. Your app can then fetch the results or handle the failure.

API usage

Want to collect this data from your own app or automation? The examples below send input to the scraper and show how to collect its results.

The existing Node.js and Python examples wait for completion and print the dataset ID. Use that ID to fetch saved rows with the Dataset API or client, using pagination for larger results. The cURL example starts a run and returns its details. Wait for completion before reading its dataset.

For setup instructions, see Apify's JavaScript client guide, Python client guide and Actor runs API reference.

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}'

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'])

MCP and AI agents

You can ask your AI assistant to collect data with Web Page to Markdown Extractor and help you work with the results. The scraper returns the data, and your assistant can then summarize it, compare records or prepare notes.

Connect your assistant through the Apify MCP server. MCP gives your assistant a way to find this scraper, run it and read the results. Follow the official setup and sign-in guide for your app.

Easier setup with an Apify plugin

If you use a supported coding assistant, the official Apify plugin can set up the connection for you. It connects your assistant to Apify and includes instructions for common tasks. Follow the guide for your particular app.

Use Apify AI in Console

Prefer to keep everything in Apify? Open Apify AI in Console and ask it to find Fetch Cat's Web Page to Markdown Extractor. You can describe the data you want and ask questions about the results.

Apify AI is currently in beta. It asks for confirmation before starting an Actor, and normal run charges apply.

Choose your assistant

• Claude and Claude Code (Anthropic): Apify setup guide.
• ChatGPT and Codex (OpenAI): Apify setup guides.
• Grok Bot (xAI): Apify plugin guide.
• Gemini CLI (Google): MCP server setup guide. Use the server URL below with the HTTP configuration supported by Gemini CLI.

Connect just this scraper

To keep your setup focused on this scraper, add this server configuration to a compatible MCP client:

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

Sign in to Apify when your client asks. If your client uses a Bearer token instead, follow its setup guide and keep the token in its secure configuration. Configuration formats vary by app, so use the linked guide if your client needs a different format.

Use Apify's general server

Already connected to the general Apify MCP server at https://mcp.apify.com? You can use it to find this scraper without adding another server. Ask your assistant to use Web Page to Markdown Extractor by Fetch Cat, or give it the identifier fetch_cat/web-page-to-markdown-extractor.

Your assistant can check the available settings and retrieve the results from the returned run. If the run is still working, it should follow that run rather than start it again. Both connection options use Apify's hosted service.

Example requests

• “Use Fetch Cat’s Web Page to Markdown Extractor to collect Markdown and page-title metadata from https://example.com with HTTP mode, a one-page cap, links on and images and HTML off. Keep warnings and source links without generating a summary.”
• “Retrieve text and normalized links from https://docs.apify.com/platform/actors with HTTP mode and a one-page cap. Keep source context and any truncation warning before preparing my own knowledge-base import.”
• “Collect Markdown and image-link context from https://example.com with automatic rendering and a one-page cap, images on and HTML off. Keep the actual render mode and failures visible without assuming browser access will succeed.”

Normal Apify charges apply. Check the live Pricing tab before asking your assistant to run a larger batch.

Pay with x402

If your AI agent has a funded wallet, it can pay for Apify usage through x402. This experimental option lets an agent use Apify without a conventional account.

Apify AGI provides a prepaid API token with a spending cap after payment. Your agent can use that token to run this scraper through the Apify API or an authenticated MCP connection.

Some MCP setups also support paying for each request directly. That is a different payment option, so check the official guide for its availability.

Follow the official guide for wallet setup, supported payment options and current terms. Apify handles the payments. Keep wallet keys and payment tokens in your agent's secure configuration.

Other ways for agents to pay

Apify also supports MPP for prepaid access through AGI and Skyfire for eligible Actors. If your agent already uses one of these, see the agentic payment guide to choose the right setup.

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: auto first. If both the direct HTTP and Chromium routes are blocked, enable proxyConfiguration 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.

Related Actors

These related Actors can complement this utility:

• Website Content Crawler Lite — Collect text, Markdown, HTML, metadata and discovered links from public website pages.
• Website Contact Finder — Find published email, phone and social profile links on known public company websites.
• Bing Search Results Scraper — Collect public Bing web-search result titles, snippets and links.
• Sitemap URL Extractor — Extract public sitemap URL inventories and optional last-modified metadata, without fetching page content.
• Webpage Image Extractor — Collect image URL references and available metadata from public web pages, without downloading image files.

Support and feedback

For custom additions or integrations, email hello@fetchcat.dev.

Found an error or have a feature request? Open an issue with the run URL, a non-sensitive input example and what you expected.

Need help sharing it? See Apify’s guide to sharing a run when reporting an issue. Sharing a run can give the developer access to its input, logs and results, so use a run that contains no sensitive data. Please leave out API tokens, passwords, cookies, private documents and personal data. Use a public sample URL or a redacted example instead.

Tried this scraper? We'd love to hear how it worked for you. Leave a review to help others choose the right tool and help us improve it. Your feedback means a lot to us.

Made with care for curious people, AI agents and the possibilities in data. ♥