Skip to main content
PDFBase

Jupyter Notebook to PDF Converter

Local

Convert a Jupyter .ipynb notebook to PDF with its outputs

All Tools
IPYNB to PDF
Local
Tool Details
Input formatsIPYNB, JUPYTER NOTEBOOK
Output formatPDF
Max file size25 MB
Max files1
ProcessingLocal
Related Tools

Markdown to PDF

Convert Markdown into a formatted PDF with real text

JSON to PDF

Convert JSON data to a readable PDF document

HTML to PDF

Convert an HTML file into a PDF that keeps its layout

PDF to Text

Extract plain text from PDF files

Privacy First

Your files are processed entirely in your browser. Nothing is uploaded to any server.

How do I convert a Jupyter notebook to PDF?

Add your .ipynb file, pick a page size and margin, then convert and download the PDF. Markdown cells arrive as formatted text, code cells as monospace blocks under their In [n] prompts, and the outputs stored in the notebook — printed text, error tracebacks and PNG or JPEG figures — appear beneath the cell that produced them. Nothing is executed and nothing is installed: no Python, no LaTeX, no nbconvert. The notebook is read and the PDF written inside this browser tab.

About the Jupyter Notebook to PDF Converter

Convert a Jupyter notebook (.ipynb) into a PDF that keeps the notebook’s shape: Markdown cells render as formatted text with headings, lists and tables, code cells appear in a monospace block under their In [n] prompt, and the outputs saved in the file — printed text, error tracebacks and PNG or JPEG figures — sit under the cell that produced them. Nothing is executed: the PDF shows the outputs the notebook was saved with, exactly as an unopened notebook shows them. No Python, no LaTeX and no nbconvert install is needed, because the whole conversion runs in this browser tab. Interactive widget output cannot be drawn on a page and is reported as skipped rather than silently dropped. The text layer uses the built-in PDF fonts, so it covers English, Western European accents and common punctuation, but not Cyrillic, Greek, CJK or emoji.

  • Hand in a data-science assignment or lab report as a PDF when the marker asks for one and nbconvert refuses without a LaTeX distribution installed.
  • Send an analysis to a reviewer who has no Jupyter install, with the charts and printed results still under the cells that produced them.
  • Archive a notebook run as a fixed record: the PDF captures the outputs stored in the file, so it does not change when the data or the library versions do.
  • Produce a code-free reading copy for a non-technical audience by turning off code cells and keeping the Markdown narrative and figures.

How to use the IPYNB to PDF tool

  1. 1

    Upload IPYNB, Jupyter Notebook file

    Select IPYNB, Jupyter Notebook file from your device or drag file into the upload area.

  2. 2

    Choose settings

    Choose settings such as Page Size, Orientation, Margin before processing.

  3. 3

    Convert to PDF

    Run the IPYNB to PDF tool to create the PDF output.

  4. 4

    Download the result

    Download the finished file. The original file stays on your device and is not uploaded.

Why does nbconvert ask for LaTeX before it will make a PDF?

Because its default PDF route goes through TeX. `jupyter nbconvert --to pdf` converts the notebook to LaTeX and then calls an engine such as XeLaTeX to typeset it, which means a TeX distribution and Pandoc both have to be installed before the command works at all — several gigabytes of dependencies for one document. The alternative, `jupyter nbconvert --to webpdf`, prints through a headless Chromium supplied by Playwright, so it needs nbconvert installed with its webpdf extra and a browser downloaded first. This page needs neither, because the browser you are already using is the layout engine.

Which notebook outputs survive into the PDF, and which cannot?

Printed output, error tracebacks, PNG and JPEG figures, HTML output such as a pandas DataFrame table, and plain-text results are all drawn. Tracebacks have their ANSI colour codes stripped, so an exception reads as text rather than as a line of bracketed escape sequences. What cannot be drawn is anything that is only alive in a running kernel: ipywidgets and other interactive views, JavaScript output, SVG figures, and PDF output embedded inside a cell. Each of those is counted and named in the message shown with the finished file, so you know what is missing before you send it.

Can you leave the code out and keep the write-up?

Yes. Two checkboxes control it: turning off "Include code cells" keeps the Markdown narrative and the outputs while dropping the source, which is the version to hand to a reader who wants the findings rather than the implementation. Turning off "Include cell outputs" does the opposite and produces a plain code listing with no figures, printed values or tracebacks. Both are on by default, which reproduces the notebook as it was saved.

Does converting run the notebook again?

No. There is no Python kernel here, and no cell is executed. What you get is the outputs that were stored in the .ipynb file the last time it was run and saved — the same ones GitHub shows when it previews a notebook. If a notebook was cleared before it was saved, or a cell was never run, its output section is empty in the file and therefore empty in the PDF. Run the notebook and save it before converting if you want the results included.

Are my files uploaded when converting a Jupyter notebook to PDF?

No. The .ipynb file is read by JavaScript in this tab, turned into a document there, and written back out as a PDF you download — no upload, no queue, no conversion server. That matters more for notebooks than for most formats, because a notebook routinely carries the things around the analysis as well as the analysis: connection strings, API keys pasted into a cell, customer rows printed by a stray `head()` call, and file paths that name internal systems.

How to do this offline, on the command line

nbconvert is the official notebook converter, and both of its PDF routes need something substantial installed first — which is the reason this page exists.

jupyter nbconvert (LaTeX route)

pip install nbconvert · plus Pandoc and a TeX distribution (macOS: brew install pandoc and brew install --cask mactex; Debian/Ubuntu: apt install pandoc texlive-xetex texlive-fonts-recommended)

jupyter nbconvert --to pdf analysis.ipynb

Converts the notebook to LaTeX and typesets it with XeLaTeX. Add --no-input to leave the code cells out, the same as clearing "Include code cells" here.

jupyter nbconvert (browser route)

pip install "nbconvert[webpdf]" · then playwright install chromium

jupyter nbconvert --to webpdf analysis.ipynb

Prints through a headless Chromium instead of TeX, so the output matches the notebook’s HTML styling. It downloads a browser on first use, which is why it is not the default.

jupyter nbconvert (HTML, then print)

pip install nbconvert

jupyter nbconvert --to html analysis.ipynb

The one route with no extra dependency: it writes analysis.html, which you then print to PDF from a browser. This page collapses those two steps into one.

Frequently Asked Questions

Do I need Python, Jupyter or LaTeX installed?
No. The .ipynb file is JSON, and this page reads that JSON and lays the notebook out with the browser you already have. nbconvert’s own PDF route needs a TeX distribution and Pandoc, and its webpdf route needs a Playwright-managed Chromium; neither is required here.
Are my cells re-run during the conversion?
No. There is no kernel, so no code is executed. The PDF shows the outputs that were saved inside the notebook, which is the same thing GitHub renders when it previews an .ipynb file. A cell that was never run, or was cleared before saving, has no output in the file and none in the PDF.
Why are my plots missing from the PDF?
Because of how they were saved. PNG and JPEG figures are embedded; SVG figures and interactive widget views cannot be drawn on a static page and are reported as skipped in the message shown with the finished PDF. If your figures are SVG, set the plotting backend back to PNG, re-run the notebook, save it, and convert the new copy.
Which notebook format versions are supported?
nbformat 4, which is what every Jupyter release since 2015 writes. A version 3 notebook stores its cells under a "worksheets" key and uses different output names, so it is rejected with a message rather than half-converted — open it in Jupyter and save it once to upgrade it, then convert the new file.
Can I hide the code and keep the narrative?
Yes. Turn off "Include code cells" and the PDF keeps the Markdown text and the outputs but leaves the source out. "Include cell outputs" does the reverse, giving a plain code listing. Both are on by default.
Is my notebook uploaded anywhere?
No. It is read, converted and written back out in this tab. Notebooks often contain more than the analysis — credentials pasted into a cell, printed customer rows, internal hostnames in file paths — which is exactly the material that should not be handed to an upload-based converter.

Need More Tools?

Explore our collection of 58 free PDF tools, all with privacy-first processing.

Browse All Tools