What happened to Datapane?

Datapane — the 'build and share data reports in 100% Python' library and hosted platform — shut down in August 2023. The hosted sharing service is gone and the open-source project is no longer maintained, so dp.upload_report() has no destination anymore.

What replaced Datapane?

The authoring half got replaced well: Quarto renders markdown plus executable code to polished HTML, and marimo exports reactive Python notebooks. The publishing half did not. Neither tool gives you a one-line 'upload, get a share link, collect comments' step — that's the slice Comma covers, for HTML produced by any tool.

Is Comma a drop-in Datapane replacement?

For the publish-and-share step, close to it: one POST to /api/v1/reports with your HTML returns a share URL, and reviewers leave comments anchored to specific text and table cells. For the authoring step, no — Comma doesn't build reports from Python objects. Keep Quarto, marimo, Plotly, or plain Jinja for that, and send Comma the rendered HTML.

Does Comma have a Python SDK like Datapane did?

Comma's API is one JSON endpoint, so a publish step is a few lines of requests code or a curl call — no SDK dependency to pin. Agents (Claude Code, Cursor) can also publish through Comma's MCP server with the same scoped token.

Datapane alternatives: what actually replaced one-line publishing

Datapane's pitch was "build and share data reports in 100% Python." You composed a report from DataFrames, Plotly figures, and markdown blocks, called dp.upload_report(), and got back a hosted URL your team could open and discuss. In August 2023, Datapane shut down. The hosted platform is gone and the open-source library is unmaintained.

Two and a half years later, the authoring half of that pitch has been replaced well — arguably better than Datapane ever did it. The publishing half hasn't. This page maps what to use for each.

The authoring half is solved

Quarto is the closest thing to a successor for "document with executable code." A .qmd file mixes markdown with Python, R, or Julia cells; quarto render produces clean, self-contained HTML with figures, tables, and cross-references. It is mature, Posit-backed, and free.

marimo replaces the notebook side. Reactive Python notebooks stored as plain .py files, with an export html command that snapshots the whole notebook — outputs included — into a single HTML file.

Both produce better-looking artifacts than Datapane's block layout did. Neither answers the question Datapane's upload call answered.

The publishing half is the gap

dp.upload_report() did four things in one line:

Hosted the artifact at a stable URL.
Made it shareable — link-first, with visibility controls.
Made it discussable — teammates commented on the report itself instead of in a Slack thread next to it.
Versioned it — re-upload and the same link showed the new run.

What ex-Datapane users do today instead: render with Quarto, then push to GitHub Pages (public, no comments, no access control), or Netlify (same), or S3 (a URL to raw HTML is not a review surface), or paste a screenshot into Slack (feedback scatters, the chart is now a picture). Each of these recovers hosting and loses sharing, discussion, and versioning.

Comma is the publish-share-discuss layer

Comma starts where your renderer stops: at the HTML.

One call to publish. POST /api/v1/reports with the rendered HTML returns a share URL. From a Makefile, a CI step, a cron job, or the last cell of a notebook:

jq -Rs '{title: "Weekly metrics", html: .}' report.html |
  curl -s -X POST https://commareports.com/api/v1/reports \
    -H "Authorization: Bearer $COMMA_API_TOKEN" \
    -H "Content-Type: application/json" \
    --data-binary @-

Faithful rendering. The HTML renders untouched inside an opaque-origin sandbox. Comma doesn't reformat or restyle what your tool produced.
Anchored comments. Reviewers pin comments to a specific paragraph or table cell, Google-Docs style — the discussion lives on the artifact, not beside it. Commenters are free on every plan.
Share roles. Private, registered-users-only, or public; link permission set to view, comment, or edit. Datapane's visibility controls, plus per-link permissions.
Revisions on a stable URL. PATCH /api/v1/reports/:id with new HTML appends a revision; reviewers' bookmark keeps working and Comma can diff runs.
Agent-native. The same scoped comma_sk_… token gates the REST API and an MCP server, so a Claude Code or Cursor agent publishes with create_report and reads feedback with list_comments. Datapane never had to think about agents; in 2026 they produce a large share of the reports worth reviewing.

What Comma deliberately does not do: build the report. There is no block API, no dp.Table(df). Your renderer — Quarto, marimo, Plotly's to_html(), Jinja, pandas styling, an LLM — owns the artifact. Comma owns what happens after.

The replacement stack, concretely

Datapane piece	2026 replacement
Python block layout (`dp.Report`)	Quarto `.qmd` / marimo notebook / own templates
`dp.upload_report()`	`POST /api/v1/reports` → share URL
Hosted report page	Comma report view (sandboxed, faithful)
Comments on reports	Anchored comments on text and table cells
Re-upload to update	`PATCH` → new revision, same link
Scheduled reports (Teams plan)	Comma routines — daily on Pro, hourly on Team

Costs: Quarto and marimo are free and open source. Comma is free to publish and collaborate; $9/month (Pro) adds daily scheduled routines, $75/seat (Team) adds hourly cadence and shared workspaces. Only creators pay — reviewers and commenters are always free.

Migration path

Port the report body to Quarto or marimo (or keep whatever already produces your HTML — Comma doesn't care where it came from).
Create a Comma token under Settings → API tokens.
Add the publish step above to the end of your render script.
Drop the returned share_url wherever the Datapane link used to go.

The loop you had — render in Python, one line to publish, teammates discuss on the report — comes back, with the discussion now anchored to the exact line being discussed.

Create your first report →

Use Comma with Quarto — the render-and-publish pipeline
Use Comma with marimo — publishing notebook exports
Share an HTML report — the manual flow, no API