Markdown cells, untouched
Headings, lists, links and task lists pass through exactly as you wrote them — including attachment images, which become inline data URLs.
IPYNB to Markdown
Drop in an .ipynb file and download a clean .md file: markdown cells untouched, code cells fenced with the kernel language, outputs embedded as markdown — ready for GitHub, Obsidian or your docs.
Converted in your browser — the notebook is never uploaded. You can also drop it anywhere on this page.
That file could not be opened
notebook.ipynb
Markdown preview (first 200 lines)
The file is assembled in this tab from the notebook you chose. Nothing is uploaded, and the download is yours alone — the same file every time for the same notebook.
Convert to HTML instead100% of the markdown kept
Markdown cells pass through byte-for-byte.
0 bytes uploaded
Parsing and serialization happen on your device.
``` fenced code blocks
Tagged with the kernel language for highlighting.
6 notebook sources
Jupyter, JupyterLab, Colab, VS Code, Kaggle, Deepnote.
What the file keeps
The converter reads the notebook format directly, so the output is a real .md file — diff-able, greppable and at home in any repository.
Headings, lists, links and task lists pass through exactly as you wrote them — including attachment images, which become inline data URLs.
Every code cell becomes a ``` block tagged with the kernel language, so GitHub and Obsidian highlight Python, R, Julia or SQL correctly.
Stream text, JSON and result outputs become fenced blocks under their cell; HTML output tables are converted to real GFM tables.
Plot and image outputs are embedded as base64 data URLs, so the .md file renders with its figures on GitHub or in any renderer that allows them.
Tracebacks are kept as plain-text blocks with the error name, so a failed cell is visible in the document instead of vanishing.
A .md file diffs line by line in pull requests — the review workflow that notebooks were never built for.
Compatibility
Notebooks from Jupyter Notebook, JupyterLab, Google Colab, Kaggle, Deepnote and VS Code all convert, including the older nbformat 3 files.
Notebook formats
Cell types
Output types
Known limits
How it works
Drop in an .ipynb file and download a clean .md file: markdown cells untouched, code cells fenced with the kernel language, outputs embedded as markdown — ready for GitHub, Obsidian or your docs.
Drop the notebook in
Choose an .ipynb file or drag it onto the page; it is parsed on your device and the Markdown file is assembled immediately.
Check the document
The preview shows the first lines of the .md — headings, fenced code and embedded figures in one portable file.
Download the .md file
Save notebook.md into your repository: it diffs cleanly, renders on GitHub, and opens in any Markdown editor.
From the browser converter above to the tooling built into Jupyter and GitHub — pick the route that fits where you already are.
The command-line standard: jupyter nbconvert --to markdown notebook.ipynb writes a .md file and an image folder next to your notebook. nbconvert ships with Jupyter, needs no extra install and works in a CI pipeline — the route to choose when you already live in the terminal.
Classic Jupyter Notebook has File → Download as → Markdown; JupyterLab exposes the same conversion through File → Save and Export Notebook As. If your version hides the entry, nbconvert in a terminal is the same job.
Push an .ipynb to a repository and GitHub displays a rendered view of the last saved session — handy for a quick look, but it cannot replace a committed Markdown file that diffs in pull requests.
Knowledge tools speak Markdown, not notebooks. Converting gives you one portable document whose headings, code fences and images survive the paste — no plugin required.
In a hurry? Use the converter at the top.
The browser converter above reads the same notebooks as every route on this page and produces the same clean .md file — with nothing installed and nothing uploaded.
FAQ
Short answers about converting a Jupyter notebook to Markdown — what happens to outputs, how nbconvert compares, and where the .md file works best.
Use the converter at the top of this page: choose or drop in your .ipynb file and the browser builds a Markdown document — markdown cells as-is, code cells fenced with the kernel language, outputs embedded. Then download the .md file. No upload, no install, no terminal.
Run jupyter nbconvert --to markdown notebook.ipynb. nbconvert writes a .md file next to your notebook and a folder of extracted images. This page embeds images as data URLs instead, so you get one portable file — useful for wikis that dislike asset folders.
Stream text, JSON and execute_result outputs become fenced blocks under the code. HTML output tables are converted to real GFM tables, images are embedded as base64 data URLs, and tracebacks are kept as plain text with the error name.
Markdown is the format your tools already edit: it diffs cleanly in git, renders on GitHub and in Obsidian, and can be pasted into most documentation systems. Choose HTML for a shareable page and PDF for printing; choose Markdown when the text will keep changing.
The Jupyter extension in VS Code exports HTML, Python scripts and .ipynb files — not Markdown, so vscode ipynb to markdown has no built-in answer. Drop the notebook into this page instead: the .md it produces renders the same in VS Code's Markdown preview.
In Colab use File → Download → .ipynb to save the notebook locally, then convert that file here. Colab has no direct Markdown export; the downloaded notebook converts exactly like any other .ipynb file — headings, code, plots and all.
Yes — image outputs are embedded as base64 data URLs inside the .md, and GitHub renders those directly in the file preview. That also means the file is larger than an nbconvert export with a separate image folder; the trade-off is one portable file versus many small ones.
Formulas export as their LaTeX source inside fenced blocks. Markdown has no universal math syntax — GitHub uses $$ delimiters, Obsidian its own — so the export keeps the formulas copy-pasteable rather than guessing a dialect.
nbconvert extracts images into an assets folder next to the .md; this converter inlines them as data URLs so the Markdown file is a single artifact. Both produce valid Markdown — pick nbconvert when you manage assets explicitly, this page when you want one file.
No. The file is read with the browser's File API, parsed as JSON and serialized inside the tab. You can disconnect from the network after the page loads and the conversion still works — which is also the practical proof that nothing is uploaded.
Not on this site — that direction is the job of Jupytext or the VS Code Python Interactive window, which read ```-fenced scripts back into notebooks. The fences this converter writes are the format those tools understand.
Yes, with no account, no file-size gate and no watermark. The conversion runs on your own device, so there is no per-file cost — same as the site IPYNB to PDF, IPYNB to PY and IPYNB to HTML converters.
Drop it in, download the .md, and paste it into your repository — headings, code and plots arrive in a form GitHub already understands.
Convert a notebook to Markdown