anydoc

Convert documents to GitHub-Flavored Markdown. A Firecrawl project.

Every format parses into one shared document model and renders through a single GFM serializer. Escaping, tables, anchors, and footnotes behave the same no matter what you feed in.

Supported formats

PDFs are converted with pdf-inspector, which emits Markdown directly without building a document model. to_document rejects them. Use to_markdown_bytes instead. Scanned and image-only PDFs need OCR, which is out of scope: they error as unsupported.

What's parsed

Headings and their anchors, paragraphs, bold, italic, strikethrough and inline code, links (external, relative, and internal cross-references), bulleted, ordered, nested and task lists with the numbering the source assigns them, tables with merged cells and header rows, block quotes, code blocks, footnotes and endnotes, speaker notes, and embedded images and objects.

An embedded image renders as its alt text, because Markdown cannot embed bytes. The bytes stay on the document model, tagged with a media type and the part they came from (Document::assets in Rust, document.assets in Node). Images that carry an external URL render as ordinary Markdown images.

Node

npm install @firecrawl/anydoc

import { toDocument, toMarkdown, toMarkdownBytes } from '@firecrawl/anydoc';

// From a file path:
const fromPath = await toMarkdown('report.docx');

// From bytes, with the format detected from the content:
const fromBytes = await toMarkdownBytes(bytes);

// Or name it, which signature-less formats (CSV) need:
const fromCsv = await toMarkdownBytes(bytes, 'csv');

// Or stop at the document model, which also carries embedded assets:
const document = await toDocument(bytes);

Conversion runs on the libuv thread pool, so it never blocks the event loop. TypeScript types ship with the package.

Python

pip install firecrawl-anydoc

The package installs as firecrawl-anydoc and imports as anydoc.

import anydoc

# From a file path:
markdown = anydoc.to_markdown("report.docx")

# From bytes, with the format detected from the content:
markdown = anydoc.to_markdown_bytes(data)

# Or name it, which signature-less formats (CSV) need:
markdown = anydoc.to_markdown_bytes(data, "csv")

# Or stop at the document model, which also carries embedded assets:
document = anydoc.to_document(data)

Conversion releases the GIL, so other threads keep running. Type stubs ship with the package.

Rust

cargo add anydoc

// From a file path:
let markdown = anydoc::to_markdown("report.docx")?;

// From bytes, with the format detected from the content:
let markdown = anydoc::to_markdown_bytes(&bytes, None)?;

// Or name it, which signature-less formats (CSV) need:
let markdown = anydoc::to_markdown_bytes(&bytes, anydoc::Format::Csv)?;

// Or stop at the document model, which also carries embedded assets:
let document = anydoc::to_document(&bytes, None)?;

A CLI for manual testing ships in examples/, in all three languages:

cargo run --release --example convert -- file.docx [-f csv] [-o out.md] [--assets dir]
node examples/convert.mjs file.docx [-f csv] [-o out.md] [--assets dir]
python examples/convert.py file.docx [-f csv] [-o out.md] [--assets dir]

Format detection

The format is read from the file content, using the marker its specification designates: the PDF header, the RTF open group, OLE stream names, the ZIP package mimetype and content types. CSV has no such marker. Detection returns nothing for it, and the extension or an explicit format names it instead.

formatFromBytes(bytes); // 'docx', or null when nothing matches
formatFromExtension('.pptm'); // 'pptx'
formatFromPath('report.odt'); // 'odt'

anydoc.format_from_bytes(data)  # 'docx', or None when nothing matches
anydoc.format_from_extension(".pptm")  # 'pptx'
anydoc.format_from_path("report.odt")  # 'odt'

anydoc::Format::from_bytes(&bytes); // Option<Format>
anydoc::Format::from_extension("pptm");
anydoc::Format::from_path(Path::new("report.odt"));

Benchmarks

anydoc is measured against six other converters on 100 real-world documents spanning fourteen formats, using the harness in bench/.

Quality is scored by an LLM judge (Claude Sonnet 5). For each document, anydoc's output and one competitor's are shown blind against ground truth: the document's first six pages, rendered by LibreOffice and attached as images. Each output is scored 1 to 5 on completeness, structure, formatting, and cleanliness. Every pair is judged twice with the two outputs swapped, so position bias shows up as disagreement. The numbers above are the mean of those scores as a percentage of the maximum, over 479 verdicts.

score is the mean of a tool's per-format scores over the formats it supports, which keeps a corpus heavy in one format from skewing it. The tradeoff is that each row averages a different set: mammoth's 70 is docx alone, while anydoc's 80 spans all fourteen. The per-format table is the like-for-like comparison.

Speed is one warm conversion per document. anydoc and the Python libraries are timed with process spawn excluded. The CLI tools include it, since that is how they are used.

Measured in one run on a Ryzen 9 9950X3D with 64 GB of DDR5-6400, on Windows 11. The corpus itself is not redistributable and is not in the repo. The harness reads whatever documents are in samples/.

Development

cargo test
cd node && npm install && npm run build && npm test
cd python && pip install maturin && maturin develop && python -m unittest discover -s tests

A committed fixture corpus under tests/fixtures/ is snapshot-tested, tests/robustness.rs mutation-tests every fixture, and fuzz/ carries cargo-fuzz targets per format. A speed and quality benchmark against other converters lives in bench/.

Releases are tagged v<version>, which publishes the crate, the npm package, and the PyPI wheels from .github/workflows/release.yml. The version lives in three places, bumped together for a release:

• Cargo.toml — the crate
• node/package.json — the npm package
• python/Cargo.toml — the wheel (python/pyproject.toml reads it)

License

MIT