# Website to Markdown Converter (`lofomachines/website-to-markdown-converter`) Actor

Best faster and cheaper way to convert any web page into clean, structured, LLM-ready Markdown.

- **URL**: https://apify.com/lofomachines/website-to-markdown-converter.md
- **Developed by:** [Lofomachines](https://apify.com/lofomachines) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Website to Markdown Converter 🌐➡️📝

**Convert any website or web page into clean, structured, LLM-ready Markdown — fast, reliable, and at scale.** Paste up to 100 URLs and instantly turn live pages into well-formatted **Markdown** you can feed straight into ChatGPT, Claude, Gemini, RAG pipelines, vector databases, knowledge bases, or documentation. No messy HTML, no ads, no boilerplate — just the readable content that matters.

If you've been searching for a **URL to Markdown** tool, a **website to Markdown converter**, or a simple way to **scrape web pages to Markdown for AI**, this actor does exactly that.

---

### What is Website to Markdown Converter?

Website to Markdown Converter is a fast, scalable tool that **converts web pages into clean Markdown**. Give it a list of page URLs and it returns the main content of each page as structured Markdown, complete with the page **title**, **status**, and a per-URL **success/error** flag — so nothing is ever silently dropped.

It's built for **AI and LLM workflows**: the output is optimized to be **LLM-ready**, making it ideal for prompts, embeddings, retrieval-augmented generation (RAG), fine-tuning datasets, and content pipelines.

### What can this actor do?

- 🔗 **URL to Markdown** — convert up to **100 URLs** in a single run
- 🧠 **LLM-ready output** — perfect for ChatGPT, Claude, Gemini, embeddings & RAG
- 🧹 **Clean content extraction** — strips navigation, ads, and clutter
- 🏷️ **Title + content** — every result includes the extracted page title
- ✅ **Success & error tracking** — know exactly which URLs converted and why
- ⚡ **Scalable & reliable** — handles heavy, concurrent usage with automatic retries
- 📤 **Export anywhere** — JSON, CSV, Excel, HTML, or Markdown

### What data does this actor extract?

| Field         | Description                                       |
| ------------- | ------------------------------------------------- |
| `url`         | The page that was converted                       |
| `title`       | Extracted page title                              |
| `markdown`    | The clean Markdown content of the page            |
| `statusCode`  | HTTP status of the conversion                     |
| `success`     | `true` if the page converted successfully         |
| `error`       | Short, human-readable reason if a URL failed      |
| `convertedAt` | ISO timestamp of when the conversion ran          |

---

### How to use Website to Markdown Converter

Converting a website to Markdown takes seconds — no code required:

1. **Add your URLs.** Paste up to 100 page URLs into the *Page URLs* field.
2. **Click Start.** The actor converts each page to clean Markdown.
3. **Get your results.** Open the **Output** tab and switch between the *Overview* and *Markdown* views, or export to **JSON, CSV, Excel, or Markdown**.

> 💡 Tip: Need to collect the URLs first? Use the complementary **[URLs Extractor](https://apify.com/lofomachines/urls-extractor)** actor to pull every link from a site, then feed them into this converter.

---

### Input

| Field  | Type            | Description                                                        |
| ------ | --------------- | ----------------------------------------------------------------- |
| `urls` | array of string | The page URLs to convert. Up to **100** per run. http/https only. |

Example input:

```json
{
  "urls": [
    "https://example.com",
    "https://example.org/blog/post"
  ]
}
````

### Output

Each converted URL produces one dataset item:

```json
{
  "url": "https://example.com",
  "title": "Example Domain",
  "markdown": "## Example Domain\n\nThis domain is for use in examples...",
  "statusCode": 200,
  "success": true,
  "error": null,
  "convertedAt": "2026-06-07T10:00:00.000Z"
}
```

The **Output** tab offers two ready-made views: **Overview** (all fields and status) and a focused **Markdown** view for reading the converted content.

***

### How much does it cost?

This actor is lightweight and runs without a headless browser, so **compute usage is minimal**. Cost scales with the number of URLs you convert and the platform compute units consumed — converting a typical batch of pages costs only a few cents. You only pay for what you run.

***

### Use cases

- **AI & LLM context** — convert web pages to Markdown for prompts, RAG, and fine-tuning
- **Content repurposing** — migrate articles and docs into clean Markdown
- **Knowledge bases & wikis** — import web content as structured Markdown
- **Research & archiving** — capture readable snapshots of pages
- **Documentation pipelines** — automate HTML-to-Markdown conversion at scale

***

### Other actors you may like

- 🔎 **[URLs Extractor](https://apify.com/lofomachines/urls-extractor)** — *complementary actor.* Extract all the URLs from any website, then feed them into **Website to Markdown Converter** to turn them into clean Markdown. Together they form a complete **collect → convert** pipeline.

***

### FAQ

**How do I convert a website to Markdown?**
Paste the page URLs into the input, click **Start**, and download the Markdown from the Output tab. No coding needed.

**How many URLs can I convert at once?**
Up to **100 URLs** per run.

**What export formats are available?**
JSON, CSV, Excel, HTML table, and Markdown — straight from the dataset.

**Is the output good for AI and LLMs?**
Yes. The Markdown is clean and structured specifically to be **LLM-ready**, ideal for ChatGPT, Claude, embeddings, and RAG.

**What happens if a page can't be converted?**
You still get a dataset item with `success: false` and a short reason, so you always know what happened to every URL.

**Does it work at scale with many users?**
Yes. The actor is designed to run reliably under heavy, concurrent usage, with automatic retries and graceful handling of rate limits.

***

### Related searches

website to markdown, url to markdown, web page to markdown, html to markdown, convert website to markdown, scrape website to markdown, markdown converter, LLM-ready markdown, web scraping to markdown, AI content extraction, RAG, ChatGPT, Claude, Gemini.

# Actor input Schema

## `urls` (type: `array`):

List of web page URLs to convert into Markdown. Up to 100 URLs per run. Each URL must start with http:// or https://.

## Actor input object example

```json
{
  "urls": [
    "https://example.com"
  ]
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "urls": [
        "https://example.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lofomachines/website-to-markdown-converter").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "urls": ["https://example.com"] }

# Run the Actor and wait for it to finish
run = client.actor("lofomachines/website-to-markdown-converter").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "urls": [
    "https://example.com"
  ]
}' |
apify call lofomachines/website-to-markdown-converter --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=lofomachines/website-to-markdown-converter",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Website to Markdown Converter",
        "description": "Best faster and cheaper way to convert any web page into clean, structured, LLM-ready Markdown.",
        "version": "0.1",
        "x-build-id": "1qiCqZiBBVtddsAgR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lofomachines~website-to-markdown-converter/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lofomachines-website-to-markdown-converter",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/lofomachines~website-to-markdown-converter/runs": {
            "post": {
                "operationId": "runs-sync-lofomachines-website-to-markdown-converter",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/lofomachines~website-to-markdown-converter/run-sync": {
            "post": {
                "operationId": "run-sync-lofomachines-website-to-markdown-converter",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "Page URLs",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "List of web page URLs to convert into Markdown. Up to 100 URLs per run. Each URL must start with http:// or https://.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```