# Use Comma with Mode: Faithful Sharing, Anchored Comments, Scheduled Refresh

Canonical: https://commareports.com/with/mode

> Mode is the BI platform. Comma is where your team reviews the output. Connect a Mode report to a Comma routine so refreshed HTML lands on a commentable, shareable document — same link every cadence.

# Use Comma with Mode

Mode does the BI work. Comma is where your team reviews the output. Connecting
them gives you the strongest part of each tool without duplicating either.

## The division of labor

**Mode does the build.** SQL workbench, R, Python notebooks, drag-and-drop
dashboards, governed datasets, custom data apps, embedded analytics. The
full BI arc from "raw data in the warehouse" to "rendered, governed report."

**Comma does the review.** Takes the rendered HTML, displays it faithfully
inside an opaque-origin sandbox, and adds anchored Google-Docs-style comments
on text and table cells. Routines re-run the underlying skill on a cron and
post the new HTML as a revision. The same `comma_sk_…` token gates the REST
API and the MCP server, so a Claude or Cursor agent is a first-class
contributor.

Each tool keeps the slice it's best at. Neither tool pretends to be the
other.

## When the pair makes sense

- **You have an established Mode setup** but the share-step ends in Slack
  screenshots, an email digest, or a Mode dashboard link reviewers won't
  open.
- **Stakeholders aren't Mode users.** PMs, designers, execs, and customers
  open documents more readily than BI workspaces.
- **Reviewers outnumber editors.** Mode's per-seat cost is steep for casual
  commenters; Comma doesn't paywall commenters per seat.
- **You want reports refreshed at a cadence outside Mode's tier.** Comma
  routines run on every plan, at any cadence.
- **You have an agent in the loop.** A Cursor or Claude Code agent runs
  alongside your Mode workflow and needs somewhere scoped to post.

## Three integration patterns

### Pattern 1: Manual export → Comma report

The lightest setup. Run the Mode report, use Mode's "export HTML" or
"download" function, and upload to a Comma report. Reviewers leave anchored
comments. Next refresh, upload the new HTML and Comma appends it as a new
revision on the same report — comments persist.

**When to use it:** One-off reports, monthly recurring reports where you
don't need full automation, the first proof-of-concept.

### Pattern 2: Comma routine re-runs the skill

The strongest setup. Wrap your Mode logic (or the data-fetching logic
underneath it) as a Claude skill. A Comma routine fires on its cadence,
executes the skill, and posts the resulting HTML as a revision on the
target report. If you want Mode to remain the build engine, the skill can
call Mode's API to pull the latest rendered output rather than
re-implementing the SQL.

**When to use it:** Recurring reports with a predictable shape (daily ops
digest, weekly analytics, monthly compliance). When you want the schedule,
the cost cap, and the credential under one tool — Comma.

See [routines documentation →](/features/routines).

### Pattern 3: Mode scheduled report → Comma API

The tightest coupling. Mode fires its scheduled report. A small webhook or
the Mode notification's destination calls Comma's
`/api/v1/reports/{id}/revisions` endpoint, posting the rendered HTML as the
next revision.

```bash
# At the end of a Mode scheduled report
curl -X POST https://commareports.com/api/v1/reports/$REPORT_ID/revisions \
  -H "Authorization: Bearer $COMMA_TOKEN" \
  -H "Content-Type: text/html" \
  --data-binary @./mode-export.html
```

**When to use it:** You already trust Mode as your scheduler and don't want
two of them. Mode fires the run; Comma is the publication target with the
comment layer attached.

## What changes for reviewers

| Before (Mode alone)                            | After (Mode + Comma)                                           |
| ---------------------------------------------- | -------------------------------------------------------------- |
| Open a Mode dashboard to leave a comment       | Open a document link, no Mode account required                 |
| Comments live in Mode threads                  | Comments anchored to text and table cells in the rendered HTML |
| Refresh requires opening Mode                  | Same link refreshes in place via routines                      |
| Reviewers may need a Mode seat                 | Casual commenters don't add seat cost                          |
| Conversation lives in Slack alongside the link | Conversation lives on the artifact                             |

## What stays in Mode

- The warehouse connections and credentials.
- The SQL workbench, R, and Python notebooks.
- Governed datasets and the semantic layer.
- The dashboard builder and custom data apps.
- The full audit and compliance posture of an enterprise BI tool.

Comma doesn't try to replace any of this. Mode stays the source of truth for
the _how_ of the analysis; Comma carries the _what_ to the people who need
to review it.

## Setup, end to end

1. **Pick the report shape.** A daily ops digest? A weekly analytics
   summary? A monthly board report? Decide the cadence first.
2. **Have a Comma account.** Free is enough to test the loop end-to-end at
   any cadence.
3. **Create the Comma report.** Either upload your current Mode output, or
   start with a placeholder. Set access for reviewers.
4. **Choose an integration pattern.** Manual to start, routine when the
   shape is stable, API for tight coupling with Mode's scheduler.
5. **For Pattern 2: wire the routine.** From the Comma report, **Add
   routine →**. Pick a skill that wraps your Mode logic (or that calls
   Mode's API). Set cadence and cost cap.
6. **Invite reviewers.** They get a link, anchor comments where they want
   them, and the link refreshes in place at each cadence boundary.

## Pricing for the pair

You keep paying Mode for what you use Mode for — enterprise BI seats. Comma
is free for the share layer — unlimited reports, commenters, and routines —
with AI compute billed only when a routine uses Comma's hosted keys (prepaid
credits) or free when you bring your own AWS Bedrock key. For most teams,
this is materially cheaper than adding more Mode seats just so reviewers can
comment, because Comma's commenters don't count against editor seats.

**[See full Comma pricing →](https://commareports.com/pricing)**

## Try the integration

The fastest way to feel the pair is on the Comma Free plan: export your
latest Mode report, create a Comma report from it,
invite two reviewers, and see how the surface changes. Move to Pattern 2 or
3 when the loop is worth automating.

**[Create your first report →](https://commareports.com/)**

### Related

- [Comma vs Mode](/vs/mode) — direct comparison of the two products
- [Mode alternatives](/alternatives/mode-alternatives) — the wider landscape
- [Routines](/features/routines) — Comma's hosted-cron primitive