If you've been building LLM-powered applications, you've likely run into the same problem: your data lives in PDFs, Word documents, Excel sheets, and PowerPoint decks — but your AI pipeline expects clean text. Copy-pasting doesn't scale, and most conversion tools either strip too much structure or produce noisy output.
Microsoft's MarkItDown is built specifically for this gap. It's a lightweight Python utility that converts a wide range of file formats into Markdown, preserving the structure that matters: headings, tables, lists, and links.
MarkItDown is a Python library (and CLI tool) that converts files and documents into Markdown. It is not designed for pixel-perfect human-readable output. The explicit goal is to feed text into LLMs and text analysis pipelines — and Markdown is the right format for that because most large language models understand it natively and it is highly token-efficient.
Supported formats include:
That's a broad surface area for one library.
You need Python 3.10 or higher. The simplest way to get everything:
pip install 'markitdown[all]'
The [all]
flag installs all optional dependencies for every supported format. If you want a leaner install, you can pick specific formats:
pip install 'markitdown[pdf,docx,pptx]'
Available optional extras: pdf
, docx
, pptx
, xlsx
, xls
, outlook
, audio-transcription
, youtube-transcription
, az-doc-intel
.
It is recommended to work inside a virtual environment:
python -m venv .venv
source .venv/bin/activate
pip install 'markitdown[all]'
The command-line interface is straightforward:
markitdown report.pdf
markitdown report.pdf -o report.md
cat report.pdf | markitdown
That's it. No configuration required for basic use.
For programmatic use in your pipeline:
from markitdown import MarkItDown
md = MarkItDown(enable_plugins=False)
result = md.convert("financials.xlsx")
print(result.text_content)
The result.text_content
attribute holds the converted Markdown string.
from markitdown import MarkItDown
md = MarkItDown()
result = md.convert("proposal.docx")
result = md.convert("slides.pptx")
result = md.convert("data.csv")
result = md.convert("page.html")
print(result.text_content)
The API is consistent regardless of file type. You call .convert()
and get back a result object.
If you pass an image file (or a PowerPoint with images), MarkItDown can call an LLM to generate descriptions for those images, which then become part of the Markdown output. You supply your own client:
from markitdown import MarkItDown
from openai import OpenAI
client = OpenAI()
md = MarkItDown(llm_client=client, llm_model="gpt-4o")
result = md.convert("diagram.jpg")
print(result.text_content)
This is useful when the actual visual content of an image matters for downstream processing, not just the file metadata.
For PDFs and Office documents that contain images with embedded text (scanned documents, screenshots inside slides), MarkItDown supports a separate OCR plugin:
pip install markitdown-ocr
pip install openai
python
from markitdown import MarkItDown
from openai import OpenAI
md = MarkItDown(
enable_plugins=True,
llm_client=OpenAI(),
llm_model="gpt-4o",
)
result = md.convert("scanned_report.pdf")
print(result.text_content)
The OCR plugin uses the same LLM vision pattern as image descriptions — no separate ML libraries or binaries are required.
For enterprise-grade document parsing (better table extraction, form recognition), MarkItDown integrates with Azure Document Intelligence:
markitdown report.pdf -o report.md -d -e "<your_endpoint>"
python
from markitdown import MarkItDown
md = MarkItDown(docintel_endpoint="<your_endpoint>")
result = md.convert("complex_form.pdf")
print(result.text_content)
This is the right path if you are processing complex financial documents, legal contracts, or forms where structure accuracy is critical.
If you prefer containerized workflows:
docker build -t markitdown:latest .
docker run --rm -i markitdown:latest < your-file.pdf > output.md
MarkItDown supports third-party plugins. They are disabled by default.
markitdown --list-plugins
markitdown --use-plugins path-to-file.pdf
To find community plugins, search GitHub for #markitdown-plugin
.
One thing worth knowing before you integrate this into a server-side application: MarkItDown runs with the privileges of the current process. It can access local files and remote URIs the same way open()
or requests.get()
can.
The recommendation from the project is to avoid passing untrusted input directly to .convert()
. If you only need to convert local files, use convert_local()
. If you need to handle streams, use convert_stream()
. Prefer the narrowest API for your use case.
This is standard advice for any file processing library, but it is worth calling out explicitly if you are building a web-facing feature.
The honest answer: it depends on what you need it for.
MarkItDown is a good fit if:
MarkItDown is not the right tool if:
| Task | Command |
|---|---|
| Install all formats | pip install 'markitdown[all]' |
| Convert via CLI | markitdown file.pdf -o output.md |
| Convert via Python | MarkItDown().convert("file.pdf").text_content |
| Convert with LLM images | Pass llm_client and llm_model to MarkItDown() |
| Enable OCR plugin | |
pip install markitdown-ocr , then enable_plugins=True |
|
| Use Azure Doc Intelligence | Pass docintel_endpoint to MarkItDown() |
| Run via Docker | docker run --rm -i markitdown:latest < file.pdf > output.md |