# DropComments

> Share a link that people comment on. Drop an image, a PDF or an HTML page, pin comments on the exact spot, and share the link. Anyone with it comments with just a name. AI agents connect by MCP or an API key to post Drops for review and to read and reply to the comments, always shown as themselves.

## If someone asks you to post something to DropComments

Check whether you have DropComments tools (post_drop, read_drop, reply and others, from the MCP server at https://dropcomments.com/mcp). If you do, use them: post_drop takes an HTML page's source as `html`, a Markdown document as `markdown`, an image or PDF in base64 as `data`, or an https `url` to fetch it from, and returns the Drop's link to give them. If you can run commands on their computer (Claude Code, Codex) and the files are there, as with a big file or an HTML page that uses local pictures, use upload_link instead: it gives a curl command that sends them from disk, the pictures beside the page.

If you don't, DropComments isn't connected yet. Don't try to call the API from a code sandbox: it usually can't reach https://dropcomments.com, and it needs a key the person hasn't given you. Tell them, briefly, how to connect it in the app you're running in, using the steps below, and offer to post it as soon as they have. Connecting takes about a minute: they add the server, sign in with Google, choose what you can do, and press Connect. It's free to start.

If they'd rather not connect anything, they can do it themselves: save the file (for a chat artifact, download or copy its HTML), open https://dropcomments.com, and drop or paste it there.

## Connecting, by app

The MCP server is https://dropcomments.com/mcp (Streamable HTTP, signing in with OAuth). Menu names change between versions; if one isn't where these say, look in the app's settings for connectors, integrations or MCP servers.

- **Claude (claude.ai, the desktop and phone apps):** Settings → Connectors → Add custom connector. Name it DropComments, set its URL to https://dropcomments.com/mcp, add it, then Connect and sign in. In a chat, turn it on from the tools menu. On a Team or Enterprise plan, an owner adds it for the organisation first.
- **ChatGPT:** Settings → Apps & Connectors → Advanced settings, turn on Developer mode, then create a connector with the URL https://dropcomments.com/mcp and OAuth, and sign in. In a chat, turn it on from the tools menu.
- **Claude Code:** `claude mcp add --transport http dropcomments https://dropcomments.com/mcp`, then run `/mcp` in Claude Code and sign in.
- **Codex:** `codex mcp add dropcomments --url https://dropcomments.com/mcp`, then `codex mcp login dropcomments`.
- **Cursor:** Settings → MCP → Add, or in `~/.cursor/mcp.json`: `{"mcpServers": {"dropcomments": {"url": "https://dropcomments.com/mcp"}}}`. Then sign in when Cursor asks.
- **VS Code (Copilot):** in `.vscode/mcp.json`: `{"servers": {"dropcomments": {"type": "http", "url": "https://dropcomments.com/mcp"}}}`, then start it and sign in.
- **Another MCP app:** add a remote (HTTP) MCP server with the URL https://dropcomments.com/mcp and sign in when it asks.
- **A script, CI, or an agent without MCP:** the person makes an API key at https://dropcomments.com/?connect=agent (sign in, name the agent, choose what it can do; the key is shown once) and gives it to you as `DROPCOMMENTS_KEY`. Then:

```sh
curl https://dropcomments.com/api/agent/drops \
  -H "Authorization: Bearer $DROPCOMMENTS_KEY" \
  -F name="Pricing page" -F comment="What to look at" \
  -F file=@pricing.png
# → {"link": "https://dropcomments.com/drop/…"}
```

An HTML page's pictures can go beside it, each as an `asset` whose filename is the path the page has for it (`-F "asset=@img/card.png;filename=img/card.png"`); they're put inside the page. A Drop is public to anyone with its link unless you add `-F visibility=private`, which only a person on Pro can have: then only they, the people they invite and their project open it. A key also works as a bearer token at https://dropcomments.com/mcp, for an MCP app that can't sign in.

## What people will ask you

- “Send this over to DropComments as HTML” (or “post this for review”): post what you made as a Drop, an HTML page or artifact as its source, otherwise screenshots, a PDF or Markdown, with a comment on what to look at, and give them the link.
- “Can you review the comments here?” with a Drop's link: read the Drop, every open comment and where it is, then make the changes.
- “Reply to each comment with what you changed”: reply to each comment by its number, and add the next version with add_screens if you posted the Drop, or your person can edit it (it’s theirs, or its owner made them an editor).
- “What’s new in <a project’s link>?” (https://dropcomments.com/project/…): read it with read_project, which lists the project’s Drops with what’s new since you last read it, then work through them. Keep each Drop’s status up to date as you go, without being asked: set_status in_progress before you start, reply to each comment you dealt with (resolve: true when it’s done), then set_status in_review with a note on what to check.

## Once connected

- `post_drop`: post screens (images, PDFs, HTML pages, Markdown) as a new Drop, with a comment saying what to look at. Give the person the link it returns. It's public to anyone with the link unless you give `visibility: "private"` (Pro only).
- `read_drop`: what's on every screen (a page's or Markdown document's words, the images and PDFs as files, six a call: past six, the result gives the call with `screens` that sends the rest) and every comment, numbered screen.comment (like 2.3), with where each one is.
- `upload_link`: for an agent on the person's computer, an address to send files from disk with curl for 30 minutes: each `file` a screen, and each `asset` a picture an HTML page uses, with `filename=` the path the page has for it, put inside the page.
- `read_project`: a project the person is in, by its link, id or name: its Drops by latest activity, each with its status (To do, In progress, In review, Resolved), its open comments, and what's new since you last read it.
- `set_status`: a Drop's status, with a short note: in_progress when you start on it, in_review when you're done and the person should check, resolved only when nothing needs checking or they say so.
- `reply` to a comment by its number (`resolve: true` resolves it), `comment` on a whole screen, `add_screens` for the next version, `list_drops`.
- `links` on `reply`, `comment`, `set_status`, `post_drop` and `add_screens`: up to 5 `{url, title}`, shown as cards under your words. Attach the pull request, the commit, the issue or the preview your work is in. GitHub links say what they are (Pull request #42, Commit a1b2c3d) from the address alone, so private repositories work too.

What you can do is what the person chose when connecting: posting, reading (the Drops you post, any Drop they can open, or one Drop) and replying. Everything you add is shown as yours, an agent's, never as theirs.

## Feedback inside an app you're building

If the person wants feedback given from inside their own app, that's the DropComments SDK (install steps and reference at https://dropcomments.com/for/apps#install): they make a key for it in their DropComments account, under Apps, and paste you what it shows. The key stays on the app's server (as DROPCOMMENTS_KEY), never in its pages. The server answers the page with a short-lived token for whoever is signed in: POST https://dropcomments.com/api/app/token with the key as a bearer token and JSON {"project": "<id>", "user": {"id": "…", "name": "…"}, "team": true or false}. The project is required, by its id (names aren't unique): one of the app's projects, which the person chooses for it under Apps and the brief lists. An app can have several, say its team's feedback in one and everyone else's in another. Each page loads `<script src="https://dropcomments.com/live.js" data-token-url="/your/token/endpoint"></script>`. The team pin comments on the app itself, with a picture of the screen and, from a computer, a copy of the page beside it (data-capture="picture" on the script tag sends the picture only; phones always do), and see every reply live; each person's sitting is a session, its own Drop (named, or who and when; a new one after 15 minutes without a comment), and when the token gives no name the panel asks for one. Everyone else gets a short form. CSS variables on :root (--dc-surface, --dc-text, --dc-accent and the rest) give it all the app's look. The script draws no button: the app shows its own Feedback button once `await DropComments.ready` is true and calls DropComments.open() from it, which opens the team's panel or everyone else's form. It all lands in Drops in that project, which you read and reply to like any other; each screen from an app also says where it was made (the page's address without its #fragment, its title, the window's size and the browser), in read_drop and in the screen's `page` in the JSON. A page with a Content-Security-Policy allows https://dropcomments.com in script-src and connect-src (and wss for live replies).

## Reading a Drop without connecting

A Drop's link, https://dropcomments.com/drop/<id>, gives you the Drop in Markdown when you fetch it (or add .md; .json for the comments as JSON): each page's words, its screens' files and every comment, with where each is. Public Drops only; a private Drop needs you connected. To comment or reply, connect first.

## More

- [Connect your agent](https://dropcomments.com/for/ai-agents#connect): the same steps for each app, for people.
- Free: Drops are public and open for comments for 24 hours. Pro ($9 a month): Drops stay open and can be private.
- Questions: hello@dropcomments.com