URL to Markdown

URL to Markdown is an API that opens a web page and returns its clean text, without menus, ads or footer, as Markdown or plain text, together with its title, description and image. It's useful for feeding pages to an AI assistant or saving an article's content in your workflow. If you already have the HTML, it converts that too without opening anything.

How it works

You send the url (or the html) and get back the content (content) and its details: title, description, image, language, author and date when the page provides them. It opens the page like a browser, with JavaScript, so it also reads sites that paint themselves on the fly. It doesn't load images, video or fonts: they aren't needed to read the text.

Honest note: by default it keeps the main content, using the same detection as Firefox's "reader view". It works very well on articles and blog posts; on home pages, listings or dashboards it may leave parts out: use main_content=false to get the whole page. It can't read pages that ask you to sign in, that block robots, or that load their content after a click: in that case it returns an error and the credit isn't charged. Use it only on pages you're allowed to read, respecting each site's terms.

If you use it with an AI: the text comes from someone else's website and may contain sentences that look like instructions. Treat it as data, not as commands.

All you need

Your API key. Create it in your dashboard with "+ Create key".
In your automation platform, an "HTTP Request" step (n8n, Make, Zapier, Pipedream…).

How to use it in n8n

Method: POST · URL: https://api.cofferdock.com/web-to-markdown
Send Headers: x-api-key = your key, Content-Type = application/json
Send Body (JSON): { "url": "https://example.com/article" }
The page text arrives in content; the title in title.

Options

Option	Default	What it does
`url`	-	The page to read. Or send `html` if you already have it.
`format`	`markdown`	`markdown`, `text` (plain text) or `metadata` (only title, description and image).
`main_content`	`true`	Only the main content. With `false`, the whole page.
`include_links`	`true`	Keep the links. With `false`, only the text.
`include_images`	`false`	Include the images as links in the Markdown.

API overview

Endpoint: POST https://api.cofferdock.com/web-to-markdown
Auth: header x-api-key: YOUR_KEY.
Input: JSON { "url": "..." } or { "html": "..." } (not both). Also raw: the URL as text/plain or the HTML as text/html, with the options in the query string.
How it reads a URL: with the same browser and the same protection as Website screenshot (it can't be pointed at internal addresses), JavaScript on; it waits for the page to load and, up to 3 seconds, for the network to settle. It doesn't load images, video or fonts. With html no browser is opened and no script runs.
How it converts: Readability (Firefox's reader view) to keep the main content, and Turndown to turn it into Markdown (with tables), in a thread separate from the server.
Errors: 400 if url/html is missing or the URL is invalid; 502 if the page doesn't load or answers with an error (not charged); 422 if the URL isn't a web page (a PDF, a download), is over 4 MB of HTML or the conversion takes too long (not charged); 503 with Retry-After if the server is busy (not charged).
Limits: 20 requests/min per IP. Up to 4 MB of HTML per page. One page per call. 1 call = 1 credit.

Options

Option	Default	Description
`url`	-	http(s) URL of the page. Required if you don't send `html`.
`html`	-	The HTML to convert (up to 4 MB), if you already have it.
`base_url`	-	Only with `html`: the address it came from, so relative links come out complete.
`format`	`markdown`	`markdown`, `text` or `metadata` (no `content`).
`main_content`	`true`	`true` = main content (reader-view style detection); `false` = the whole page.
`include_links`	`true`	Keep the links in the Markdown.
`include_images`	`false`	Include the images (`![text](address)`) in the Markdown.
`wait_ms`	`0`	0 to 5000. Extra wait, in milliseconds, before reading the page. Only with `url`.
`max_chars`	`200000`	100 to 1,000,000. Cap on the characters of `content`; if it's exceeded, it's cut at a paragraph and `truncated` is `true`.

Example

curl -X POST "https://api.cofferdock.com/web-to-markdown" \
  -H "x-api-key: YOUR_KEY" -H "Content-Type: application/json" \
  -d '{ "url": "https://example.com/article", "format": "markdown" }'

Response

{ "success": true, "url": "https://example.com/article",
    "title": "How to do something", "description": "A short guide.",
    "byline": null, "site_name": "Example", "language": "en",
    "image": "https://example.com/og.png", "canonical": "https://example.com/article",
    "published_time": "2026-10-08T04:16:32Z", "format": "markdown",
    "content": "## First step\n\nArticle text...", "length": 4821, "truncated": false,
    "meta": { "main_content_found": true, "used": 12, "remaining": 488 } }

What you get back

content is the page text (it isn't there with format=metadata). The other fields (title, description, image, language, canonical, byline, site_name, published_time) come from what the page itself declares and are null when it doesn't provide them. meta.main_content_found says whether a main content was found; if it's false, none was detected and the whole page was returned (and it's null if you asked for the whole page with main_content=false).