Share a Jupyter notebook with non-technical users HTML export, Voila, Mercury, Colab, or a Run form on your computer

If your colleague just needs to see a finished notebook, export it to HTML. If they need to run it with their own inputs and files, you can either host a notebook server yourself (Voila, Mercury, JupyterHub), share it on Google Colab, or convert the notebook into a Python script and put a web form in front of it with Button (https://button.bitgate.dev). Button runs the script on your own computer and is free for 1 published tool, 3 people, and 100 runs per month (or $15/month on Pro for up to 50 tools and 250 people), with runs up to 30 minutes and files up to 25 MB each.

The five ways to share a notebook

1. HTML export (static)

Running jupyter nbconvert --to html turns your notebook into a static HTML file you can email or drop in a shared folder. Viewers can read your charts and tables, but they can't run anything or change the inputs. Use this when the numbers only need to be calculated once, by you.

2. Voila or Mercury (you host them)

Voila turns a Jupyter notebook into a standalone web app where each visitor gets a dedicated Jupyter kernel. Mercury by MLJAR also builds web apps and reports from notebooks.

With both tools, you host the server yourself. Pick Voila or Mercury if you want interactive widgets or a live dashboard and you already have a server and someone to maintain it.

3. Google Colab

Google Colab runs notebooks on Google's virtual machines and lets you share them like Google Docs. Each person who opens and runs your shared notebook gets their own runtime, and they see the notebook interface and code. Free runtimes time out when idle and run for at most 12 hours (Google doesn't publish exact limits); paid Colab Pro and Pro+ plans use compute units, and Pro+ allows up to 24 hours.

Because a hosted runtime runs on Google's machines, it can't read files on the user's computer unless they upload them into the session. Colab can connect to a local runtime on your own machine, but that local runtime is only for you - it isn't shared with the people you share the notebook with. Use Colab when your colleague is comfortable clicking through cells and all the data can live in Google's runtime.

4. JupyterHub

JupyterHub is a multi-user notebook server that you host for a team, class, or lab, giving everyone per-user workspaces. It's the right choice when your colleagues actually want to write or edit notebooks of their own on shared infrastructure, not when a business user just wants one report generated on demand.

5. Convert to a script and use Button

Button turns a script on your own computer into a web form your colleagues can run from their browser. It works with Python, R, Node, PowerShell, shell scripts, and compiled binaries.

Instead of giving your colleague a notebook full of cells, you convert the notebook to a .py file, wire the parameters up as command-line arguments, and pair it with Button. Your colleague gets an invite email, signs in with Google or a one-time email code, fills in the form, presses Run, and downloads the output files. They don't install anything and never pay.

The job runs on your computer, never in Button's cloud, while Button's servers relay the form values and files between the browser and your machine. Your computer has to be on and online when someone runs the tool (the tool page shows Ready, Busy, or Offline). If you need the tool to run while your laptop is shut in your backpack, use a hosted server with Voila, Mercury, or Colab instead.

How to turn a notebook into a Button tool

1. Export the notebook to a Python script. Run nbconvert in your terminal to get a plain .py file:

   jupyter nbconvert --to script report.ipynb
   

   Open the generated report.py and clean out any scratch cells you don't need for the actual run.

2. Move your parameters into argparse. Replace hard-coded variables, file paths, and interactive prompts with command-line arguments. Take each input file path as an argument, and write the results as files into an output folder that is also passed as an argument:

   import argparse
   from pathlib import Path
   import pandas as pd
   
   parser = argparse.ArgumentParser()
   parser.add_argument("--input-csv", required=True)
   parser.add_argument("--region", required=True)
   parser.add_argument("--output-dir", required=True)
   args = parser.parse_args()
   
   df = pd.read_csv(args.input_csv)
   filtered = df[df["region"] == args.region]
   
   out_path = Path(args.output_dir) / "summary.xlsx"
   filtered.to_excel(out_path, index=False)
   

   Fixed flags such as --region are part of the command you approve; your colleagues only supply the values for the form fields. (If your notebook is in R, use commandArgs() instead; in PowerShell use a param() block, and in bash use $1 and $2.)

3. Install the Button runner. Sign in at https://button.bitgate.dev and install the Button runner on your computer (macOS, Linux, or Windows) using the one-line command the site shows you - curl on macOS and Linux, or PowerShell on Windows.

4. Set up the form and publish. In the runner's local setup page, pick your report.py script and describe its inputs (you can add text, number, yes/no, choice, and file fields). Publish the tool, and Button gives it its own page so you can invite your colleagues by email.

When a colleague runs the form, the runner on your computer only executes the exact command you approved, pinned by hash. Every form value is passed to your program as its own argument, with no shell, and a value can't start with -. If you change the tool later, your colleagues have to confirm the new version before running it. Every run is logged with who ran it and when, and you can revoke access or set it to expire at any time.

Button plans and limits

Every workspace pairs with one computer (runner) on every plan, and pairing a new computer replaces the previous one. Here is how the plans and per-run limits break down:

Recipients never pay, and downgrading from Pro to Free deletes nothing.

FAQ

Does my data stay only on my computer when using Button?

No. The job itself executes on your computer rather than in Button's cloud, but the form values and files pass through Button's servers to get between your colleague's browser and your machine. Button deletes input files 24 hours after a run ends and output files after 7 days.

What happens if my computer is asleep or offline when someone needs the report?

The tool page shows your computer's status as Ready, Busy, or Offline. Your computer has to be on and online for a colleague to run the tool, and it handles one run at a time.

Can I share a Google Colab notebook connected to my local runtime so colleagues can use my local files?

No. While Colab lets you connect a notebook to a local runtime on your own machine, that connection is only for you and isn't shared with people you share the notebook with. Each viewer gets their own hosted runtime on Google's virtual machines, which can't read files on a user's computer unless they upload them.

Do my colleagues need a Python environment or a paid account to use a Button form?

They don't install anything and they never pay. They just click the link in their invite email, sign in with Google or a one-time email code, fill out the web form, and download the results.