ipynb to pdf

IPYNB to Markdown

Notebook to Markdown,plain and portable.

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.

  • Jupyter Notebook
  • JupyterLab
  • Google Colab
  • VS Code
  • Kaggle
  • Deepnote

100% 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

Plain text that any Markdown app understands.

The converter reads the notebook format directly, so the output is a real .md file — diff-able, greppable and at home in any repository.

Markdown cells, untouched

Headings, lists, links and task lists pass through exactly as you wrote them — including attachment images, which become inline data URLs.

Code cells, fenced

Every code cell becomes a ``` block tagged with the kernel language, so GitHub and Obsidian highlight Python, R, Julia or SQL correctly.

Outputs embedded

Stream text, JSON and result outputs become fenced blocks under their cell; HTML output tables are converted to real GFM tables.

Images inline

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.

Errors preserved

Tracebacks are kept as plain-text blocks with the error name, so a failed cell is visible in the document instead of vanishing.

Perfect for git

A .md file diffs line by line in pull requests — the review workflow that notebooks were never built for.

Compatibility

Reads every notebook you can throw at it.

Notebooks from Jupyter Notebook, JupyterLab, Google Colab, Kaggle, Deepnote and VS Code all convert, including the older nbformat 3 files.

Notebook formats

  • nbformat 4 (current)
  • nbformat 3 worksheets (legacy)
  • attachments as data URLs
  • UTF-8 content, any language

Cell types

  • markdown cells pass through untouched
  • code cells fenced with the language
  • raw cells dropped like nbconvert does
  • empty cells skipped quietly

Output types

  • GFM tables from HTML output
  • PNG, JPEG, GIF and WebP as data URLs
  • stream text and JSON as fences
  • LaTeX kept as fenced source

Known limits

  • SVG outputs become image links only
  • interactive widgets have no markdown form
  • very large images make large .md files
  • math stays unrendered LaTeX source

How it works

Three steps to the file.

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.

  1. 01

    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.

  2. 02

    Check the document

    The preview shows the first lines of the .md — headings, fenced code and embedded figures in one portable file.

  3. 03

    Download the .md file

    Save notebook.md into your repository: it diffs cleanly, renders on GitHub, and opens in any Markdown editor.

Every route from notebook to Markdown

From the browser converter above to the tooling built into Jupyter and GitHub — pick the route that fits where you already are.

jupyter nbconvert --to markdown

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.

Jupyter's own menus

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.

GitHub renders notebooks itself

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.

Obsidian, Notion and wikis

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.

What the file keeps (and what it drops)

  • Markdown as markdown — headings, lists, tables and links as you wrote them.
  • Code as code — fenced blocks tagged with the kernel language.
  • Outputs where they belong — text, tables and figures under their cell.
  • Images inline — plots embedded as base64 data URLs that render on GitHub.
  • Errors as errors — tracebacks kept as plain text with the error name.
  • Widgets noted honestly — interactive outputs have no markdown form and get a short note.

FAQ

IPYNB to Markdown: frequently asked questions

Short answers about converting a Jupyter notebook to Markdown — what happens to outputs, how nbconvert compares, and where the .md file works best.

How do I convert IPYNB to Markdown?

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.

How do I convert a Jupyter notebook to Markdown on the command line?

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.

What happens to code-cell outputs in the Markdown export?

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.

Why convert a notebook to Markdown instead of HTML or PDF?

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.

How do I convert IPYNB to Markdown in VS Code?

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.

How do I convert a Google Colab notebook to Markdown?

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.

Do images render on GitHub after converting IPYNB to MD?

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.

What happens to LaTeX math in the Markdown export?

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.

How is this different from jupyter nbconvert --to markdown?

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.

Is my notebook uploaded when I convert it here?

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.

Can I convert the Markdown back into a notebook?

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.

Is the IPYNB to Markdown conversion free?

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.

Try it with the notebook behind your README.

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