Markdown to Plain Text
Paste Markdown content to strip all formatting syntax while preserving readable text.
Last reviewed: April 2026New to this tool? Click here for instructions
How to Use Markdown to Plain Text
To use the Markdown to Plain Text tool, simply paste your Markdown content into the input area. The tool will automatically strip all formatting syntax and preserve the readable text. You can also choose to use the Preserve Structure mode to keep original line breaks and paragraph spacing while removing all Markdown syntax characters.
When to Use a Markdown Stripper
Markdown strippers are most useful when moving content from a Markdown-aware environment to a plain text destination. Common scenarios include email composition, CMS migration, text analysis, and text-to-speech. The tool is also essential for generating plain-text email versions from Markdown source, as RFC 2046 multipart emails require both HTML and plain-text parts.
How it Works
The tool uses a client-side script to strip all Markdown syntax from the input text. It handles CommonMark and common extensions from GitHub Flavored Markdown, including strikethrough, tables, and task list checkboxes. The output is a plain text version of the input, preserving only the visible text and removing all formatting syntax.
Tips, Edge Cases, or Limitations
The tool is designed to handle most common Markdown syntax, but it may not support very exotic extensions from specific platforms. The output will still be readable, even if it doesn't perfectly match the original Markdown. The tool is 100% client-side, meaning no data is sent to a server, ensuring your content remains private and secure.
Frequently Asked Questions
Strip Markdown formatting from any document and get clean, readable plain text in one click. Paste a README, changelog, or blog post draft — headers, bold markers, link URLs, fenced code blocks, and blockquote prefixes all disappear, leaving only the human-readable content behind.
What This Tool Does
The converter removes every CommonMark-specified syntax token: ATX and setext headers, fenced and indented code blocks, inline code backticks, bold and italic markers, strikethrough, blockquote prefixes, ordered and unordered list bullets, horizontal rules, link and image syntax, and inline HTML tags. What it does not strip is the human-readable text those tokens wrap — anchor text from links is preserved, alt text from images is kept, and code block bodies are output verbatim without their surrounding fence lines.
The result is UTF-8 plain text with no markup whatsoever: no asterisks, no angle brackets, no hash prefixes. Everything runs in your browser — your input never leaves the local session and no data is sent to any server.
🔒 Privacy: This tool runs 100% in your browser. Your input is not uploaded, stored, or logged anywhere outside your local session.
How to Use It
Step 1 – Paste or type your Markdown
Drop your Markdown source into the left input pane. You can type directly, paste from the clipboard, or hit Try Example to auto-load a realistic Node.js README snippet that exercises headers, bold, links, a fenced code block, and a blockquote. The status bar immediately shows the character count of your input.
Step 2 – Choose strip options
Two option chips sit above the output pane. Strip inline HTML (default: on) removes any raw HTML tags embedded in the Markdown — both inline tags like <br> and block-level tags like <div> — while preserving their text content. Collapse consecutive blank lines (default: on) squashes multiple empty lines between paragraphs down to a single blank line, which prevents the output from looking double-spaced where Markdown sections were separated by two or more blank lines.
Step 3 – Click Convert and copy the output
The plain-text result appears in the right pane instantly. Use the Copy button to send it to your clipboard, or Download to save the stripped content as a .txt file. The status bar updates to show the output character count alongside the input count so you can gauge how much markup was removed.
Worked Example: Node.js README Snippet
The following example uses the exact input loaded by the Try Example button. It covers every major syntax category the tool handles — ATX headers at two levels, inline bold, a hyperlink, an unordered list with inline code, a fenced JavaScript code block, and a blockquote with bold text.
Input Markdown
# Getting Started with Node.js
Node.js is a **JavaScript runtime** built on Chrome's V8 engine. See the [official docs](https://nodejs.org) for setup.
## Installation
- Download from nodejs.org
- Run `npm install -g express`
- Create your first server
```javascript
const http = require('http');
http.createServer((req, res) => {
res.end('Hello World');
}).listen(3000);
```
> **Note:** Use Node 18+ for async/await support.Plain-text output
Getting Started with Node.js
Node.js is a JavaScript runtime built on Chrome's V8 engine. See the official docs for setup.
Installation
- Download from nodejs.org
- Run npm install -g express
- Create your first server
const http = require('http');
http.createServer((req, res) => {
res.end('Hello World');
}).listen(3000);
Note: Use Node 18+ for async/await support.What changed line by line
- Line 1:
# Getting Started with Node.js - The leading
#ATX header prefix is stripped; bare text becomes the first output line. - Line 2:
**JavaScript runtime**and[official docs](https://nodejs.org) - The double-asterisk bold markers are removed, leaving JavaScript runtime. The hyperlink's anchor text official docs is kept;
https://nodejs.orgis discarded — URLs produce no visible content when Markdown renders, so dropping them keeps the prose clean. - Line 4:
## Installation - The
##prefix is stripped; the word Installation stands alone as a section heading. - Lines 6–8: unordered list
- The dash-space
-list markers are kept (they aid readability in plain text). The inline code backticks aroundnpm install -g expressare stripped, leaving the command as bare text. - Lines 10–14: fenced code block
- The opening fence
```javascriptand closing fence```are discarded, as is the language info string javascript. The three body lines are output verbatim — indentation, parentheses, and semicolons untouched. - Line 16:
> **Note:** Use Node 18+... - The blockquote
>prefix is stripped. The bold markers aroundNote:are removed, leaving Note: in plain text. With blank-line collapsing enabled, the double blank line before this paragraph is reduced to one.
| Document Type | Approx. Reduction (%) |
|---|---|
| API README (moderate formatting) | 18% |
| Blog post (heavy formatting) | 31% |
| Changelog file | 22% |
| Technical spec with tables | 27% |
| Minimal prose document | 6% |
Markdown Elements This Tool Removes
The table below is the definitive reference for every syntax element the tool handles. Spec sources reference CommonMark 0.31.2 and the GitHub Flavored Markdown (GFM) extension spec.
Inline syntax
Bold (**text** and __text__), italic (*text* and _text_), and strikethrough (~~text~~) have their delimiter runs stripped; the wrapped text remains. Inline code backtick spans lose their backticks; the code content is kept as plain text. Inline links [anchor](url) yield the anchor text only — the URL and parentheses are discarded. Images  yield the alt text only.
Block-level syntax
ATX headers (# through ######) lose their hash prefix and trailing hashes. Setext headers — text underlined with === or --- — lose the underline line entirely; the text line above is kept. Fenced code blocks (opened and closed by ``` or ~~~) lose their fence lines and language info string; body lines are preserved verbatim. Indented code blocks (4-space indent preceded by a blank line, per CommonMark §4.4) are similarly unwrapped. Blockquote > prefixes are stripped at every nesting level. Ordered (1. 2.) and unordered (- * +) list markers are removed or normalized, and nesting indentation is collapsed. Horizontal rules (---, ***, ___) are dropped entirely.
Extended GFM syntax
GFM table rows lose the pipe characters and hyphen separator rows; cell text is preserved with columns separated by spaces. Task list checkboxes ([ ] and [x]) are stripped. Reference-style link definitions ([label]: url) are stripped entirely — they produce no visible text in rendered output, so nothing is kept.
What is intentionally kept
Plain prose paragraphs pass through unchanged. Blank lines between paragraphs are preserved (or collapsed to one, with the option on). Emoji characters (😀) and all Unicode ranges — CJK, Arabic, Cyrillic — pass through without modification because the tool operates on UTF-8 strings end to end.
| Markdown Element | Spec Source | Strip Behavior | Text Content Preserved? | Notes |
|---|---|---|---|---|
| H1–H6 ATX headers | CommonMark §4.2 | Hash prefix removed | Yes | Trailing hashes also removed |
| Setext headers | CommonMark §4.3 | Underline line dropped | Yes | Underline must be ≥1 char |
| Fenced code blocks | CommonMark §4.5 | Fence lines dropped | Yes (verbatim) | Language info string discarded |
| Indented code blocks | CommonMark §4.4 | Indent stripped | Yes | Only when preceded by blank line |
| Inline code | CommonMark §6.1 | Backticks removed | Yes | Multiple-backtick spans supported |
Bold (** / __) | CommonMark §6.4 | Delimiters removed | Yes | Both syntaxes handled |
Italic (* / _) | CommonMark §6.4 | Delimiters removed | Yes | Underscore rules per spec |
Strikethrough (~~) | GFM §6.5 | Delimiters removed | Yes | GFM extension |
| Blockquote (single) | CommonMark §5.1 | > prefix removed | Yes | — |
| Blockquote (nested) | CommonMark §5.1 | All > chars removed | Yes | All nesting levels handled |
| Ordered list | CommonMark §5.3 | Number+period stripped | Yes | Nesting normalized |
| Unordered list | CommonMark §5.3 | Bullet marker stripped | Yes | - * + all handled |
| Inline link | CommonMark §6.3 | Syntax stripped, URL dropped | Anchor text only | — |
| Reference-style link | CommonMark §6.3 | Definition line stripped | Anchor text (resolved in pass 2) | Definition produces no visible text |
| Image | CommonMark §6.4 | Syntax stripped, URL dropped | Alt text only | — |
| Horizontal rule | CommonMark §4.1 | Entire line removed | No | No text content to preserve |
| Inline HTML tag | CommonMark §6.6 | Tag stripped (option on) | Tag content preserved | Passes through when option off |
| Block HTML | CommonMark §4.6 | Tags stripped (option on) | Text content preserved | Includes <div>, <script> |
| GFM table | GFM §4.10 | Pipes and separator rows stripped | Yes | Cell text space-separated |
| GFM task list | GFM §5.3 | Checkbox [ ]/[x] stripped | Item text kept | — |
Emoji shortcode (:smile:) | GFM extension | Not decoded | Left as literal text | Shortcode syntax passes through unchanged |
| Feature | Plain Text (this tool) | HTML (Markdown to HTML) | PDF (external tool) |
|---|---|---|---|
| Preserves formatting visually | No | Yes | Yes |
| Output is searchable plain text | Yes | Partial (HTML source) | Depends on tool |
| Embeddable in email body | Yes | Yes (HTML email) | No (attachment only) |
| Suitable for log files | Yes | No | No |
| File size vs. input | Smaller | Larger | Much larger |
| Requires renderer to read | No | Yes (browser) | Yes (PDF viewer) |
| Handles GFM extensions | Yes | Yes | Varies |
| Offline-capable in browser | Yes | Yes | No (most tools) |
Edge Cases and Gotchas
Escaped characters
Per CommonMark §2.4, a backslash before an ASCII punctuation character is an escape sequence. The tool strips the backslash and outputs the literal character — so \* becomes * in the output, not an italic marker. This matters for documents that intentionally display asterisks or hash marks in prose.
Nested blockquotes
A triple-nested blockquote like >>> deeply quoted text loses all three > characters. The tool does not attempt to re-indent or label nesting levels; the content appears flat. If preserving nesting depth matters for your use case, post-process the output manually.
Indented code blocks vs. plain indented text
CommonMark §4.4 is specific: a 4-space-indented block is only treated as a code block when preceded by a blank line. Indented lines that follow a paragraph without a blank line are treated as a lazy continuation of that paragraph, not as code. The tool respects this distinction — indentation is preserved in lazy continuations and stripped only in true indented code blocks.
Bare URLs and autolinks
Autolinks enclosed in angle brackets (<https://example.com>) have their angle brackets stripped per CommonMark §6.7, and the URL text is kept as-is. Bare URLs that are not enclosed in angle brackets and are not inside link syntax pass through unchanged — the tool does not attempt to detect and remove bare URLs from prose, since they may be intentional.
HTML entities
HTML entities such as &, <, and > are left as-is by default. The tool does not decode them to their Unicode equivalents. If your plain-text consumer cannot interpret HTML entities, run the output through a dedicated entity decoder before use. This is a deliberate choice: decoding entities without full HTML context can produce unexpected results for documents that mix raw HTML with Markdown.
Mixed Markdown and raw HTML
With Strip inline HTML on, both inline elements (<em>, <br>, <strong>) and block-level elements (<div>, <table>, <script>) are removed. The text content inside those tags is preserved. With the option off, raw HTML passes through to the output unchanged — useful when the downstream consumer is an HTML renderer that can handle the tags. For documents that are primarily HTML with occasional Markdown rather than the reverse, the HTML to Plain Text tool is the better starting point.
Behind the Scenes: The Parsing Algorithm
Tokenizer vs. regex approach
The tool uses a tokenizer and AST-walk approach rather than a single monolithic regex. A mega-regex breaks down quickly on real-world documents because Markdown's inline constructs can be nested and overlapping — consider [a [b] c](url), where the inner brackets are part of the link text, not a nested link. CommonMark §6.3 dedicates an entire section to link parsing precedence precisely because bracket nesting creates ambiguity that a greedy regex cannot resolve without look-ahead state. The tokenizer resolves block structure first, then walks each block to resolve inline syntax — mirroring the two-phase parsing described in CommonMark spec Appendix A.
CommonMark compliance level
The implementation targets CommonMark 0.31.2. GFM extensions — tables, task list checkboxes, strikethrough — are layered on top per the GitHub Flavored Markdown spec. The fenced code block parser extracts body content verbatim; the language info string (e.g., javascript in ```javascript) is discarded since it has no equivalent in plain text. Link reference definitions are collected in a first pass and resolved before stripping in a second pass, so reference-style links in the document body are correctly expanded to their anchor text before their definition lines are removed.
Processing order matters
Block-level structure (headers, fenced code, blockquotes, lists) is resolved before inline syntax (bold, italic, links, images). Fenced code block interiors are excluded from inline processing entirely — otherwise a **bold** inside a code sample would have its asterisks stripped, corrupting the code. This sequencing is not optional; the CommonMark spec mandates it as the correct parse order, and deviating from it is the primary reason many regex-based strippers produce incorrect output on code-heavy documents.
Related Tools
For rendered output rather than stripped output, the Markdown to HTML converter produces semantic HTML from the same Markdown source — useful for email templates or CMS imports where tags are expected. For documents that are primarily HTML rather than Markdown, the HTML to Plain Text tool handles the inverse problem, stripping HTML tags and block structure down to readable prose.
To verify the conversion produced exactly what you expected, paste both the original Markdown and the stripped output into the Text Diff Checker to see a line-by-line change view. Developers building their own Markdown-stripping pipeline can prototype and test patterns in the Regex Tester before integrating into a script. For batch conversion of multiple files, the Download button combined with a shell loop — or a one-liner using the marked npm package piped through a custom strip script — covers most needs; no separate batch tool is required.