# Datapane Alternative: Where Did One-Line Report Publishing Go?

Canonical: https://commareports.com/alternatives/datapane-alternative

> Datapane shut down in August 2023. Quarto and marimo replaced the authoring half — nothing replaced upload-and-share. Comma is that layer: publish HTML from any tool, get a link, collect anchored comments.

# 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](https://quarto.org)** 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](https://marimo.io)** 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:

1. **Hosted the artifact** at a stable URL.
2. **Made it shareable** — link-first, with visibility controls.
3. **Made it discussable** — teammates commented on the report itself
   instead of in a Slack thread next to it.
4. **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:

```bash
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 — any cadence, every plan        |

Costs: Quarto and marimo are free and open source. Comma is free too —
unlimited reports, commenters, and scheduled routines at any cadence on
every plan. You pay only for the AI compute a routine uses: bring your own
AWS Bedrock key (free) or draw down prepaid credits for hosted runs. Team
and Enterprise add shared workspaces and pooled credits and are sales-led
(let's talk). Reviewers and commenters are always free.

## Migration path

1. Port the report body to Quarto or marimo (or keep whatever already
   produces your HTML — Comma doesn't care where it came from).
2. Create a Comma token under **Settings → API tokens**.
3. Add the publish step above to the end of your render script.
4. 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 →](https://commareports.com/)**

### Related

- [Use Comma with Quarto](/with/quarto) — the render-and-publish pipeline
- [Use Comma with marimo](/with/marimo) — publishing notebook exports
- [Share an HTML report](/share-html-report) — the manual flow, no API