MarkItDown comes in two variants: as a Python library to install and as a browser tool at markitdown.de. Both use the same conversion code, but when is each one worth it? This question depends less on technical skills than on the specific use case. This guide helps you decide honestly.
The two variants at a glance
Browser variant (markitdown.de). You open the website, drop a file in, copy the Markdown out. No installation, no configuration. The conversion runs completely local in your browser via WebAssembly, your data never leaves the machine.
Python library (markitdown via pip). You install the library with pip install markitdown and use it in your own scripts or as a command-line tool. Fully scriptable, automatable, integrable into workflows. Requires Python basics.
Both variants produce identical Markdown because they use the same conversion logic. The difference lies in convenience, scaling, and integration.
When the browser is enough
For the vast majority of use cases, the browser variant is the better choice. Specifically in these situations:
One-off or occasional conversions. You have to turn a PDF into Markdown every few days to send to Claude or ChatGPT. Open browser, drop file, done.
You are not a developer. If pip install is already too much for you, the browser is the only sensible variant. No setup, no dependencies.
You work with sensitive data and want security. The browser variant runs completely local, no file leaves your machine. This is verifiable in the browser network tab. Some think local Python is safer, but browser WebAssembly offers the same guarantee without setup.
You switch devices frequently. The browser variant works on every machine, every tablet, every OS. You don't have to install Python every time.
You don't need automation. As long as you convert every file manually, the browser is faster than any script. Open task, drag file, copy, close browser. 30 seconds.
If you convert five or fewer files per week, the browser variant is the right choice in 90 percent of cases. The setup effort for Python only pays off once you regularly hit double-digit conversions per week.
When Python is worth it
There are clear cases where the Python library is the significantly better choice:
Bulk conversions. You have a folder with 200 PDFs that all need to become Markdown. In the browser you would have to do each one individually. With Python it's a 10-line script.
Automated workflows. A new file lands in a watch folder, should be automatically converted and fed into a knowledge base. This only works scriptable.
Integration into your own tools. You build a web app that should convert user uploads. Or a Slack bot that automatically summarizes attached PDFs. Library instead of UI.
Pre-processing for RAG pipelines. You build a Retrieval-Augmented-Generation system and need conversion as a step between upload and vector embedding. Python integrates seamlessly into LangChain, LlamaIndex, or your own pipelines.
CI/CD integration. Documentation is automatically generated from Office sources on every commit. The browser tool doesn't work there, Python does.
Specific configuration. You need your own pre- or post-processing steps, your own plugins, your own output adjustments. The library is extensible, the browser is not.
Practical code examples
Two minimal examples so you get an idea of the Python setup.
Example one: one-off conversion of a single file
from markitdown import MarkItDown
md = MarkItDown()
result = md.convert("document.pdf")
print(result.text_content)
Four lines of code, done. Output is Markdown text as a string that you can save or process further.
Example two: batch conversion of an entire folder
from markitdown import MarkItDown
from pathlib import Path
md = MarkItDown()
input_dir = Path("documents")
output_dir = Path("markdown")
output_dir.mkdir(exist_ok=True)
for file in input_dir.iterdir():
if file.suffix.lower() in [".pdf", ".docx", ".xlsx", ".pptx"]:
result = md.convert(str(file))
output_file = output_dir / (file.stem + ".md")
output_file.write_text(result.text_content)
print(f"Converted: {file.name}")
With this script you convert an entire folder in under ten seconds, assuming the files are not huge. Browser conversion of the same amount would mean several minutes of manual clicks.
The Python library needs Python 3.10 or newer. Installation runs via pip install markitdown. For PDF OCR, you additionally need Tesseract, which you install via your package manager (apt, brew, choco).
Performance comparison from practice
A real example with identical input: an 8 MB PDF with 45 pages, mixed content of text, tables, and a few images.
| Variant | Conversion time | Effort per file |
|---|---|---|
| Browser (markitdown.de) | 4 to 6 seconds | 15 seconds incl. clicks |
| Python local | 3 to 5 seconds | 0 seconds (in script) |
The pure conversion time is similar because both variants use the same library. The difference comes from manual effort per file. For a single file, this doesn't matter. For 50 files, that's 12 minutes of clicking in the browser, 0 minutes in Python.
Decision matrix
Answer these three questions for yourself:
Number of conversions per month:
- 1 to 20: Browser
- 21 to 100: Browser or Python (depends on other points)
- 100+: Python
Technical comfort zone:
- Python is a foreign language: Browser
- Python basics available: Both possible
- Python used daily: Python
Use case:
- Manual, one-off, local task: Browser
- Automation, pipeline, integration: Python
- Occasional conversions on work machine: Browser
If at least two of three answers are "Browser," the browser variant is right. If at least two are "Python," the setup effort is worth it.
Many power users use both in parallel. Browser for quick one-off conversions on the laptop, Python in the backend for automated workflows. They don't exclude each other.
Common misconceptions
Misconception one, "Python is always faster than browser." For a single file, both are similarly fast. Python only becomes truly superior at batch operations.
Misconception two, "In the browser my data gets uploaded." Wrong at markitdown.de. The conversion runs completely local via WebAssembly. You can verify this in the browser network tab, where there are no upload requests during conversion.
Misconception three, "Python supports more formats than browser." No, both variants support the same formats because they use the same library. PDF, DOCX, XLSX, PPTX, images, HTML, and more work identically in both.
Misconception four, "Browser variant is only for beginners." Experienced developers also use the browser for quick ad-hoc conversions. Opening a tab is often faster than opening a terminal and triggering a script.
When both complement each other
A typical hybrid setup from practice:
In daily work, you use the browser variant for everything that comes up spontaneously. A PDF that a colleague sent. An Excel sheet from a meeting. Quick conversion, done.
In parallel, you have the Python library integrated in the backend of your main project (for example a RAG system for a knowledge database). As soon as a user uploads a document, it gets converted server-side and fed into the vector store.
Both worlds benefit from each other because the conversion logic is identical and you don't get inconsistencies.
Conclusion
The browser variant is the right choice for 80 percent of LLM users because it works without setup and is ideal for occasional conversions. Python is worth it as soon as you regularly automate, integrate, or want to script. Both variants are free, both use the same Microsoft library, both produce identical Markdown. The choice depends only on your workflow, not on quality.
If you're just starting and unsure: start with the browser tool. If after three weeks you notice you convert daily, switching to Python is worth it.
Read more
- Use MarkItDown directly for instant browser conversion
- What is Markdown?, for the basics
- MarkItDown vs Pandoc vs Markdownify, if you're considering other tools
- Feeding Claude Projects with documents, for the next step after conversion