JupyTools.com
Available now.txt

IPYNB requirements.txt

Scan imports and !pip install lines, deduplicate them, and download a clean requirements.txt with the right PyPI names so a colleague can pip install in one shot.

Free and instant. Files are processed briefly on our servers for conversion, then discarded — nothing is stored.

How it works

List imports as requirements.txt

1

Upload the .ipynb

We scan import lines and !pip install magics. This is not a freeze of your live environment.

2

Check name mapping

cv2, sklearn, and PIL are mapped to the usual PyPI names. Standard library modules are dropped.

3

Save requirements.txt

Review pins before you install on another machine. Processed for this request only.

requirements.txt extractor: turn a Jupyter notebook into pip dependencies in seconds

This extractor reads a .ipynb, scans code cells for imports and shell-magic install lines, and writes a requirements.txt you can hand to pip install -r. Someone shared a notebook, you want to run it locally, and you do not have time to collect imports by hand. The notebook is processed for this request only and is not stored afterward.

Pure Python parsers tend to miss a few things. The extractor handles import x, import a, b, import a as b, from x.y import z, and shell magics like !pip install pandas, %pip install requests==2.31, and !conda install -y numpy. Standard-library modules drop out so you do not pin os or json by mistake. The well-known import-name aliases, cv2 to opencv-python, sklearn to scikit-learn, PIL to Pillow, bs4 to beautifulsoup4, yaml to PyYAML, dotenv to python-dotenv, map to their real PyPI names so pip install -r actually works.

Compared to running pipreqs locally, this page is faster when you only have one notebook to inspect, when the project is not on disk yet, or when you want to share a starter requirements.txt with a teammate before you create a virtual environment. It is also a useful sanity check after pipreqs: drop the same notebook here, eyeball the list, and adjust pins before you push.

The defaults give you a list pinned only where the notebook itself pinned things (via !pip install pandas==2.2.1). Turn off Map import names if you would rather see the raw module names. Turn off Sort to keep the order in which the imports appear. Turn off Header to skip the comment block at the top when you want a strict, machine-readable file.

What this requirements.txt extractor catches

Reads imports, magics, and pinned installs

Detects top-level import and from … import statements as well as !pip install, %pip install, !conda install, and !mamba install lines. Pinned versions written into the notebook carry through to the output.

Maps import names to PyPI names

Knows the common surprises, cv2 becomes opencv-python, sklearn becomes scikit-learn, PIL becomes Pillow, bs4 becomes beautifulsoup4, yaml becomes PyYAML, so pip install -r succeeds the first time.

Drops the standard library

Modules shipped with CPython (os, json, pathlib, typing, …) are filtered out by default so the requirements file lists what pip actually needs to fetch.

Sort, dedupe, and pin

Duplicates collapse to one entry per package, the list sorts alphabetically, and pins from inline !pip install pkg==1.2 lines are preserved when you keep the option on.

No durable archive

Requirements export runs for this request only. Review the list before you install it on another machine.

Friendly header you can keep or strip

By default the file starts with a short comment reminding the reader to review pins before shipping. Toggle Header off when you need a bare list for tooling.

How to generate requirements.txt from a Jupyter notebook

  1. 01

    Upload the.ipynb

    Drop the notebook into the uploader. The parser reads cells in your browser, secure server conversion (not stored afterward).

  2. 02

    Tune the options if you need to

    Choose whether to map import aliases, keep version pins, sort the list, or include the friendly header comment.

  3. 03

    Download requirements.txt

    Click download to save the file. Run pip install -r requirements.txt (or the conda equivalent) inside a fresh virtual environment to recreate the notebook’s dependencies.

FAQ

Frequently asked questions about extracting requirements

Open this requirements.txt extractor, upload the.ipynb, and download the generated file. The list contains every imported third-party package the notebook needs, ready for pip install -r requirements.txt.

Yes. Magic install lines and !conda install / !mamba install lines are scanned. Version pins written there (e.g. ==2.31 or >=1.0) carry into the output when Include pins is on.

No. Map import names handles the common surprises, cv2 to opencv-python, sklearn to scikit-learn, PIL to Pillow, bs4 to beautifulsoup4, yaml to PyYAML, dotenv to python-dotenv, and a few more, out of the box.

Not by default. Modules shipped with CPython are filtered out. Switch Include Python standard library on if you want the raw list of every imported module.

It is a faster, install-free alternative when you only need to scan a notebook. pip freeze lists everything in the current environment (helpful for reproducing an exact install), and pipreqs scans whole projects. Use this tool when the input is one notebook and the goal is a starter list.

Only top-level imports get listed. Transitive packages install automatically when you run pip install -r requirements.txt. For a fully-pinned lock file, generate it with pip freeze after the install completes.

If the notebook contains lines like !pip install pandas==2.2.1, that pin appears in the output when Include pins is on. To pin every package, install in a clean environment and run pip freeze to capture exact versions.

Yes. The result is a normal requirements.txt. conda accepts it via conda install --file. pip-tools can read it with pip-compile. Edit the list before compiling if you want to enforce stricter pins.

No. The notebook is parsed in your browser and the requirements.txt is generated locally.

The extractor lists what was imported. Internal packages need an extra index URL or a local install path; add those manually after the export.

Yes. Imports anywhere in a code cell are detected. The extractor cannot tell which branch will run, so any imported package shows up in the list.

Some teams build private wheels that match the import name exactly. Disable Map import names when you trust the source modules and want them listed verbatim.

Try our other free tools