How to Convert a Jupyter Notebook to a Python Script

Before converting anything, it helps to know a notebook is a JSON document: a list of cells, each with a cell_type (code or markdown), its source (lines of text), and — for code cells — any saved outputs. That's the whole format. Our test notebook has four cells:

{
  "cells": [
    {"cell_type": "markdown", "source": ["# Sales analysis\n", "Quick exploration."]},
    {"cell_type": "code", "source": ["import pandas as pd\n", "%matplotlib inline"]},
    {"cell_type": "code",
     "outputs": [{"output_type": "stream", "text": ["rows: 1000\n"]}],
     "source": ["df = pd.DataFrame({'x': range(1000)})\n", "print('rows:', len(df))"]},
    {"cell_type": "code", "source": ["def total(col):\n", "    return col.sum()"]}
  ],
  "nbformat": 4, "nbformat_minor": 5
}

If you have Jupyter installed, the built-in converter is one command:

$ jupyter nbconvert --to script sales.ipynb
# writes sales.py  (use --stdout to print instead)

Here's the actual output (nbconvert 7.17.1). It concatenates the code cells — but notice two things:

import pandas as pd
%matplotlib inline

df = pd.DataFrame({'x': range(1000)})
print('rows:', len(df))

def total(col):
    return col.sum()

If you don't have Jupyter set up, or you want a runnable .py without hand-editing, a browser tool is the quickest path. Our free Jupyter Notebook → Python Script converter runs entirely in your browser: drop in the .ipynb, get a clean .py. It does what nbconvert doesn't — removes the IPython magics and shell escapes — so the result runs as ordinary Python.

Under the hood it's the same idea as Method 3 below (parse the JSON, keep the code) — it just happens client-side, so your notebook never leaves your machine.

Because a notebook is just JSON, you don't strictly need any package. This reads the cells, comments the markdown, drops the magics/shell lines, and skips outputs entirely:

import json

def notebook_to_script(path, keep_markdown=True):
    nb = json.load(open(path))
    out = []
    for cell in nb.get('cells', []):
        src = ''.join(cell.get('source', []))
        if cell['cell_type'] == 'code':
            lines = [ln for ln in src.splitlines()
                     if not ln.lstrip().startswith(('%', '!'))]
            out.append('\n'.join(lines))
        elif keep_markdown and cell['cell_type'] == 'markdown':
            out.append('\n'.join('# ' + ln for ln in src.splitlines()))
    return '\n\n'.join(b for b in out if b.strip()) + '\n'

# # Sales analysis
# Quick exploration.

import pandas as pd

df = pd.DataFrame({'x': range(1000)})
print('rows:', len(df))

def total(col):
    return col.sum()

I verified the result with compile(script, '<nb>', 'exec') — it's valid Python (no leftover magic), the markdown became comments, and the saved rows: 1000 output was dropped. That's the clean, runnable conversion most people actually want.

Whichever you pick, remember what conversion doesn't do: it won't reproduce cell outputs, and code that relied on notebook state (out-of-order execution, In[]/Out[], display side-effects) may behave differently as a top-to-bottom script. Once you have the .py, you can run it in the online Python compiler or tidy it with the Python Formatter.