Can I share a Kaggle notebook with someone who does not have a Kaggle account?

Only by making the notebook public, which publishes it to the whole Kaggle community and its search index. Private sharing is done by adding named collaborators, and those collaborators need Kaggle accounts. For a reader outside Kaggle, export the executed notebook to HTML and publish that file instead.

What happens when I make a Kaggle notebook public?

It becomes visible to everyone on Kaggle and on the open web, it can be forked, and it is associated with your profile. That is often the point — public notebooks are how Kaggle reputation works — but it is the wrong setting for client work, an interview take-home, or anything touching proprietary data.

How do I export a Kaggle notebook to HTML?

Run jupyter nbconvert inside the notebook, or download the .ipynb from the notebook menu and convert it locally. Add --execute so the outputs are regenerated, and --no-input if you want it to read as a document rather than as code.

Do the charts still work in an exported Kaggle notebook?

Plotly, Bokeh, Altair and folium charts keep working, because their interactivity is client-side JavaScript with no kernel behind it. Make sure the library is embedded in the file rather than linked to a CDN, or the chart will render blank on a network that blocks it.

How do I keep one link across submissions?

Publish the export once, keep the report id, and PATCH it after each run. Revisions stack at the same URL, so a link in an application or a writeup stays correct and any two runs can be compared.

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:

!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:

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

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 — 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 →