Website to Markdown — Content Crawler for LLM & RAG avatar

Website to Markdown — Content Crawler for LLM & RAG

Pricing

from $0.60 / 1,000 results

Go to Apify Store
Website to Markdown — Content Crawler for LLM & RAG

Website to Markdown — Content Crawler for LLM & RAG

Convert web pages into clean Markdown for LLMs, RAG and vector databases. Pay per delivered result: $1/1,000 on Free; from $0.60/1,000 on Diamond. $0.00005 per run start.

Pricing

from $0.60 / 1,000 results

Rating

0.0

(0)

Developer

Murat Uzun

Murat Uzun

Maintained by Community

Actor stats

0

Bookmarked

7

Total users

3

Monthly active users

a day ago

Last modified

Features

Limited permissions

Share

What is Website to Markdown Crawler?

Website to Markdown Crawler is an Apify Actor that turns server-rendered web pages into Markdown — one row per page, with navigation, footers, sidebars and cookie banners stripped, headings and code blocks preserved, and links made absolute. It uses plain HTTP with Crawlee's CheerioCrawler, without a headless browser. Feed it a start URL or sitemap to crawl up to your page budget and produce content for an LLM, RAG pipeline, LangChain/LlamaIndex loader, or vector database.

Pricing: Website to Markdown costs $1.00 per 1,000 results (pay per result, no subscription; Apify's free plan credit covers small runs).

Why use Website to Markdown Crawler?

  • Feed an LLM or RAG pipeline in minutes. Point it at your docs site, a competitor's help center, or your own product site and get clean Markdown ready for chunking and embedding — no HTML soup to clean up first.
  • 10× cheaper, no browser. apify/website-content-crawler and similar Actors spin up a browser per page. This Actor fetches raw HTML over HTTP, so it's faster and priced at $1 per 1,000 pages.
  • Predictable cost. maxPages is the billed unit and the crawl stops at exactly that count — no surprise runs.
  • Sitemap-aware BFS crawl. Optionally seeds from /sitemap.xml (including nested sitemap indexes) so you reach real content pages immediately instead of waiting for link discovery.

How to use Website to Markdown Crawler

  1. Paste one or more pages into Start URLs, e.g. https://docs.apify.com/platform or your own docs/blog root.
  2. Set Max pages — this is the billed unit ($1 per 1,000 pages) and the crawl stops exactly there.
  3. Optionally set Include path prefixes (e.g. /docs) to stay inside one section of a larger site.
  4. Choose Output format: Markdown, plain text, or both.
  5. Click Start, then download the dataset as JSON, CSV, Excel or HTML, or pull it straight into your RAG pipeline via the API.

Example input

{
"startUrls": [{ "url": "https://docs.apify.com/platform" }],
"maxPages": 50,
"maxDepth": 3,
"sameDomainOnly": true,
"useSitemap": true,
"outputFormat": "markdown"
}

Example output

{
"url": "https://crawlee.dev/docs",
"finalUrl": "https://crawlee.dev/js/docs/quick-start",
"statusCode": 200,
"title": "Quick Start | Crawlee for JavaScript",
"description": "Crawlee helps you build reliable scrapers. Fast.",
"lang": "en",
"canonical": "https://crawlee.dev/js/docs/quick-start",
"markdown": "# Quick Start\n\nWith this short tutorial you can start scraping with Crawlee in a minute or two...\n\n## Choose your crawler\n\n### CheerioCrawler\n\nThis is a plain HTTP crawler...",
"text": null,
"wordCount": 1484,
"headings": ["Quick Start", "Choose your crawler", "CheerioCrawler", "PuppeteerCrawler"],
"links": ["https://crawlee.dev/js/docs/introduction", "https://crawlee.dev/js/docs/guides"],
"depth": 0,
"contentHash": "3f9a1c2e...",
"crawledAt": "2026-09-12T18:21:07.000Z",
"error": null
}

What data does Website to Markdown Crawler extract?

One row per crawled page:

FieldTypeDescription
url / finalUrlstringRequested URL and URL after redirects
statusCodeintegerHTTP status code, null on a failed request
title / descriptionstringPage <title> (or first <h1>) and meta description
langstring<html lang> attribute
canonicalstring<link rel=canonical>, resolved to an absolute URL
markdownstringMain content as Markdown — headings, lists, code blocks, tables, absolute links/images
textstringMain content as plain text
wordCountintegerWord count of the extracted content
headingsarrayH1-H3 text, in order, up to 50
linksarraySame-domain absolute links found on the page, up to 200
depthintegerLink depth from the nearest start URL
contentHashstringSHA-1 of the plain text — diff two runs to detect changed pages
crawledAtstringISO timestamp
errorstringAlways null: pages that fail are not charged and are listed in the run's ERRORS record instead
chunksarrayWith Add RAG chunks: text, exact token count, heading path, source identity and overflow metadata (see below); otherwise null
changeStatusstringWith Detect changes: new, changed or unchanged, otherwise null

markdown/text are populated according to the Output format input (markdown, text, or both); the unused one is null.

Input parameters

ParameterTypeDefaultDescription
urlstringnoneFast single-page mode for AI agents: fetch only this page (no sitemap, no link following); overrides startUrls and maxPages
startUrlsarraydocs.apify.com/platformPage(s) to start crawling from
maxPagesinteger50Billed unit; the crawl stops at exactly this count (1-5000)
maxDepthinteger3Link depth from a start URL (0-10)
sameDomainOnlybooleantrueOnly follow links on any supplied start domain (www. counts as the same)
includePathPrefixesarraynoneOnly crawl paths starting with one of these, e.g. /docs
excludePathPatternsarrayimages/PDF/CSS/JS, /login, /signup, ?replytocom=Regexes tested against the full URL; a match is skipped
useSitemapbooleantrueAlso seed from /sitemap.xml (follows one nested sitemap-index level)
outputFormatstringmarkdownmarkdown, text, or both
removeSelectorsarraynoneExtra CSS selectors to strip before extraction
maxConcurrencyinteger10Parallel requests (1-50)
maxPagesPerDomainintegernoneCap pages crawled from any one domain (www. ignored)
maxConsecutiveFailuresinteger20Stop the crawl after this many failed pages in a row; 0 = never
respectRobotsbooleantrueSkip URLs disallowed by robots.txt
proxyConfigurationobjectnoneOptional Apify Proxy configuration
chunkForRagbooleanfalseAdd a chunks array (heading-aware, exact o200k token counts) to every page
chunkSizeinteger500Target tokens including context and overlap (50-8000); whole code/GFM table blocks may exceed it and are flagged
changeDetectionbooleanfalseAdd changeStatus (new / changed / unchanged) versus the previous run with the same start URLs
skipUnchangedContentbooleantrueWith change detection on, unchanged pages get empty markdown/text/chunks

Pricing

Website to Markdown Crawler uses pay-per-event pricing: $1 per 1,000 pages ($0.001 per page), plus the actor-start fee shown in the Store pricing tab. Check that tab for current plan-specific charges. Set Max pages and the platform's Maximum cost per run to limit spend. An owner's development-run platform cost is not the price charged to customers.

Website to Markdown Crawler vs. browser-based content crawlers

This Actor extracts the HTML returned by HTTP. Tools such as Website Content Crawler also offer adaptive HTTP/browser modes, JavaScript rendering and file handling. Pages that render their content only with JavaScript may return little or no text here. Performance and total customer cost depend on the page and settings; no general speed or cost advantage is claimed.

The converter preserves page hero titles and article headers unless an explicit removal selector excludes them. Heading cards become valid linked Markdown headings, retaining their descriptions and code. Tables and code blocks follow the preservation rules below.

RAG-ready chunks in the same run

Technical examples wrapped in an article's <aside> keep their code and tables. Global sidebars, explicitly complementary regions and your Remove selectors rules still apply. This matters for documentation sites that use aside boxes for substantive examples.

Turn on Add RAG chunks to get heading-aware pieces of each page's Markdown with exact GPT (o200k) token counts. Normal prose includes heading context and overlap within Chunk size. Fenced code and GFM tables stay whole. An indivisible block above the target has oversized: true and overflowReason: "preserved-code-block" or "preserved-table-block"; route these blocks separately before sending them to an embedding model with a strict input limit. HTML table fallbacks are retained in the page Markdown but are not treated as indivisible GFM chunks. Chunks are part of the page result at no extra charge.

Each chunk includes chunkIndex (zero-based), sourceUrl (final URL), sourceContentHash (the page's text hash) and a deterministic chunkId derived from that URL, hash, index and chunk text. Use these fields to keep citations attached to the source and to upsert unchanged chunks. The ID changes when those inputs change; it is not a permanent semantic ID across edits or chunk-size changes.

tokenTarget, tokens, overlapTokens, oversized and overflowReason make the actual token budget explicit. Overlap stays within a section and is never copied from a code or table block. Very long headings remain in headingPath; when their repeated prefix would consume too much of the budget, headingPrefixOmitted is true. Empty pages and unchanged pages with Skip unchanged content produce no chunks. JavaScript-only pages still require a rendering crawler.

Keep a knowledge base fresh: change detection

Turn on Detect changes since last run and schedule the Actor. Each page gets changeStatus — new, changed or unchanged — compared with the previous run that used the same start URLs (the state is kept in a key-value store in your own account). With Leave content empty for unchanged pages on, unchanged rows carry no Markdown, so you only re-embed what changed. Every crawled page still counts as one result.

Using Website to Markdown Crawler with AI agents, LangChain and LlamaIndex

Website to Markdown Crawler runs on pay-per-event pricing with limited permissions, so it's callable through the Apify MCP server directly from an AI agent — pass startUrls and maxPages and get back one Markdown row per page.

For AI agents: pass url. {"url": "https://crawlee.dev/js/docs/quick-start"} fetches just that one page — no sitemap, no link following, one row, one result billed — so the answer is ready inside the MCP call-actor wait (at most 45 s). In a cloud test on 9 October 2026 that page (1,484 words) came back as 17,649 characters of Markdown and the run took about 4 seconds from container start to finish. url overrides startUrls and maxPages; use startUrls to crawl a site. If the page cannot be fetched, the run's status message says why and nothing is billed for it. The dataset also drops straight into a RAG pipeline: use Apify's LangChain or LlamaIndex ApifyDatasetLoader to turn the dataset into Document objects, then chunk and embed into Pinecone, Qdrant, Weaviate or pgvector. It also connects through n8n, Make and Zapier via Apify's standard integrations.

Timeouts and delivery state. Confirmed pages are saved as they are converted. The crawler stops taking new pages near the deadline. Read the OUTPUT record for resultRows, failedPages, partial, stoppedForTime, chargeLimitReached, and deliveryUnconfirmed; counters cover this process attempt. If a dataset write loses its acknowledgement or is still in flight at the hard stop, the run fails with unconfirmed delivery. The application does not repeat that write; inspect the dataset before manually retrying. This is not an exactly-once guarantee across SDK retries, migrations, or new runs.

Sizing a run. A typical site crawls at 2–10 pages per second (in a 60-second local test, 282 docs.apify.com pages at maxConcurrency 3), after a few seconds of start-up and sitemap reading: maxPages 100 fits a 60-second timeout on most sites; for thousands of pages give the run several minutes. maxTotalChargeUsd caps the cost — the Actor lowers maxPages to what the budget covers ($1 per 1,000 pages, so $0.05 = 50 pages) and says so in the status message.

Source failures and partial runs. The crawler stops after maxConsecutiveFailures consecutive failed pages. If every attempted source fails, the run is FAILED with zero result rows and no dataset-result events. Successful partial output remains available with OUTPUT.partial=true; failed sources are in ERRORS. Link-discovery errors after a confirmed write are recorded separately in DISCOVERY_ERRORS and do not repeat the delivered row. Startup fees and platform usage may still apply. A zero-result charging allowance is reported as NO_RESULT_BUDGET, not a source failure. Valid empty HTML and change-detection rows retain their existing output behavior.

Why did a page fail? Every failed page gets a fixed reason code, both in ERRORS (next to the raw error message and statusCode) and in OUTPUT.failedPageDetails ({ url, reason, statusCode }, first 100 pages). OUTPUT.failureReasons counts them, e.g. { "blocked": 3, "timeout": 1 }, and a run in which every page failed names the counts in its status message. OUTPUT.failedPages stays the total number of failed pages. Failed pages are never charged.

reasonMeaningWhat to try
blockedThe site refused the crawler: HTTP 401/403/429 or a bot-protection pageTurn on a proxy (residential for strict sites), lower maxConcurrency
http-statusAny other HTTP 4xx/5xx answer, e.g. 404 or 503Check the URL; for 5xx retry later
timeoutThe page did not load in timeLower maxConcurrency, retry, or use a proxy closer to the site
networkDNS, connection, TLS certificate or redirect errorCheck the domain spelling and that the site is up
non-htmlThe URL is not an HTML page (PDF, image, JSON …)Exclude it with excludePathPatterns
robotsA fetch error that names robots.txt (pages robots.txt disallows are normally skipped before fetching, not failed)Only if you are allowed to: set respectRobots to false
unknownAnything else; the raw message is in ERRORS[].errorOpen an issue with the run link

A page that loads but has no content in its HTML (a JavaScript-only app shell) is not a failure: it is saved as a normal row with an empty markdown — see Limitations.

Limitations

  • JavaScript-rendered single-page apps are the main limitation. This Actor fetches raw HTML over HTTP and never executes page JavaScript, so a site that renders its content entirely client-side (no content in the initial HTML) will come back with an empty or near-empty row. It does follow <meta http-equiv="refresh"> redirect stubs (one hop) and ordinary HTTP redirects, which covers a common class of "empty landing page" issue, but not full client-side rendering. If you hit this, look for a browser-based crawler instead.
  • Interactive widgets that swap content via JavaScript (tabs, accordions with lazy content) are captured in whatever state they render in the raw HTML — usually just the first/default tab.
  • Short run timeouts end cleanly. If the run timeout is reached before maxPages, the crawler stops shortly before the deadline and the run finishes as SUCCEEDED with every page crawled so far (you pay only for those). Raise the timeout or lower maxPages for a full crawl.
  • The main-content heuristic (no @mozilla/readability) is tuned for documentation and blog layouts (article, main, #content, .content); unusual layouts may need removeSelectors to clean up.

Need bulk volume or a custom scraper?

Need a fixed monthly price, a large recurring run, extra output fields, or a scraper for a site this Actor does not cover? Open an issue on this Actor's Issues tab and include: the target site or URL pattern, the expected volume per run and how often you run it, and the output fields you need. We reply there.

FAQ

Is this legal? The Actor reads only public HTML. You're responsible for crawling sites you're allowed to and respecting their terms of service.

Why is a row empty? Almost always a JavaScript-rendered page — see Limitations above. Check the statusCode field (failed pages are in the ERRORS record with a reason code); a 200 with an empty markdown usually means client-side rendering.

How do I stay inside one section of a site? Set includePathPrefixes, e.g. ["/docs"], and/or turn off useSitemap if the sitemap covers more than you want.

How do I control cost? Set maxPages; the Actor never crawls or bills past it. On the platform, also set Maximum cost per run. maxPagesPerDomain caps any one domain, and maxConsecutiveFailures (default 20) stops a run whose pages keep failing.

How do I get one page fast from an AI agent? Send {"url": "https://…"} — single-page mode skips the sitemap and link following and returns one row in seconds.

Can I detect changed pages between runs? Yes — compare contentHash (SHA-1 of the extracted text) across runs to see which pages changed.

Does this work with n8n, Make or Zapier? Yes, through Apify's standard integrations, and through LangChain/LlamaIndex document loaders for RAG pipelines.

Part of the webdatatools web-intelligence suite — every Actor is pay-per-event, reads public data without a login, and returns one clean row per entity:

Browse the whole suite at webdatatools, or call ten of these Actors straight from Claude, Cursor or Cline with the webdatatools MCP server.

Website & domain intelligence

Content for AI, LLMs and RAG

Search, video and social

Leads, jobs and company data

Developer, app and research data

Support and feedback

Markdown tables retain captions, hyperlinks and inline code. Valid rowspan and colspan cells are expanded into aligned cells by repeating their value. Nested tables, malformed spans and spans larger than 100 cells are retained as HTML because a GFM pipe table cannot safely represent them. Code blocks use fences longer than literal backticks in their content; RAG block parsing respects the matching fence length so code examples are not mistaken for document headings. This preserves static source content; it does not add browser rendering or PDF extraction.

Found a bug or want a feature? Open an issue on the Issues tab.

URL deduplication normalizes the host and removes fragments while preserving case-sensitive paths and query values. /Docs and /docs stay separate in start URLs, discovered links, and sitemaps. Every supplied domain participates in the crawl scope; an unrelated third domain is excluded when sameDomainOnly is enabled.