marcellmanfrin · marcellmanfrin · Aug 28, 2026 · Aug 28, 2026 · Aug 28, 2026 · Aug 28, 2026
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -26,9 +26,12 @@ cfb = "0.14.0"
 csv = "1.4.0"
 flate2 = "1"
 encoding_rs = "0.8.35"
+html5ever = "0.39.0"
 log = "0.4"
+mail-parser = { version = "0.11.8", features = ["full_encoding"] }
 pdf-inspector = "1.14.2"
 quick-xml = "0.41.0"
+scraper = { version = "0.27.0", default-features = false }
 zip = { version = "8.6.0", default-features = false, features = ["deflate"] }
 
 [profile.release]

diff --git a/README.md b/README.md
@@ -6,7 +6,7 @@
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![skills.sh](https://skills.sh/b/firecrawl/anydoc)](https://skills.sh/firecrawl/anydoc)
 
-Fast Rust library that converts documents (Word, PowerPoint, Excel, OpenDocument, RTF, EPUB, CSV, and PDF) into clean GitHub-Flavored Markdown. Includes bindings for [Node.js](node/README.md), [Python](python/README.md), and the [browser](wasm/README.md) (WebAssembly).
+Fast Rust library that converts documents (Word, PowerPoint, Excel, OpenDocument, RTF, EPUB, HTML, MHTML, CSV, and PDF) into clean GitHub-Flavored Markdown. Includes bindings for [Node.js](node/README.md), [Python](python/README.md), and the [browser](wasm/README.md) (WebAssembly).
 
 Built by [Firecrawl](https://firecrawl.dev) to turn any office document into LLM-ready Markdown in single-digit milliseconds, with one consistent output no matter which format goes in. It powers [Firecrawl Parse](https://firecrawl.dev/parse), so if you'd rather not run it yourself, the hosted API gives you the same conversion plus our OCR models for the scanned pages anydoc can't read on its own.
 
@@ -150,7 +150,7 @@ Only documents that need OCR leave the machine, and the whole document goes, sin
 - **Full document structure.** Headings with anchors, bold/italic/strikethrough, inline code and code blocks, links and internal cross-references, bulleted/numbered/nested/task lists with the source's own numbering, tables with merged cells and header rows, block quotes, footnotes and endnotes, and speaker notes.
 - **Equations as LaTeX.** Word and PowerPoint (OMML), OpenDocument and EPUB (MathML), and RTF equations convert to GitHub-flavored math: `$...$` inline and `$$` blocks.
 - **Embedded assets.** Images and embedded objects render as their alt text in the Markdown, and the raw bytes stay available on the document model, tagged with their media type. Images with an external URL become ordinary Markdown images.
-- **Content-based format detection.** The format is read from the bytes themselves (PDF header, RTF open group, OLE stream names, ZIP package mimetype), so mislabeled files still convert correctly.
+- **Content-based format detection.** The format is read from the bytes themselves (PDF header, RTF open group, OLE stream names, ZIP package mimetype, HTML5 doctype or `<html>` marker, MHTML archives carrying archive-specific evidence such as `Snapshot-Content-Location`), so mislabeled files still convert correctly.
 - **Fast.** Pure Rust, no ML models, no external services. Median conversion time is under 5ms per document.
 - **Bindings that stay out of the way.** Node.js conversion runs on the libuv thread pool and never blocks the event loop; Python releases the GIL so other threads keep running. TypeScript types and Python stubs ship with the packages.
 - **PDF support built in.** Text-based PDFs convert locally through [pdf-inspector](https://github.com/firecrawl/pdf-inspector), no OCR service required. Scanned pages can opt into [hosted OCR](#scanned-pdfs-ocr).
@@ -166,6 +166,8 @@ Only documents that need OCR leave the machine, and the whole document goes, sin
 | OpenDocument     | `.odt`, `.ods`, `.odp`                                     |
 | Rich Text Format | `.rtf`                                                     |
 | EPUB             | `.epub`                                                    |
+| HTML             | `.html`, `.htm`                                             |
+| MHTML            | `.mhtml`, `.mht`                                           |
 | CSV              | `.csv`                                                     |
 | PDF              | `.pdf`                                                     |
 

diff --git a/node/cli.js b/node/cli.js
@@ -3,7 +3,7 @@
 
 const { readFile, writeFile } = require('node:fs/promises')
 
-const FORMATS = 'doc, docx, odt, pdf, ppt, pptx, rtf, epub, xlsx, ods, odp, csv'
+const FORMATS = 'doc, docx, odt, pdf, ppt, pptx, rtf, epub, html, mhtml, xlsx, ods, odp, csv'
 
 const HELP = `anydoc: convert documents to GitHub-Flavored Markdown
 

diff --git a/node/html.test.mjs b/node/html.test.mjs
@@ -0,0 +1,10 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { formatFromBytes, formatFromExtension, toMarkdownBytes } from './index.js'
+
+test('standalone HTML is exposed through the Node binding', async () => {
+  const input = Buffer.from('<!doctype html><h1>Hello</h1><p><b>world</b></p>')
+  assert.equal(formatFromExtension('html'), 'html')
+  assert.equal(formatFromBytes(input), 'html')
+  assert.equal(await toMarkdownBytes(input), '# Hello\n\n**world**\n')
+})
diff --git a/node/index.d.ts b/node/index.d.ts
@@ -128,6 +128,8 @@ export declare const enum Format {
   pptx = 'pptx',
   rtf = 'rtf',
   epub = 'epub',
+  html = 'html',
+  mhtml = 'mhtml',
   xlsx = 'xlsx',
   ods = 'ods',
   odp = 'odp',
@@ -136,9 +138,10 @@ export declare const enum Format {
 
 /**
  * Detect the format from the content itself: the signature and identity each
- * container specification designates (PDF header, RTF open group, OLE stream
- * names, ZIP package mimetype/content types). Plain-text formats (CSV) carry
- * no signature and return `null`; so does anything unrecognized.
+ * container specification designates (PDF header, RTF open group, MIME HTML
+ * aggregate, OLE stream names, ZIP package mimetype/content types).
+ * Plain-text formats (CSV) carry no signature and return `null`; so does
+ * anything unrecognized.
  */
 export declare function formatFromBytes(bytes: Uint8Array): Format | null
 

diff --git a/node/mhtml.test.mjs b/node/mhtml.test.mjs
@@ -0,0 +1,18 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { formatFromBytes, formatFromExtension, toMarkdownBytes } from './index.js'
+
+const input = Buffer.from(
+  'Snapshot-Content-Location: https://example.test/page\r\n' +
+  'MIME-Version: 1.0\r\n' +
+  'Content-Type: multipart/related; type="text/html"; boundary="b"\r\n\r\n' +
+  '--b\r\nContent-Type: text/html\r\n\r\n' +
+  '<!doctype html><h1>Hello MHTML</h1>\r\n--b--\r\n'
+)
+
+test('MHTML is exposed through the Node binding', async () => {
+  assert.equal(formatFromExtension('mhtml'), 'mhtml')
+  assert.equal(formatFromExtension('mht'), 'mhtml')
+  assert.equal(formatFromBytes(input), 'mhtml')
+  assert.equal(await toMarkdownBytes(input), '# Hello MHTML\n')
+})
diff --git a/node/src/lib.rs b/node/src/lib.rs
@@ -26,6 +26,8 @@ pub enum Format {
     pptx,
     rtf,
     epub,
+    html,
+    mhtml,
     xlsx,
     ods,
     odp,
@@ -43,6 +45,8 @@ impl From<Format> for anydoc::Format {
             Format::pptx => anydoc::Format::Pptx,
             Format::rtf => anydoc::Format::Rtf,
             Format::epub => anydoc::Format::Epub,
+            Format::html => anydoc::Format::Html,
+            Format::mhtml => anydoc::Format::Mhtml,
             Format::xlsx => anydoc::Format::Excel,
             Format::ods => anydoc::Format::Ods,
             Format::odp => anydoc::Format::Odp,
@@ -62,6 +66,8 @@ impl From<anydoc::Format> for Format {
             anydoc::Format::Pptx => Format::pptx,
             anydoc::Format::Rtf => Format::rtf,
             anydoc::Format::Epub => Format::epub,
+            anydoc::Format::Html => Format::html,
+            anydoc::Format::Mhtml => Format::mhtml,
             anydoc::Format::Excel => Format::xlsx,
             anydoc::Format::Ods => Format::ods,
             anydoc::Format::Odp => Format::odp,
@@ -71,9 +77,10 @@ impl From<anydoc::Format> for Format {
 }
 
 /// Detect the format from the content itself: the signature and identity each
-/// container specification designates (PDF header, RTF open group, OLE stream
-/// names, ZIP package mimetype/content types). Plain-text formats (CSV) carry
-/// no signature and return `null`; so does anything unrecognized.
+/// container specification designates (PDF header, RTF open group, MIME HTML
+/// aggregate, OLE stream names, ZIP package mimetype/content types).
+/// Plain-text formats (CSV) carry no signature and return `null`; so does
+/// anything unrecognized.
 #[napi]
 pub fn format_from_bytes(bytes: Uint8Array) -> Option<Format> {
     anydoc::Format::from_bytes(&bytes).map(Format::from)

diff --git a/python/anydoc/__init__.py b/python/anydoc/__init__.py
@@ -39,7 +39,8 @@
 from anydoc._anydoc import to_markdown_bytes as _to_markdown_bytes
 
 Format = Literal[
-    "doc", "docx", "odt", "pdf", "ppt", "pptx", "rtf", "epub", "xlsx", "ods", "odp", "csv"
+    "doc", "docx", "odt", "pdf", "ppt", "pptx", "rtf", "epub", "html", "mhtml", "xlsx", "ods",
+    "odp", "csv"
 ]
 """Input format, named after the extension that identifies it. Container
 variants that share a parser (`.docm`, `.xlsm`, `.ppsx`, ...) map onto these

diff --git a/python/anydoc/_anydoc.pyi b/python/anydoc/_anydoc.pyi
@@ -4,7 +4,7 @@ import os
 from typing import Literal, final
 
 Format = Literal[
-    "doc", "docx", "odt", "pdf", "ppt", "pptx", "rtf", "epub", "xlsx", "ods", "odp", "csv"
+    "doc", "docx", "odt", "pdf", "ppt", "pptx", "rtf", "epub", "html", "mhtml", "xlsx", "ods", "odp", "csv"
 ]
 
 class ConvertError(Exception):
@@ -50,10 +50,12 @@ class MissingPartError(ConvertError):
 
 def format_from_bytes(data: bytes | bytearray) -> Format | None:
     """Detect the format from the content itself: the signature and identity
-    each container specification designates (PDF header, RTF open group, OLE
-    stream names, ZIP package mimetype/content types). Plain-text formats
-    (CSV) carry no signature and return `None`; so does anything
-    unrecognized."""
+    each container specification designates (PDF header, RTF open group, an
+    HTML5 doctype or `<html>` marker, a MIME HTML aggregate carrying
+    archive-specific evidence such as Snapshot-Content-Location, OLE stream
+    names, ZIP package mimetype/content types).
+    Plain-text formats (CSV) carry no signature and return `None`; so does
+    anything unrecognized."""
 
 def format_from_extension(extension: str) -> Format | None:
     """The format an extension names, with or without a leading dot."""

diff --git a/python/src/lib.rs b/python/src/lib.rs
@@ -67,7 +67,7 @@ create_exception!(
 /// Format names, as the extension that identifies each format. Container
 /// variants that share a parser (`.docm`, `.xlsm`, `.ppsx`, ...) map onto
 /// these via `format_from_bytes` or `format_from_extension`.
-const FORMATS: [(&str, anydoc::Format); 12] = [
+const FORMATS: [(&str, anydoc::Format); 14] = [
     ("doc", anydoc::Format::Doc),
     ("docx", anydoc::Format::Docx),
     ("odt", anydoc::Format::Odt),
@@ -76,6 +76,8 @@ const FORMATS: [(&str, anydoc::Format); 12] = [
     ("pptx", anydoc::Format::Pptx),
     ("rtf", anydoc::Format::Rtf),
     ("epub", anydoc::Format::Epub),
+    ("html", anydoc::Format::Html),
+    ("mhtml", anydoc::Format::Mhtml),
     ("xlsx", anydoc::Format::Excel),
     ("ods", anydoc::Format::Ods),
     ("odp", anydoc::Format::Odp),
@@ -139,9 +141,10 @@ fn convert_error(py: Python<'_>, error: anydoc::ConvertError) -> PyErr {
 }
 
 /// Detect the format from the content itself: the signature and identity each
-/// container specification designates (PDF header, RTF open group, OLE stream
-/// names, ZIP package mimetype/content types). Plain-text formats (CSV) carry
-/// no signature and return `None`; so does anything unrecognized.
+/// container specification designates (PDF header, RTF open group, MIME HTML
+/// aggregate, OLE stream names, ZIP package mimetype/content types).
+/// Plain-text formats (CSV) carry no signature and return `None`; so does
+/// anything unrecognized.
 #[pyfunction]
 fn format_from_bytes(data: Vec<u8>) -> Option<&'static str> {
     anydoc::Format::from_bytes(&data).map(format_name)

diff --git a/python/tests/test_html.py b/python/tests/test_html.py
@@ -0,0 +1,15 @@
+import unittest
+
+import anydoc
+
+
+class HtmlBindingTests(unittest.TestCase):
+    def test_standalone_html_is_exposed(self):
+        data = b'<!doctype html><h1>Hello</h1><p><b>world</b></p>'
+        self.assertEqual(anydoc.format_from_extension('html'), 'html')
+        self.assertEqual(anydoc.format_from_bytes(data), 'html')
+        self.assertEqual(anydoc.to_markdown_bytes(data), '# Hello\n\n**world**\n')
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/python/tests/test_mhtml.py b/python/tests/test_mhtml.py
@@ -0,0 +1,84 @@
+import unittest
+import anydoc
+
+INPUT = (
+    b'Snapshot-Content-Location: https://example.test/page\r\n'
+    b'MIME-Version: 1.0\r\n'
+    b'Content-Type: multipart/related; type="text/html"; boundary="b"\r\n\r\n'
+    b'--b\r\nContent-Type: text/html\r\n\r\n'
+    b'<!doctype html><h1>Hello MHTML</h1>\r\n--b--\r\n'
+)
+
+
+class MhtmlTests(unittest.TestCase):
+    def test_mhtml_binding(self):
+        self.assertEqual(anydoc.format_from_extension('mhtml'), 'mhtml')
+        self.assertEqual(anydoc.format_from_extension('mht'), 'mhtml')
+        self.assertEqual(anydoc.format_from_bytes(INPUT), 'mhtml')
+        self.assertEqual(anydoc.to_markdown_bytes(INPUT), '# Hello MHTML\n')
+
+
+def nested_multipart(levels):
+    out = bytearray(
+        b'Snapshot-Content-Location: https://example.test/page\r\n'
+        b'MIME-Version: 1.0\r\n'
+        b'Content-Type: multipart/related; boundary="b0"\r\n\r\n'
+    )
+    for level in range(levels):
+        out += (
+            b'--b' + str(level).encode() + b'\r\n'
+            b'Content-Type: multipart/mixed; boundary="b' + str(level + 1).encode() + b'"\r\n\r\n'
+        )
+    out += (
+        b'--b' + str(levels).encode() + b'\r\nContent-Type: text/html\r\n\r\n<p>deep</p>\r\n'
+        b'--b' + str(levels).encode() + b'--\r\n'
+    )
+    for level in range(levels - 1, -1, -1):
+        out += b'--b' + str(level).encode() + b'--\r\n'
+    return bytes(out)
+
+
+class MhtmlBehaviorTests(unittest.TestCase):
+    def test_excessive_multipart_nesting_is_rejected(self):
+        with self.assertRaises(anydoc.ResourceLimitError):
+            anydoc.to_markdown_bytes(nested_multipart(300))
+
+    def test_cid_image_resolves_to_embedded_asset(self):
+        mhtml = (
+            b'Snapshot-Content-Location: https://example.test/page\r\n'
+            b'MIME-Version: 1.0\r\n'
+            b'Content-Type: multipart/related; boundary="b"\r\n\r\n'
+            b'--b\r\nContent-Type: text/html; charset=utf-8\r\n\r\n'
+            b'<!doctype html><p><img alt="logo" src="cid:logo@example.test"></p>\r\n'
+            b'--b\r\nContent-Type: image/png\r\nContent-ID: <logo@example.test>\r\n\r\n'
+            b'PNGDATA\r\n--b--\r\n'
+        )
+        # The cid reference resolves to the embedded part's asset...
+        document = anydoc.to_document(mhtml)
+        self.assertEqual(len(document.assets), 1)
+        self.assertEqual(document.assets[0].media_type, 'image/png')
+        # The Markdown renders an embedded asset as its alt text (bytes stay
+        # in Document.assets); the structural asserts above are the real
+        # resolution check.
+
+    def test_relative_base_href_resolves_embedded_resources(self):
+        mhtml = (
+            b'Snapshot-Content-Location: https://example.test/page\r\n'
+            b'MIME-Version: 1.0\r\n'
+            b'Content-Type: multipart/related; boundary="b"\r\n\r\n'
+            b'--b\r\nContent-Type: text/html; charset=utf-8\r\n\r\n'
+            b'<!doctype html><base href="subdir/"><p><img alt="logo" src="./logo.png"></p>\r\n'
+            b'--b\r\nContent-Type: image/png\r\nContent-Location: logo.png\r\n\r\n'
+            b'PNGDATA\r\n--b--\r\n'
+        )
+        # The ./ dot segment only collapses through the relative base join,
+        # so the asset resolves only if the base href is honored...
+        document = anydoc.to_document(mhtml)
+        self.assertEqual(len(document.assets), 1)
+        self.assertEqual(document.assets[0].media_type, 'image/png')
+        # Markdown alt rendering is covered by the renderer tests; the
+        # structural asserts above are the resolution check.
+
+
+if __name__ == '__main__':
+    unittest.main()