# How to Share a Kaggle Notebook Outside Kaggle

Canonical: https://commareports.com/share-kaggle-notebook
Published: 2026-09-04

> A Kaggle notebook is either public to the whole community or shared with named Kaggle users — there is no middle. How the visibility settings work, and how to export an executed HTML copy for readers who are not on Kaggle.

# How to share a Kaggle notebook

Kaggle's visibility model has exactly two settings and no dial between them.

**Private with collaborators.** You add named Kaggle users. They can open and
edit. Everyone else, including someone who has never used Kaggle, is out.

**Public.** The notebook is visible to the entire Kaggle community and the open
web, forkable, indexed, and attached to your profile.

For the platform's actual purpose — a public learning and competition
community — this is the right design. It becomes a problem the moment the
audience is someone specific who is not a Kaggle user: a hiring manager, a
client, a co-author at a different institution, a professor.

## The three situations this breaks

**A take-home or interview notebook.** Publishing it hands your solution to
every future candidate. Adding the reviewer as a collaborator requires them to
have a Kaggle account and gives them edit rights on your work.

**Client or internal analysis run on Kaggle's free GPUs.** Public is out for
obvious reasons. Collaborators means provisioning Kaggle accounts for people
who have no other reason to have one.

**A writeup you want feedback on before publishing.** Kaggle has comments, but
only on public notebooks — so getting review means publishing first, which is
backwards.

## Export the executed notebook

The reliable move is to render the notebook to one self-contained HTML file
and share that file, decoupled from Kaggle's visibility model entirely.

From inside the notebook:

```python
!jupyter nbconvert --to html --execute --no-input \
    /kaggle/working/__notebook__.ipynb --output /kaggle/working/report.html
```

Or download the `.ipynb` from the notebook menu and convert locally, which is
often easier because you control the environment:

```bash
jupyter nbconvert --to html --execute --no-input notebook.ipynb --output report.html
```

`--execute` regenerates outputs so they match the code, and `--no-input` hides
the cells so it reads as a document. Drop `--no-input` when the code *is* the
thing being reviewed — for an interview submission, it usually is.

Interactive charts survive the export. Plotly, Bokeh, Altair and folium render
as client-side JavaScript with no kernel behind them, so zoom and hover keep
working — as long as the library is embedded in the file rather than pulled
from a CDN at view time.

## Publish it somewhere with a comment layer

```bash
curl -fsS -X POST "https://commareports.com/api/v1/reports" \
  -H "Authorization: Bearer $COMMA_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d "$(jq -n --rawfile html report.html \
        --arg title "Fraud detection — approach and results" \
        '{title: $title, html: $html}')"
```

Keep the returned id and `PATCH` it on later runs, so the link you put in an
application or a writeup keeps working while the content behind it improves,
with every earlier version preserved as a revision.

## What that gets you that Kaggle's settings do not

**A specific audience.** Access is a setting on the report —
[private, team, domain-gated or link](/docs/sharing) — so a reviewer opens the
work with no Kaggle account, and the work is not published to the community.

**Review before publication.** The feedback conversation happens on anchored
threads pinned to specific cells and figures — "this leaks the target through
the aggregation" — while the notebook is still private. Kaggle comments only
exist after you have published.

**A record.** Every re-run is a revision at the same URL, so a reviewer can
see what changed between the version they commented on and the current one.

## When to just make it public

If the notebook is a contribution — a tutorial, a competition writeup, an EDA
you want upvotes on — publish it on Kaggle. That is what the platform is for
and no private link substitutes for community reach. Export and publish
separately when the reader is one specific person who is not on Kaggle.

## Try it

Comma is free — unlimited reports, unlimited commenters, unlimited revision
history.

**[Create your first report →](https://commareports.com/)**

### Related

- [Share a Colab notebook](/share-colab-notebook)
- [Share a Jupyter notebook as HTML](/share-jupyter-notebook-html)
- [Share an EDA report](/share-eda-report)