HTML to Markdown Converter
Convert HTML markup to clean Markdown syntax. Paste your HTML and get properly formatted Markdown that preserves headings, links, lists, images, and text formatting.
Conversion Mapping
- h1-h6 tags become # to ###### headers
- strong/b tags become **bold**
- em/i tags become *italic*
- a tags become [text](url)
- img tags become 
- ul/li become - list items
- ol/li become numbered lists
- pre/code become code blocks
When to Convert
- Migrating blog content to a Markdown-based CMS
- Converting web pages to documentation
- Creating README files from existing HTML docs
- Preparing content for static site generators
Handling Complex HTML
Simple semantic HTML converts cleanly. Complex layouts with nested divs, CSS classes, and custom elements may need manual cleanup. Tables convert but may need formatting adjustments. Inline styles are stripped.
Tips for Clean Output
- Remove unnecessary wrapper divs before converting
- Ensure HTML is well-formed (proper nesting and closing tags)
- Review converted output for any missed elements
- Test the Markdown in your target platform
When Your Images Are Trapped Inside HTML — And How to Set Them Free
Picture this: you've just exported a blog post from WordPress, or scraped a product page, or received an HTML file from a designer. Inside it are dozens of image tags, styled tables, clickable thumbnails, and figure captions — all wrapped in layers of <div> soup. You need clean, portable Markdown. You could spend an afternoon manually converting each <img src="..."> to  syntax. Or you paste the HTML into an HTML-to-Markdown converter and let it handle the tedious part.
This tool sits in a strange but genuinely useful category: image-heavy HTML conversion. It's not just about stripping tags — it's about preserving the visual meaning of a document while shedding everything that makes HTML brittle to edit by hand.
What Actually Happens to Your Images During Conversion
The most interesting behavior to understand is how image tags transform. An HTML snippet like this:
<figure>
<img src="https://example.com/photo.jpg" alt="Sunset over the mountains" width="800" height="600">
<figcaption>Golden hour at 3,200 meters</figcaption>
</figure>Becomes something like this in Markdown output:
*Golden hour at 3,200 meters*The width and height attributes disappear — Markdown has no native syntax for image dimensions. The figcaption becomes italicized text sitting below the image reference, which is a reasonable approximation. The important thing is that the alt text is preserved and becomes the bracket content, and the src URL goes into the parentheses exactly as written.
Where this matters practically: if you're migrating content into a static site generator like Hugo or Jekyll, the Markdown image syntax will render correctly as long as your asset paths are valid. The converter doesn't touch URLs, so a relative path like ../images/photo.jpg stays relative — good or bad depending on your folder structure.
The Alt Text Problem Nobody Talks About
Here's where photo and image-heavy content creates a specific headache. A lot of real-world HTML — especially exported from CMS platforms — has images with empty or useless alt attributes:
<img src="product-shot.jpg" alt="">
<img src="banner.png" alt="image">
<img src="profile.jpg" alt="photo">The converter faithfully produces:
These are technically valid Markdown, but they're accessibility dead ends and will hurt you if you're publishing somewhere that checks for descriptive alt text. The converter can't invent descriptions — that's still your job. But using HTML-to-Markdown conversion as part of a content audit workflow is actually smart: the Markdown output makes it visually obvious which images have missing or placeholder alt text, precisely because the bracket content is so exposed. What was hidden inside attribute syntax becomes glaring when you see  scattered through a document.
Handling Linked Images and Clickable Thumbnails
Gallery pages and product listings often have images wrapped in anchor tags — click the thumbnail, get the full-size version. In HTML that looks like:
<a href="full-size.jpg">
<img src="thumbnail.jpg" alt="Product detail view">
</a>Good HTML-to-Markdown converters handle this nesting and produce:
[](full-size.jpg)This is Markdown's linked image syntax — an image inside a link — and it's one of the trickier structures to get right. If the converter you're using just drops the wrapping anchor and only gives you the image, that's a red flag. Test this specific pattern before committing to a tool for a large conversion job.
Quick Workflow: Converting an Image-Heavy Page in Three Steps
- Isolate the content HTML. Don't paste the full page source — strip the
<head>, navigation, footer, and sidebar first. Most browsers let you right-click the main article area, choose "Inspect", then copy the outer HTML of just the content container. This prevents the converter from producing hundreds of lines of nav links and script tags you don't need. - Paste and convert. Drop the HTML into the input field and run the conversion. Scan the output for image lines — look for every
 and nothing else. This is the correct behavior — Markdown doesn't have a styling layer — but it means any visual formatting that was communicated through CSS is gone. If you're converting to Markdown for a platform that supports HTML inside Markdown (like many static site generators do), you have the option of keeping the image as raw HTML for those specific elements where styling matters, and letting everything else convert cleanly.
A practical rule: use the converter for the bulk of your content, then manually keep or rewrite specific image tags where appearance is non-negotiable.
Base64-Embedded Images: Expect Trouble
Some HTML exports — especially from tools like Notion, certain email clients, or offline webpage saves — embed images as Base64 data URIs directly in the src attribute:
<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...">The converter will produce Markdown with that entire Base64 string crammed into the URL position. The result is technically valid Markdown but completely unreadable and often breaks editors that have line length limits. If you're dealing with Base64-heavy HTML, extract the images to actual files first using a separate tool, update the src paths, then run the HTML-to-Markdown conversion. Trying to do it in the wrong order creates a mess that's harder to fix than starting over.
Markdown Flavors and Image Rendering
One thing that trips people up: not all Markdown is the same. Standard Markdown supports image syntax, but some flavors (particularly in documentation tools or certain wiki platforms) treat image references differently or require specific relative path conventions. If you're pasting converted Markdown into Obsidian versus GitHub README versus a Jekyll _posts file, the images may or may not render depending on how asset paths are resolved in each context.
The HTML-to-Markdown tool doesn't know your deployment target — it just converts syntax. So the test is always: paste the converted Markdown into your actual destination and see if the images load. Don't assume because the Markdown looks right that the images will appear. The converter's job ends at the syntax level.
The Real Use Case This Tool Is Built For
The people who get the most value from this conversion process are usually content migrators — moving posts between platforms, importing product descriptions into headless CMS systems, converting documentation from old HTML sites into Markdown-based repositories. In those contexts, image handling is the bottleneck. Text converts cleanly. Tables convert passably. But images have URLs, alt text, captions, links, and sometimes dimensions — all of which need to survive the conversion intact enough to be useful.
Doing that transformation by hand across hundreds of images is the kind of repetitive work that leads to errors. Running it through a converter and then spot-checking the image lines is a much more defensible workflow. You still have to review the output — particularly alt text and URL integrity — but the mechanical transformation is handled, and that's what matters.