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

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

> Hex builds the analysis. Comma is where your team reviews it. Connect a Hex notebook to a Comma routine so refreshed HTML lands on a commentable, shareable document — same link every cadence.

# Use Comma with Hex

Hex builds the analysis. Comma is where your team reviews it. Connecting
them gives you the strongest part of each tool without duplicating either.

## The division of labor

**Hex does the work.** SQL workbench, Python cells, chart cells, warehouse
connections, AI notebook and threads agents, semantic models, published data
apps. The full arc from "raw data in the warehouse" to "rendered HTML
output."

**Comma does the review.** Takes the HTML Hex produced, renders 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

- **Your team has a mature Hex setup** but the share-layer step ends in
  Slack screenshots, an email digest, or a published Hex app that
  stakeholders won't open.
- **Reviewers outnumber editors.** Hex charges per editor; Comma doesn't
  paywall casual commenters per seat.
- **You want scheduled refreshes below the Team-plan price floor.** Hex
  scheduled runs are gated to Team ($75/seat). Comma routines run on every
  plan, at any cadence.
- **You have an agent in the loop.** A Cursor or Claude Code agent runs
  alongside the Hex workflow and needs somewhere to post its output.

## Three integration patterns

### Pattern 1: Manual export → Comma report

The lightest setup. Run the Hex notebook, use Hex's "publish as app" or
"export HTML" function, and paste the result into a new Comma report.
Reviewers leave anchored comments. Next time you re-run the notebook, paste
the new HTML in and Comma appends it as a new revision on the same report.

**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. Convert your Hex notebook's logic into a Claude skill
(or wrap your Hex API calls inside one). A Comma routine fires on its
cadence, executes the skill, and posts the resulting HTML as a revision on
the target report. The skill can still call Hex's API to pull the latest
output if you want Hex to remain the build engine.

**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: Hex job posts to Comma via API

The tightest coupling. Your Hex workflow ends with an API call to Comma's
`/api/v1/reports/{id}/revisions` endpoint, posting the rendered HTML as the
next revision. Hex orchestrates the run; Comma is the destination.

```bash
# At the end of your Hex notebook
curl -X POST https://commareports.com/api/v1/reports/$REPORT_ID/revisions \
  -H "Authorization: Bearer $COMMA_TOKEN" \
  -H "Content-Type: text/html" \
  --data-binary @./output.html
```

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

## What changes for reviewers

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

## What stays in Hex

- The warehouse connections and credentials.
- The SQL, Python, and chart cells.
- The semantic model and governed datasets.
- The Hex AI agents — Notebook agent, Threads agent.
- The history of how the analysis was built.

Comma doesn't try to replace any of this. The notebook 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 Hex 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.
5. **For Pattern 2: wire the routine.** From the Comma report, **Add
   routine →**. Pick a skill that wraps your Hex logic (or that calls Hex'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 Hex for what you use Hex for — editor seats on Professional
or Team. 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 upgrading from Hex
Professional to Hex Team just to get scheduled runs, 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 Hex 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 Hex](/vs/hex) — direct comparison of the two products
- [Hex alternatives](/alternatives/hex-alternatives) — the wider landscape
- [Routines](/features/routines) — Comma's hosted-cron primitive