Markdown to HTML Converter
Two-way Markdown ↔ HTML conversion in your browser. Render Markdown to clean semantic HTML or strip HTML down to portable Markdown — instantly, privately, and offline-capable.
Markdown ↔ HTML Converter
Paste Markdown on the left and the converter writes clean, semantic HTML on the right. Flip the switch to go the other way — paste HTML, get tidy Markdown back.
Highlights
- Headings, paragraphs, lists, links, images, and tables — all supported.
- GitHub-Flavored extensions: fenced code blocks, task lists, strikethrough, and tables.
- Everything runs in your browser. Your text never touches a server.
Code
Inline code and fenced blocks both round-trip cleanly:
const greet = (name) => `Hello, ${name}!`;
greet('world');Lists & Tasks
- Ordered items keep their numbers.
- Sub-items indent two spaces.
- Nested bullet
- Another nested bullet
- Done task
- Open task
A table
| Feature | Markdown | HTML | |---|:-:|:-:| | Bold | **bold** | <strong> | | Italic | *italic* | <em> | | Link | [text](url) | <a href> |
Blockquotes look like this. They can span multiple lines.
Conversion happens in your browser — your text, code, and links are never transmitted to any server.
How It Works
Paste your source
Drop Markdown or HTML into the input pane. Bytes stay in browser memory — no upload, no API call, no server log.
Tokenize locally
For Markdown the page runs a hand-written CommonMark + GFM tokenizer; for HTML it feeds the string into the browser native DOMParser API.
Render or emit
Headings, lists, tables, code fences, blockquotes, links, and images map across in both directions with alignment, language hints, and task-list state preserved.
Copy or save
Grab the result from the right pane. Full-document mode wraps HTML in a complete <!DOCTYPE html> shell suitable for saving as a standalone .html file.
How to Use the Markdown ↔ HTML Converter
- Pick a direction — Markdown → HTML or HTML → Markdown. Click Swap any time to flip directions and feed the current output back as the input.
- Paste your source into the left pane. The right pane updates instantly with the conversion result — a rendered preview when going to HTML, the raw Markdown when going the other way.
- Toggle the right options for your output: GitHub-Flavored Markdown (tables, task lists, strikethrough), linkify bare URLs, and full HTML document for MD → HTML; bullet marker, code fence, and preserve hard breaks for HTML → MD.
- Click Copy to send the output to your clipboard, or switch the preview to HTML source to view the underlying tags and copy the raw string.
What the Converter Supports
The tool implements CommonMark with the most common GitHub-Flavored Markdown extensions. Every block-level and inline element listed below round-trips between the two formats cleanly:
| Element | Markdown | HTML |
|---|---|---|
| Heading (levels 1–6) | # to ###### | <h1>–<h6> |
| Paragraph | Plain text separated by blank lines | <p> |
| Bold | **bold** or __bold__ | <strong> |
| Italic | *italic* or _italic_ | <em> |
| Strikethrough (GFM) | ~~struck~~ | <del> |
| Inline code | `code` | <code> |
| Fenced code (GFM) | ``` with optional language | <pre><code class="language-…"> |
| Blockquote | > text | <blockquote> |
| Unordered list | - item, * item, + item | <ul><li> |
| Ordered list | 1. item | <ol><li> |
| Task list (GFM) | - [x] done | <input type="checkbox" checked> |
| Table (GFM) | Pipe-delimited with alignment row | <table> with style="text-align" |
| Link | [label](url "title") | <a href> |
| Image |  | <img src alt> |
| Horizontal rule | --- | <hr /> |
Why Convert Markdown to HTML?
Markdown is the default authoring format for GitHub READMEs, Jekyll and Hugo static sites, Reddit and Stack Exchange posts, Notion and Obsidian notes, and most modern documentation toolchains. HTML, in turn, is what every browser actually renders. Going from one to the other lets you draft in a portable plain-text format that survives platform migrations and then paste the rendered output into a WordPress block editor, an email client that accepts HTML, or any CMS rich-text field. Going back the other way is useful for migrating content out of a legacy CMS, cleaning AI-generated HTML before committing it to a documentation site, or pulling a snippet out of a web page for archiving in a Markdown-based personal knowledge base.
Markdown vs. HTML — Same Content, Two Formats
| Feature | Markdown | HTML |
|---|---|---|
| Source readability | High — reads as plain text | Low — angle-bracket noise |
| Expressive ceiling | Block-level + basic inline | Anything the web supports |
| Diff-friendly | Excellent — line-based | Poor — indentation churn |
| Renders without conversion? | No — needs a processor | Yes — straight to the browser |
| Round-trip safe | Yes for everything Markdown can express | Lossy back to MD for inline styles, classes, custom elements |
Tips for Clean Conversions
- Keep one blank line between blocks. Markdown uses a blank line to separate paragraphs, lists, code blocks, and headings. Missing blank lines are the most common reason a list collapses into a paragraph.
- Fence code blocks with three backticks and a language tag. ```python or ```ts both produce
class="language-python"on the<code>element, which means highlighting libraries pick up the language automatically. - Use the table alignment row.
:---left-aligns the column,---:right-aligns it,:---:centres it. The converter reads this row and emits matching inlinestyle="text-align:…"on each<th>. - Prefer reference-free links. Inline
[text](url)round-trips cleanly. CommonMark reference-style links ([text][ref]) are not currently inlined back into a single Markdown link. - Strip CMS noise before pasting HTML. If you are pulling HTML out of a WYSIWYG editor, expect inline
style,class, anddata-*attributes to be dropped on the HTML → MD pass. That is intentional — they have no Markdown equivalent.
Privacy & Browser-Native Processing
Both directions of the converter execute entirely on your device. The Markdown → HTML
path uses a self-contained tokenizer bundled into the page; the HTML → Markdown path
uses the DOMParser API that has shipped in every browser since 2015 and
runs inside a sandboxed parser without issuing a network request. There is no
upload step, no opaque "AI cleanup" pass, and no analytics pixel on the textarea.
The page also degrades to a fully offline tool once it has been visited once — the
service worker keeps the JavaScript bundle in cache, so the converter remains usable
on a plane, in a coffee shop with flaky Wi-Fi, or behind a corporate firewall.
Frequently Asked Questions
Does the converter support GitHub-Flavored Markdown?
Yes. With the GFM toggle on (the default), it handles pipe-delimited tables with alignment-row syntax, fenced code blocks with optional language hints, task lists ([x] and [ ]), strikethrough (~~text~~), and bare-URL linkification. Standard CommonMark elements work in both directions regardless of the GFM toggle.
How does the HTML → Markdown direction work?
It feeds the HTML into the browser DOMParser, walks the resulting DOM tree, and emits the matching Markdown for each tag — # for headings, ** for strong, * for em, [text](url) for anchors, pipe tables for <table>, fenced code blocks for <pre><code>, and so on. Script, style, and noscript tags are dropped, and inline styles or classes that have no Markdown equivalent are flattened to their text content.
Is the conversion lossy?
Markdown → HTML → Markdown is lossless for every element Markdown can express. HTML features that Markdown does not represent (inline styles, custom classes, ARIA attributes, <iframe>, <video>, <details>, custom elements) are flattened to their text content on the HTML → Markdown leg.
Can I export the result as a complete HTML document?
Yes. In MD → HTML, toggle "Full HTML document" to wrap the body in <!DOCTYPE html>, <html lang="en">, <head> with UTF-8 charset, and <body>. Save the result as a .html file and open it directly in any browser.
Is my text uploaded anywhere?
No. Markdown → HTML uses a hand-written tokenizer bundled in the page; HTML → Markdown uses the browser native DOMParser. Neither path makes a network request. Your text, code, links, and images are never sent to any server.
Why is the Markdown sometimes different from another converter?
Markdown has multiple dialects (CommonMark, GFM, Markdown Extra). This tool follows CommonMark with GFM extensions behind a toggle. Differences you may see versus other tools include two-space nesting for sub-lists (CommonMark recommendation), trailing two-space hard breaks when "Preserve <br>" is on, and the configurable bullet marker for unordered lists.
Can I convert a README or full document?
Yes. Paste a full README.md (or any sized Markdown document, up to several megabytes) into the input pane — the converter handles it in seconds. The output pane shows both a live rendered preview and the raw HTML source, and Full HTML document mode wraps the output in a standalone .html shell suitable for archiving.
How are code blocks handled?
Markdown fenced code blocks preserve the language hint as a class on the <code> element (```python → <code class="language-python">). On the reverse path, the converter reads class="language-…" off <code> elements and re-emits the matching fence — so Prism, highlight.js, and Shiki all pick up the right language with no extra config.
Privacy & Security