Jupyter Notebook lets you combine executable code with explanations, data, equations, and visualizations in one document. To begin, either try Jupyter in a browser or install the classic Notebook or JupyterLab locally; then create a notebook, run a few cells, and save the resulting .ipynb file.
What is Jupyter Notebook?
Jupyter Notebook is a web-based environment for creating documents that mix live code with narrative text, equations, data, visualizations, and interactive controls. Instead of keeping a program and its explanation in separate files, you can place a code cell beside the explanation of what it does and the output it produces. That makes a notebook useful for learning, data exploration, demonstrations, and sharing a reproducible analysis.
A notebook is not just a static report: its code cells can be run and edited. Project Jupyter describes notebooks as an open document format, with support for over 40 programming languages (Project Jupyter). The file extension is .ipynb; the file contains structured JSON, including cells, outputs, and metadata.
Choose how to start
Try Jupyter in a browser
If you only want to see how notebooks work, start with Try Jupyter. It offers browser-based sessions without a local installation. Some JupyterLite environments are experimental, so treat the browser option as a way to learn the interface rather than as the default home for a persistent project (Try Jupyter options).
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Fix the driver behind crashes, sound loss and screen glitches3Repair Windows errors before they cause bigger problems#1 Best Overall
A browser trial is convenient for a first experiment, but a local installation is generally a better fit when you need files to persist in a project folder, custom packages, or a repeatable working environment.
Install with pip
Use pip if you already manage Python and its environments. Project Jupyter’s current install page gives these commands:
pip install notebook
jupyter notebookThe first command installs the classic Notebook interface; the second starts it. To install JupyterLab instead, use:
pip install jupyterlab
jupyter labRun the install command in the Python environment where you want Jupyter available. If your computer has multiple Python installations or virtual environments, make sure the pip and jupyter commands refer to the intended one. Release requirements can change, so consult the current official installation instructions rather than relying on an old version-specific tutorial.
Install with Anaconda
The classic Notebook installation guide recommends Anaconda for new users. It bundles Python and common scientific packages, reducing the need to assemble a beginner data-science environment package by package (classic Notebook installation guide). Anaconda is an option, not a requirement: pip is a direct route if you already have a Python environment you know how to manage.
Notebook or JupyterLab?
Both provide a browser-based way to work with notebooks, but they suit different workflows. Jupyter Notebook is the lighter, document-centered interface; JupyterLab is designed as a richer workspace with tabs, multiple documents, a customizable layout, and a system console (Jupyter documentation).
| Choose | Best fit | What to expect |
|---|---|---|
| Classic Notebook | A single focused notebook and a straightforward first experience | A simplified, lightweight authoring interface centered on the notebook document. |
| JupyterLab | Working across notebooks and other documents, or wanting an IDE-like workspace | Tabs, multiple documents, a customizable layout, and extensibility. |
If your goal is to learn notebook basics, either works. Pick the classic interface for one document with minimal workspace overhead; choose JupyterLab if you expect to switch between notebooks and other project files.
What is a Jupyter kernel?
A kernel is the process that runs code for a notebook in a particular programming language. Python is the most common starting point, but Jupyter supports many languages; official Jupyter material lists or demonstrates languages including R, Julia, C++, Ruby, and Scheme (Project Jupyter). Installing the Jupyter interface and having a kernel for the language you want to use are related but distinct: the interface presents the notebook, while the kernel executes its code.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
A kernel keeps state in memory. If one cell creates a variable, a later cell can use it. This is convenient while exploring, but it also means that the order in which you run cells matters. A notebook may appear to work because an old variable remains in memory, even if the visible cell order would not recreate it from scratch. Restarting the kernel clears that in-memory state; running the notebook’s cells from top to bottom is a useful reproducibility check.
Run your first notebook
- Make a project folder. Create a folder for the notebook and any related files. Launch Jupyter from that folder so relative file paths are predictable.
- Start your chosen interface. For the classic interface, run
jupyter notebook; for JupyterLab, runjupyter lab. Open the local address shown by the running server in your browser if it does not open automatically. - Create a notebook. Use the interface’s create or new-notebook control and choose the Python kernel if Python is what you installed. The exact menus can vary by interface and version.
- Run a code cell. Enter this example and run the cell using the interface’s run control:
name = "Jupyter"
print(f"Hello, {name}!")The cell’s output should read Hello, Jupyter!. A cell can also contain an expression whose result is displayed directly:
2 + 2That cell displays 4. In a notebook, code and its output remain together in the document, which makes a short experiment easier to explain than a bare script.
Add Markdown, data, and a plot
Cells can contain code or Markdown prose. Change a cell’s type to Markdown in the interface, then enter a heading or explanation and run it to render the text. For example:
## A small example
This notebook keeps the explanation beside the result.For a basic table and plot using only Python’s standard library and the common Matplotlib package, run:
from IPython.display import display
import matplotlib.pyplot as plt
values = [2, 4, 3, 6]
display({"day": [1, 2, 3, 4], "value": values})
plt.plot([1, 2, 3, 4], values, marker="o")
plt.xlabel("Day")
plt.ylabel("Value")
plt.show()The dictionary is displayed as a table-like output in notebook environments, and Matplotlib draws a line plot. If the import fails, the relevant package is not installed in the environment used by the kernel; install it in that environment, then rerun the cell. These examples show the notebook’s core pattern: code, rendered results, and explanation can live side by side.
Save, share, and make notebooks reproducible
Save the notebook from the interface. The resulting .ipynb file is a JSON document that can store cell source, outputs, and metadata—not just the code you typed (Notebook documentation). That is why a saved notebook can reopen with previous outputs visible, and why the file may contain more than expected when shared.
- Check the run order. Restart the kernel and run all cells from the beginning. Fix missing dependencies, out-of-order assumptions, and cells that rely on hidden state.
- Review saved outputs. Remove confusing or excessively large output where appropriate. Outputs can preserve data or reveal information you did not intend to publish.
- Remove secrets and private data. Inspect code, cell outputs, and metadata for API keys, credentials, personal information, and confidential data before sharing.
- Explain the environment. Note the language and packages a reader needs to run the notebook. A notebook file does not by itself guarantee that another computer has the same dependencies.
- Choose a sharing route. A repository or notebook viewer can display the document for readers who want to inspect it without executing it. Readers who need to reproduce the analysis also need the required data and environment.
Notebook trust and document structure are among the topics covered in the official Notebook documentation. Treat notebooks from other people as executable files: inspect code before running it, particularly when you do not know or trust its source.
Troubleshooting common first-run problems
“jupyter” is not recognized or the command is missing
The installation may have gone to a different Python environment, or the executable may not be on your command path. Activate the environment where you installed Notebook or JupyterLab, then try the matching launch command again. If needed, consult the official installation page for the current installation method.
The notebook opens, but a cell reports a missing module
The package may not be installed in the kernel’s Python environment. Install it into the same environment that provides the selected kernel, then rerun the cell. Installing a package into another Python environment will not make it available to the running kernel.
A variable is unexpectedly undefined—or has an old value
Cells may have been run out of order, or the kernel may have been restarted. Run the cells that define the variable first. To check the notebook as a whole, restart the kernel and run all cells sequentially.
My browser trial or local session does not preserve files
Browser-based trials are intended for trying Jupyter and may use temporary sessions. For persistent project files and custom packages, use a local environment or another deliberately persistent setup, and keep your work in the project folder you control.
Free tools Windows power users keep installed
One-click scans. No signup required.
Someone sees old output after opening my notebook
Outputs are saved in the notebook document. Rerun cells to update them, or clear outputs before sharing if displaying them would mislead the reader or reveal information.
Or skip the browser setup
If your goal is to capture a web page for a notebook, report, or development workflow, ScreenshotNeo is a website screenshot API and MCP server. A single request returns a PNG, JPEG, WebP, or PDF; its clean-shot options accept consent banners and remove more than 60 known consent platforms, newsletter popups, and chat widgets before capture, with each step configurable. Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed, and response headers identify the page verdict and billing status. Its MCP server provides take_screenshot, get_page_info, and capture_pdf for AI agents and MCP clients.
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo API documentation for the request options and setup. The free plan includes 1,000 shots per month without a card; paid plans start at $5 for 3,000 shots. Sign up for the free plan.
Frequently Asked Questions
Can I use Jupyter without installing it?
Yes. Try Jupyter provides browser-based sessions for experimenting with the interface; for persistent files and custom packages, use an environment intended to keep your work.
Recommended Free Tools
Is Jupyter Notebook only for Python?
No. A notebook uses a language-specific kernel. Python is a common beginner choice, and Jupyter supports other language kernels as well.
What does an .ipynb file contain?
It is a structured JSON notebook document that can include cells, saved outputs, and metadata.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
