PrivateMarkdown vs md2rich: Local Markdown Converter Compared 2026

A new competitor entered the client-side format conversion space in late July 2026. PrivateMarkdown advertises support for over 135 file formats — PDF to Markdown, DOCX to Markdown, EPUB to Markdown, and many more — all converted inside your browser with zero server uploads. The natural question for anyone using md2rich is whether PrivateMarkdown overlaps with or complements the existing workflow. This article breaks down where the two tools converge, where they diverge, and which one handles which job for a 2026 publishing pipeline.

The short answer is that they are complementary, not competitive. PrivateMarkdown is a format bridge — it takes 135 source formats and normalizes them to Markdown (or in some cases to HTML). md2rich is a publishing bridge — it takes clean Markdown and produces the platform-specific rich text that LinkedIn, X Articles, Notion, Medium, and Substack all accept on paste. Many of the writers who tested both in July 2026 ended up using them in sequence: PrivateMarkdown first to convert a DOCX brief into Markdown, then md2rich to turn that Markdown into a publishable LinkedIn post.

What PrivateMarkdown offers

PrivateMarkdown (privatemarkdown.com) is a single-page web app that lets you upload a file or paste text, select a target format, and get the converted result. The headline feature is the format count — 135+ input types ranging from common office formats (DOCX, XLSX, PPTX) through technical formats (LaTeX, ASN.1, Graphviz DOT) all the way to niche ones you would not expect in a browser-only tool (PostScript, DXF, WebAssembly Text Format).

The architecture is the interesting part. PrivateMarkdown ships each format converter as a separate WebAssembly module and loads the relevant one only when you select that format pair. A DOCX-to-Markdown conversion loads the DOCX parser, runs the conversion client-side, and discards the WASM module after the result is rendered. There is no server-side conversion engine, no upload endpoint, no background API call. The data stays in your browser tab for the entire session.

This architecture choice has real privacy implications. A server-side converter that accepts file uploads stores those files somewhere — even if the design is ephemeral, the file bytes transit a network path and may be cached or logged. PrivateMarkdown eliminates the transit step entirely. The file you select from your local drive is read by a FileReader on the page, fed into a local WASM parser, and the output is presented in a textarea for you to copy. No HTTP POST ever carries your content.

// PrivateMarkdown architecture (simplified)
// Every conversion runs client-side via WASM

import { detectFormat } from './formats/detect.js';
import { loadWasm } from './wasm/loader.js';

async function convert(file, targetFormat) {
  const sourceFormat = await detectFormat(file);
  const wasmModule = await loadWasm(sourceFormat, targetFormat);
  const bytes = await file.arrayBuffer();
  const result = wasmModule.convert(bytes, targetFormat);
  return result.text;  // no network round-trip
}

Where md2rich specializes

md2rich is narrower by design. It accepts one input format — Markdown — and produces one family of output: the rich text that publishing platforms accept on paste. The reason for the narrow scope is that the conversion output matters more than the format list when your goal is to publish. A Markdown-to-LinkedIn conversion that drops bold formatting on paste is useless even if it handles 135 other format pairs correctly.

md2rich's conversion engine has been tuned against each platform's paste handler. LinkedIn strips <span> tags with inline styles but respects <strong> and <em> if they are direct children of <p>. X Articles collapses nested lists past two levels. Notion converts pasted HTML to native blocks. Medium reinterprets <h2> as a full-width separator. Substack preserves inline <code> but strips classes on <pre> blocks. Each of these behaviors was discovered through iterative testing, and md2rich's output format accounts for them.

PrivateMarkdown does not optimize for platform-specific paste behavior. It produces clean HTML from Markdown, and that HTML will work on most platforms most of the time. But md2rich's output is tuned for the platforms where the edge cases matter — and for a daily publishing workflow, the edge cases are the ones that waste time.

Head-to-head comparison

The combined pipeline

The pattern that emerged in July 2026 among multi-platform writers who tested both tools is a two-step pipeline. It works like this:

1. Step 1 — Inbound. You receive a client brief as a DOCX file, a meeting transcript as a PDF, or an article draft as an EPUB export. Open PrivateMarkdown, drop the file in, and get clean Markdown out minutes later. No upload, no server, no conversion fee.
2. Step 2 — Outbound. Edit the Markdown in your editor of choice (Obsidian, VS Code, iA Writer — all the tools covered in our 2026 editor roundup). When the draft is final, open md2rich, paste the Markdown, and copy the platform-optimized rich text to your clipboard.
3. Step 3 — Publish. Cmd/Ctrl-V into LinkedIn, X Articles, Notion, Medium, or Substack. The format travels intact because the conversion was tuned for that destination platform.

The pipeline is fully client-side. PrivateMarkdown handles the many-to-Markdown step. md2rich handles the Markdown-to-publish step. Nothing touches a server between the source file and the published post.

# Combined pipeline (one real example)

# 1. Source is a DOCX client brief (80KB)
#    PrivateMarkdown: DOCX-to-Markdown → 2.1KB clean .md

# 2. Edit the draft in VS Code (3-4 revision passes)

# 3. Open md2rich.com, paste final Markdown
#    md2rich → platform-tuned rich text

# 4. Cmd+V into LinkedIn post composer
#    Headings render as LinkedIn H2, bullets stay indented,
#    code blocks survive, links are clickable.

Where PrivateMarkdown still lags

PrivateMarkdown's format list is impressive, but the quality of the output varies by format pair. DOCX-to-Markdown handles paragraphs, bold, italic, and headers cleanly. Table support is incomplete — merged cells are flattened into separate cells. Image handling is nonexistent (images in DOCX files are dropped on conversion). Code blocks with syntax highlighting in DOCX are converted to plain Markdown code fences with no language annotation. None of these are deal-breakers for casual use, but they matter when the source document is a formatted technical report.

PDF-to-Markdown is the weaker conversion. PrivateMarkdown uses the same WASM-based PDF parser available in open source, which handles text extraction reliably but loses PDF-native formatting — multi-column layouts are concatenated, inline images are dropped, and table positioning is approximated rather than reconstructed. For a brief that was designed in a WYSIWYG tool, the Markdown output will need manual cleanup.

The format breadth also creates a discoverability problem. With 135+ formats listed, finding the right input-target pair requires scanning a long list. The interface groups formats by category (Document, Data, Markup, Code, etc.), which helps, but users converting an uncommon format like ASN.1 or PostScript will spend more time searching than converting.

Which tool wins when

The decision matrix is straightforward:

• Use PrivateMarkdown when your source is a file in DOCX, PDF, EPUB, or any format that is not Markdown. It is the fastest way to bring external drafts into your Markdown writing environment.
• Use md2rich when you have a finished Markdown draft and need to publish it on LinkedIn, X Articles, Notion, Medium, or Substack with full formatting preservation.
• Use both in sequence when your workflow starts with a client brief in a non-Markdown format and ends with a published social post. This is the most common pattern among the writers who tested both tools in July 2026.

There is no meaningful overlap. PrivateMarkdown brings content into the Markdown ecosystem. md2rich takes it out. The two tools handle opposite ends of the same one-person publishing pipeline, and neither replaces the other.

Privacy architecture compared

Both tools claim zero-upload privacy, but the guarantees are structurally similar. PrivateMarkdown uses a FileReader to read local files into ArrayBuffers, then passes the bytes to a WASM module. md2rich reads Markdown from a textarea or paste event and runs the conversion in plain JavaScript. In both cases, the input data never leaves the browser's memory space.

The practical difference is the file size envelope. PrivateMarkdown handles files up to roughly 50MB (the browser's WASM memory limit for most format converters). md2rich is designed for text inputs rarely exceeding 100KB. If your source document is a 40MB PDF report, PrivateMarkdown is the only client-side option. If your source is a 3,000-word Markdown draft, both tools handle the workload identically.

Neither tool sends telemetry or analytics to external servers. Both are single-page applications that load once and run entirely in the client. The difference in the privacy guarantee is negligible for text-sized inputs.

The 2026 client-side conversion landscape

PrivateMarkdown's launch brings the client-side format conversion category to three real contenders. md2rich covers the publishing-specific outbound conversion. all2md, which we compared earlier, covers the Python/CLI/MCP path for developer workflows. PrivateMarkdown covers the browser-based many-to-Markdown path for non-technical writers. The three tools have different entry points, different format tables, and different output targets — but they share the same core principle: your content stays on your machine.

The broader trend in 2026 is that serverless conversion is becoming the default expectation. Users who would have uploaded a DOCX to a cloud converter in 2024 now search for browser-based alternatives. The WASM ecosystem matured enough in 2025-2026 to make format parsers in the browser practical — PrivateMarkdown is the most aggressive beneficiary of that maturity so far.

For the writer whose workflow is: receive a file → convert to Markdown → edit → publish to social platforms, the logical stack in late July 2026 is PrivateMarkdown + your editor of choice + md2rich. It runs entirely in your browser, requires no accounts, and does not expose your content to a server at any step in the chain.

FAQ