How do I share a Redash dashboard with someone outside the team?

Publish a snapshot instead of an account. Pull query results via the Redash API, render them as an HTML report, and publish that to Comma — the reader gets the numbers at a URL with no Redash seat and no data-source access.

Redash has public share links — why not use those?

They work, with two caveats: a public dashboard URL is unauthenticated for anyone who has it, and it still executes against your live data source. A snapshot is a fixed artifact with real access control, which is usually what you want for anything going outside the team.

How do I get the data out of Redash?

Every query has a results endpoint: `GET /api/queries/ /results.json?api_key= ` returns the last cached result set, and `.csv` returns the same as CSV. Use a query API key, not your user key, so the credential is scoped to that one query.

Can I keep the snapshot current?

Yes. Run the fetch-and-render on a schedule and PATCH the same report id. The URL you gave a stakeholder keeps showing this week's numbers, and each refresh is a revision.

Can stakeholders ask questions about a number?

Yes. Threads anchor to the rendered content, so 'why did returns spike in week 34?' lands on the number rather than in an email that gets forwarded to the wrong person.

Share a Redash dashboard with someone who has no Redash account

Redash is where a lot of teams' operating numbers live, and it has the same structural problem every internal BI tool has: the dashboard is behind a login that is behind a data-source connection.

So sharing it with someone outside the analytics group means one of:

Provision a seat — and grant them access to a data source that answers a great deal more than the one question they had.
Turn on the public share link — an unauthenticated URL for anyone who gets it, still executing against live data.
Screenshot it — which is what actually happens, weekly, forever.

Publish a snapshot instead

Redash's API gives you the result set directly:

# last cached results for a query
curl -fsS "https://redash.internal/api/queries/412/results.json?api_key=$QUERY_API_KEY" \
  > results.json

Use a query API key rather than your personal one — Redash scopes it to that single query, so the credential in your job cannot read anything else.

Render it and publish:

jq -r '
  .query_result.data as $d |
  "<h1>Weekly ops</h1><table><tr>" +
  ($d.columns | map("<th>\(.friendly_name)</th>") | join("")) + "</tr>" +
  ($d.rows | map("<tr>" + (to_entries | map("<td>\(.value)</td>") | join("")) + "</tr>") | join("")) +
  "</table><p>As of \(.query_result.retrieved_at)</p>"
' results.json > report.html

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 t "Weekly ops — $(date +%F)" '{title: $t, html: $html}')"

Include the retrieved_at timestamp. A dashboard screenshot with no date on it is the most common way a stale number gets into a decision.

Several queries, one report

A Redash dashboard is a set of queries. Fetch each and concatenate the rendered fragments into one page — the reader gets the dashboard's content as a single document rather than a link tree they cannot follow without an account.

Charts render the same way: reuse the query result to drive a Chart.js or Plotly figure in the same page, and the snapshot keeps the visual shape people recognize.

Keep it current

# in cron, or a scheduled CI job
curl -fsS "https://redash.internal/api/queries/412/results.json?api_key=$QUERY_API_KEY" > results.json
# …render report.html…

curl -fsS -X PATCH "https://commareports.com/api/v1/reports/$REPORT_ID" \
  -H "Authorization: Bearer $COMMA_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d "$(jq -n --rawfile html report.html \
        --arg t "Weekly ops — $(date +%F)" '{title: $t, html: $html}')"

This is the part that ends the weekly screenshot. The stakeholder's bookmark resolves to current numbers, and the revision list is the history — which the Redash dashboard itself does not keep, since it shows whatever the query returns today.

See scheduled HTML reports.

Access

Reports are private by default. Domain-gated access (anyone at partner.com) is usually right for an external stakeholder — no seat to provision, no shared password, and it stops working when they leave. Team for internal readers. See the sharing model.

Compare that to a Redash public share link, which is a bearer URL: whoever it is forwarded to has it, permanently.

What review adds

Anchored threads on a number, so the explanation lives with it — see commenting on HTML.
Revisions, so "was that number different last month?" is answerable.
No data-source exposure — the reader gets results, not query access.

Limits

Entry HTML: 5 MB. A snapshot of aggregate numbers is kilobytes; publish aggregates, not raw exports.
60 requests/minute per token.

Try it

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

Publish a snapshot →