Why does my D-Tale link not work for other people?

`dtale.show(df)` starts a Flask server bound to your machine. The URL it prints is a localhost address backed by a process only you are running — it stops working the moment your kernel dies, and it never worked from anyone else's network.

How do I export something static from D-Tale?

`dtale.offline_chart(df, chart_type='bar', x='region', y='revenue')` returns a self-contained chart you can write to an HTML file. The Describe and Correlations panels also export, and the underlying frame exports to an HTML table.

Can I share the whole interactive grid?

Not as a file — the grid is served by the Flask backend, which is the thing that cannot travel. Publish the views you actually want reviewed: the chart, the profile, the filtered table.

What should I publish for a data review?

The chart or profile that carries the finding, plus the filtered frame as an HTML table. That is what a reviewer reads; the full grid is an exploration tool for the analyst.

Can teammates comment on a specific column?

Yes. Threads anchor to the rendered content, so "this column is 40% null after the migration" stays on the column instead of in a message.

Share a D-Tale view

D-Tale is excellent at the thing it does: one line in a notebook and you have a real grid over a DataFrame, with filters, describe, correlations and charts. The line is also the problem.

import dtale
dtale.show(df)
# http://your-laptop:40000/dtale/main/1

That is a Flask server running on your machine. The URL is bound to a process in your kernel, on your network, behind whatever VPN you are on. Sent to a colleague it fails immediately; kept for tomorrow it fails when the kernel restarts. Every "can you send me that view?" ends in a screenshot.

Export the view, not the server

D-Tale exports static versions of the pieces that carry findings:

import dtale

# a self-contained chart
html = dtale.offline_chart(
    df, chart_type="bar", x="region", y="revenue", agg="sum"
)
open("revenue.html", "w").write(html)

And the frame itself, when the finding is the rows:

df.query("nulls > 0").to_html("suspect_rows.html", index=False)

offline_chart renders without the backend — that is its whole purpose — so the result is a file that survives being moved.

Publish it

Drop the HTML into Comma, or from the notebook:

import requests, os

requests.post(
    "https://commareports.com/api/v1/reports",
    headers={"Authorization": f"Bearer {os.environ['COMMA_API_TOKEN']}"},
    json={"title": "Revenue by region — Q3", "html": html},
).raise_for_status()

Scripts run inside a sandboxed iframe (allow-scripts, no allow-same-origin), so the exported Plotly chart keeps its hover, zoom and legend toggles — the interaction that a screenshot of the same chart throws away. See the API reference.

Publish the profile, not the grid

The instinct is to want the whole interactive grid shared. It is worth being honest about what the reader actually needs: the grid is an exploration tool for the person who knows the data. The reviewer needs the finding.

So publish:

the chart that shows the anomaly,
the describe/correlation panel that supports it,
the filtered rows as an HTML table — the evidence.

That set is readable in a minute and is exactly what a screenshot fails to carry, because the numbers in a screenshot cannot be selected, searched or commented on.

Comments where the column is

Data review dies in messaging apps: "the revenue column looks off after June" with an image attached, and three people re-deriving the same query. Anchored threads keep the observation on the column or the row it is about, and the report takes a revision every time you republish with fresh data — so the conversation and the data stay together. See commenting on HTML.

Who can see it

Per report: private, your team, anyone signed in at your domain, or anyone with the link. Exported rows are real data — restrict accordingly, and aggregate before publishing when the rows are personal. See sharing & access control.

Limits

Entry HTML: 5 MB. A to_html() of a large frame blows past that quickly — publish an aggregate or a sample, which is also more readable.
Assets: 25 MB per file, 250 MB and 500 files total.
60 requests/minute per token.

Try it

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

Publish a data view →