# CommentWatchDog MCP server for Instagram and Facebook

> Connect Claude, ChatGPT or Cursor to your Instagram accounts and Facebook Pages. Ask in plain words to build DM automations, set up AI agents and remove spam comments. Nothing goes live, is sent or is removed without your yes.

- MCP address (remote, Streamable HTTP, OAuth sign-in): https://app.commentwatchdog.com/api/mcp
- Server name: commentwatchdog
- Start here: https://app.commentwatchdog.com/en/register?from=mcp (create an account or sign in, then Settings › MCP)
- This page for people: https://commentwatchdog.com/mcp
- How it reaches Instagram and Facebook: through Meta's official API, on the accounts and Pages connected to CommentWatchDog. It never asks for an Instagram or Facebook password and it does not scrape.

## Connect

Each app signs in once on a CommentWatchDog page with the person's account. There is no key to copy and no password to share. A person allows the app in a browser; an AI agent cannot create the account or give that consent itself.

### Claude

1. In Claude, open **Customize › Connectors** and choose **Add custom connector**.
2. Name it CommentWatchDog and paste this address:

   ```
   https://app.commentwatchdog.com/api/mcp
   ```

3. Choose Connect and allow it on the page that opens. Then turn it on in a chat from the tools menu.

On Team and Enterprise plans an Owner adds the connector first. It works in Claude on the web, the desktop app and the phone.

Full guide: https://commentwatchdog.com/mcp/claude.md

### ChatGPT

1. In ChatGPT, open **Plugins**, choose **+** and then **Add custom MCP server**.
2. Paste this address:

   ```
   https://app.commentwatchdog.com/api/mcp
   ```

3. Sign in with your CommentWatchDog account and allow it. Then ask it in any chat.

Whether you can add your own servers depends on your ChatGPT plan and, in a workspace, on its admin.

Full guide: https://commentwatchdog.com/mcp/chatgpt.md

### Claude Code

1. Run this in your terminal:

   ```
   claude mcp add --transport http commentwatchdog https://app.commentwatchdog.com/api/mcp
   ```

2. Open Claude Code, type `/mcp`, choose commentwatchdog and Authenticate.
3. Allow it on the page that opens. Then open a flow and ask for a change: you watch every step land on the canvas.

Full guide: https://commentwatchdog.com/mcp/claude-code.md

### Codex

1. Run this in your terminal:

   ```
   codex mcp add commentwatchdog --url https://app.commentwatchdog.com/api/mcp
   ```

2. Then sign in:

   ```
   codex mcp login commentwatchdog
   ```

3. Allow it on the page that opens. Codex can now work in your account.

Full guide: https://commentwatchdog.com/mcp/codex.md

### OpenClaw

1. Add CommentWatchDog to OpenClaw.

   ```
   openclaw mcp set commentwatchdog '{"url":"https://app.commentwatchdog.com/api/mcp","transport":"streamable-http","auth":"oauth"}'
   ```

2. Sign in. OpenClaw opens a CommentWatchDog page in your browser. Sign in, or create your account there, and press **Allow**. The browser hands the sign-in back to OpenClaw by itself.

   ```
   openclaw mcp login commentwatchdog
   ```

3. Check it. OpenClaw lists every CommentWatchDog tool it can now use.

   ```
   openclaw mcp probe commentwatchdog
   ```


Full guide: https://commentwatchdog.com/mcp/openclaw.md

### Hermes

1. Add CommentWatchDog to Hermes. It opens a CommentWatchDog page in your browser: sign in, or create your account there, and press **Allow**.

   ```
   hermes mcp add commentwatchdog --url https://app.commentwatchdog.com/api/mcp --auth oauth
   ```

2. Hermes waits about 30 seconds for the Allow. Making an account takes longer, so if it stopped waiting, sign in again and press **Allow**. Hermes answers that it is authenticated and how many tools it has.

   ```
   hermes mcp login commentwatchdog
   ```


Full guide: https://commentwatchdog.com/mcp/hermes.md

### Goose

1. In Goose Desktop open **Extensions › Add custom extension**. In the terminal run `goose configure` and choose **Add Extension › Remote Extension (Streamable HTTP)**.
2. Name it `commentwatchdog` and paste this address:

   ```
   https://app.commentwatchdog.com/api/mcp
   ```

3. Goose opens your browser the first time it connects. Press **Allow** on the CommentWatchDog page, then use it in a Goose session.

Full guide: https://commentwatchdog.com/mcp/goose.md

### OpenCode

1. Add the server for every folder.

   ```
   opencode mcp add commentwatchdog --url https://app.commentwatchdog.com/api/mcp --global
   ```

2. Sign in. Press **Allow** on the CommentWatchDog page that opens.

   ```
   opencode mcp auth commentwatchdog
   ```

3. Ask it: "List my CommentWatchDog channels." It should answer from your account. You can also run `opencode mcp list` to see it connected.

Full guide: https://commentwatchdog.com/mcp/opencode.md

### GitHub Copilot CLI

1. Add the server.

   ```
   copilot mcp add --transport http commentwatchdog https://app.commentwatchdog.com/api/mcp
   ```

2. Start `copilot`. It opens the CommentWatchDog sign-in in your browser by itself: press **Allow** on the CommentWatchDog page that opens.
3. Ask it: "List my CommentWatchDog channels." It should answer from your account.

Full guide: https://commentwatchdog.com/mcp/copilot-cli.md

### Cursor

1. Add it in one click: One-click link: cursor://anysphere.cursor-deeplink/mcp/install?name=commentwatchdog&config=eyJ1cmwiOiJodHRwczovL2FwcC5jb21tZW50d2F0Y2hkb2cuY29tL2FwaS9tY3AifQ%3D%3D
2. Or put this in **~/.cursor/mcp.json**:

   ```
   {
     "mcpServers": {
       "commentwatchdog": {
         "url": "https://app.commentwatchdog.com/api/mcp"
       }
     }
   }
   ```

3. In Cursor's MCP settings, choose Connect next to commentwatchdog and allow it.

Full guide: https://commentwatchdog.com/mcp/cursor.md

### VS Code

1. Add it in one click: One-click link: vscode:mcp/install?%7B%22name%22%3A%22commentwatchdog%22%2C%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fapp.commentwatchdog.com%2Fapi%2Fmcp%22%7D
2. Or run this in your terminal:

   ```
   code --add-mcp '{"name":"commentwatchdog","type":"http","url":"https://app.commentwatchdog.com/api/mcp"}'
   ```

3. Start commentwatchdog in the MCP view, allow it on the page that opens, then use it in Copilot Chat's agent mode.

Full guide: https://commentwatchdog.com/mcp/vscode.md

### Gemini CLI

1. Run this in your terminal (add `-s user` to have it in every folder):

   ```
   gemini mcp add --transport http commentwatchdog https://app.commentwatchdog.com/api/mcp
   ```

2. Then, inside Gemini CLI:

   ```
   /mcp auth commentwatchdog
   ```

3. Allow it on the page that opens.

Full guide: https://commentwatchdog.com/mcp/gemini-cli.md

### n8n

1. In a workflow add an **AI Agent** node, press **Tool +** and pick **MCP Client Tool**. Set **Endpoint** to this address and **Server Transport** to **HTTP Streamable**.

   ```
   https://app.commentwatchdog.com/api/mcp
   ```

2. Set **Authentication** to **MCP OAuth2**. Create the credential and leave **Use Dynamic Client Registration** on. Connect it and press **Allow** on the CommentWatchDog page that opens.
3. Pick **Tools to Include** (All, Selected or All Except). The node has no server name field, so rename the node `commentwatchdog`.

Full guide: https://commentwatchdog.com/mcp/n8n.md

### Windsurf

1. Open the MCP config file: **~/.config/devin/mcp_config.json** (Windsurf is now Devin Desktop), or **~/.codeium/windsurf/mcp_config.json** on older versions.
2. Add this:

   ```
   {
     "mcpServers": {
       "commentwatchdog": {
         "serverUrl": "https://app.commentwatchdog.com/api/mcp"
       }
     }
   }
   ```

3. Refresh the MCP list, then sign in when it asks and allow it.

Full guide: https://commentwatchdog.com/mcp/agents.md

### Cline

1. In Cline, open **MCP Servers** and choose **Configure MCP Servers**.
2. Add this:

   ```
   {
     "mcpServers": {
       "commentwatchdog": {
         "type": "streamableHttp",
         "url": "https://app.commentwatchdog.com/api/mcp"
       }
     }
   }
   ```

3. Sign in when Cline asks and allow it.

Full guide: https://commentwatchdog.com/mcp/cline.md

### Another app

1. Any app that supports remote MCP servers (Streamable HTTP) connects to this address:

   ```
   https://app.commentwatchdog.com/api/mcp
   ```

2. It signs in on its own with OAuth: you allow it on a CommentWatchDog page, nothing to paste.
3. If your app cannot sign in that way, make a key in Settings › MCP and send it as a Bearer header.

Full guide: https://commentwatchdog.com/mcp/agents.md

Building your own agent? If it cannot open a browser to sign in, an Owner or Administrator makes a key under Settings › MCP and the agent sends it as a Bearer header. The key is shown once and has an end date. Who can connect: Owner, Administrator or Manager. Disconnect any app in Settings › MCP and it stops at once.

## What you can ask

### Build automations and flows

Example: "When someone comments TASTING, reply with a button to book, ask how many are coming and tag them."

It builds on your real canvas. Keep the flow open in your browser and every step lands while you watch. It tests the flow before it offers to turn it on.

Built paused. Going live waits for your yes.

### Set up AI agents

Example: "Make an agent from our shipping page and price list, then try it on three questions."

It reads your link, file or text into the agent's knowledge, checks what was read, and asks it real questions so you see the answers before a customer does.

Each try uses 1 AI credit, so it runs a few and asks before more.

### Clean up comments, new and old

Example: "Check my best ad from last year and delete the spam under it."

It finds comments by words, a pattern, the author, the post or a period, one or thousands at once, and shows who wrote them. Old posts and ads go through Post cleanup, checked against your own rules.

It names the credits a check uses before it starts.

| Area | Ask it to | For example |
| --- | --- | --- |
| Automations | Build, change, test and turn on comment to DM, keyword replies, the welcome message and story replies | "When someone comments PRICE on my latest reel, send them the price list in a DM." |
| Flows | Build a flow with questions, branches, lead capture and HTTP steps, test it on the simulator, fix it | "Ask people for their email, then tag them as leads." |
| AI agents | Create an agent, give it knowledge from a link, a file or text, try it, answer its drafts | "Make an agent from our pricing page and test it on three questions." |
| Moderation | Read and change the rules per page, try a comment against them, copy them to other pages | "Hide links and crypto spam on my ads, and copy that to the Instagram account." |
| Comments | Find by words, a regex, the author, the post or a period. Then hide, delete, reply, send a private reply, block or ban | "Find every comment with a WhatsApp number from this week and hide them." |
| Post cleanup | Open an old post or ad, check its comments against your rules, then delete, hide, block or ban what it found | "Check my best ad from last year and delete the spam under it." |
| Results | Read what moderation caught and what each automation did, and explain a run | "Why did Ana not get the DM yesterday?" |
| People | Find people, read their tags and fields, change or export them | "How many people gave their email this month?" |

## It asks before it acts

Reading and building happen at once. Anything that goes live, reaches people or removes something waits for the person's yes, in their own words, in the chat.

| It does at once | It asks you first |
| --- | --- |
| Read pages, automations, flows, agents, rules, results and comments | Turn an automation or flow live, pause it, or change it while live |
| Build and change paused automations and flows, and test them | Delete, reply, send a private reply, block or ban |
| Hide, unhide, unblock and unban when no credits are used | Anything that uses comment credits, with the number shown first |

- Before a yes, it shows its work: How many comments or people, a sample of who and what, and the credits it uses.
- Same reply to many people: At most 200 comments a request and 1,000 a day, sent one every 3 seconds, so Meta never reads it as spam.
- Blocking: At most 100 people a request. Ban has no limit: CommentWatchDog hides everything a banned person writes.
- Instagram: Instagram lets no app block. Ban works there.
- Your role and your plan apply: The AI can do what you can do. A feature your plan does not include stays closed.
- What stays in the app: Billing, teammates and answering in the inbox.

## Cost

| What it does | Credits |
| --- | --- |
| Connecting an AI app, on every plan | None |
| Building, testing and searching | None |
| Checking comments against your rules (Post cleanup) | Comment credits, [the same as in the app](https://commentwatchdog.com/credits). It tells you how many before it starts. |
| Acting on a comment your plan never counted | 1 comment credit the first time anything acts on it, the same as in the inbox |
| Anything an AI writes: agent replies, translations | AI credits, the same as in the app |

## Questions

### What is the CommentWatchDog MCP server?

It is a remote MCP server that lets an AI app such as Claude or ChatGPT work in your CommentWatchDog account. You ask in plain words and it builds and tests Instagram and Facebook automations, sets up AI agents and moderation, and finds, hides, deletes or answers comments. The address is https://app.commentwatchdog.com/api/mcp.

### Which AI apps work with it?

Claude, ChatGPT, Claude Code, Codex, OpenClaw, Hermes, Goose, OpenCode, GitHub Copilot CLI, Cursor, VS Code, Gemini CLI, n8n, Windsurf, Cline, and any app that supports remote MCP servers over Streamable HTTP.

### Do I need an API key?

No. Each app signs in with OAuth: you allow it on a CommentWatchDog page and nothing is pasted. A key is only for your own agent or script that cannot open a browser.

### Can the AI delete comments or message my customers without asking?

No. Deleting, replying, sending a private reply, blocking and banning always take two steps. It shows how many and a sample, and goes ahead only after your yes in the chat.

### Does it cost more to work through an AI?

No. Connecting is free on every plan, and so are building, testing and searching. Comment credits and AI credits are charged exactly as in the app.

### Can it clean up comments on old posts and ads?

Yes, through Post cleanup. It opens the post or ad, checks its comments against your rules, and deletes, hides, blocks or bans what it found after your yes.

### How do I disconnect an app?

In Settings › MCP, under Connected apps, choose Disconnect next to it, or Disconnect all. It stops working at once.

## All 100 tools

- `start_here`: CommentWatchDog's full instructions and what this account has right now
- `run_tool`: Run any CommentWatchDog tool by its name, also one added after your app loaded its tool list (an update notice or search names it)
- `list_channels`: The workspace, the signed-in person, and every connected channel (each Instagram account and Facebook Page) with its state (ready, or why not and how…
- `connect_channel`: Connect an Instagram account or Facebook Page that the person's Meta login already shares but that is not connected yet (list_channels
- `use_channel`: Set the channel (one Instagram account or Facebook Page from list_channels) this AI builds on, as the person said
- `current_flow`: The flow the person has open in the CommentWatchDog editor in their browser right now ("the chatbot I have open"), described like get_flow with its…
- `list_flows`: The chatbot flows on the chosen channel (or the one named; page "all" for every channel), newest change first
- `get_flow`: One flow as it is now
- `get_step`: One step of a flow in full
- `values_at`: What a step can read, before you write a {{value}} or a condition rule there
- `create_flow`: A new, empty, paused chatbot flow on the chosen channel (only its start)
- `duplicate_flow`: A paused copy of a flow, in one call
- `list_posts`: Find the chosen channel's posts, reels and ads
- `get_post`: One post in full
- `list_stories`: The Instagram stories live right now (the last 24 hours; Instagram lists nothing older), newest first
- `set_post`: Which posts a comment flow answers on
- `rename_flow`: Give a flow a new name
- `get_guide`: HOW TO BUILD
- `get_practices`: Good practice for building, where the person said nothing
- `apply_changes`: Change a paused flow
- `finish`: End a piece of work
- `set_live`: Turn a flow or a basic automation LIVE (it starts answering real people on Instagram or Facebook) or pause it
- `describe_step`: One step type in full
- `describe_trigger`: One start type in full (comment, dm, story, share, link, welcome, …)
- `describe_rule`: One condition rule kind in full, with its settings and examples
- `search`: Search EVERYTHING CommentWatchDog can do, when you are not sure what exists or which tool to use
- `get_account`: The workspace's plan and what it allows right now
- `find_steps`: Which step types do something ("ask for an email", "wait a day", "check if they follow")
- `get_limits`: The platform's limits (text lengths, buttons, cards, waits) a flow must stay within
- `can_connect`: Whether a way out of one step may lead to another step, and why not
- `list_fields`: The workspace's custom fields (where answers are kept)
- `list_tags`: The workspace's tags, with how many people carry each and which flows use it
- `list_agents`: The workspace's AI agents (an agent step answers or talks as one of them)
- `get_business`: What the business has written about itself for this page (its agents' knowledge
- `find_service`: Free web services already proven to work (weather, currency, …) for an HTTP step
- `create_tag`: Make a new tag in the workspace (a step may only use a tag that exists)
- `create_field`: Make a new custom field (where an answer is kept on the person)
- `simulate`: Walk one made-up person through the flow on the simulator of the real engine (nothing is sent, nothing is kept)
- `check_flow`: Test the whole flow
- `list_runs`: What real people went through this flow or basic automation (newest first), with counts
- `get_results`: How the automations are doing, across all of them (every kind, not only flows), or the ones "automation" names (an id, words of a name, or a keyword…
- `explain_run`: One real run of a flow or a basic automation step by step, in words
- `http_test`: Run one HTTP step of the flow for real from the server, with sample values for its {{variables}}, through the same guarded call the engine makes
- `get_agent_guide`: READ THIS FIRST before creating or changing an AI agent
- `get_agent`: Everything about one AI agent
- `create_agent`: Create an AI agent (the plan must include agents and have room for one more)
- `update_agent`: Change an agent
- `add_knowledge`: Add knowledge you extracted yourself (from a website, a PDF, a doc, the person's words) as one text source
- `read_link`: FALLBACK when you could not read a page yourself
- `read_file`: FALLBACK when you could not extract a file yourself
- `get_source`: The full text of one knowledge source as the agent uses it, to VERIFY a page or file was read properly (are the prices, plans, policies and contact…
- `edit_source`: Correct a source's text (a wrong price, a missing line, cut what customers never ask about)
- `remove_source`: Remove a knowledge source (a page that failed, a duplicate, one replaced by a shorter text)
- `reread_source`: Read a web page source again (it changed, or the last read failed for a passing reason such as a timeout)
- `check_agent`: Is the agent ready? Free
- `test_agent`: Ask the agent a made-up customer comment or DM and see exactly what it would answer (or why it would hand over to a person)
- `list_automations`: The basic automations (not flows) on the chosen channel, or the one named, or page "all"
- `describe_automation`: One kind of basic automation in full, before you create one (and before choosing a flow
- `get_automation`: One basic automation as it is now
- `current_automation`: The basic automation the person has open in the CommentWatchDog editor in their browser right now ("the one I have open", "this automation")…
- `create_automation`: Make a basic automation on the chosen channel, PAUSED (it answers nobody until the person says yes to set_live)
- `update_automation`: Change a basic automation
- `duplicate_automation`: A paused copy of a basic automation
- `test_automation`: Test a basic automation (flows
- `send_to_earlier`: Send a LIVE comment → DM automation to the people who already commented before it went live (the last 7 days, on the posts it covers, each person…
- `pause_automations`: Pause several live automations and flows at once (ids from list_automations / list_flows, or all:true for every live one on the channel)
- `save_topic`: Make a topic, or change one (id)
- `test_topic`: Would this message count as the topic? topic (an id from list_topics) or name + about + examples (an unsaved one), and text
- `list_topics`: The workspace's topics (what comments or DMs are about, decided by AI)
- `describe_moderation`: How comment moderation works, before setting it up or changing it
- `get_moderation`: Read a channel's comment moderation settings
- `test_moderation`: Run a made-up comment through a channel's moderation with the live engine (AI rules included) and say what would happen
- `update_moderation`: Set up or change a channel's comment moderation
- `copy_moderation`: Put one channel's moderation settings on other connected channels (their own settings are REPLACED)
- `find_comments`: Search the comments on the channel (or "all") the way the inbox does, to answer "what are people saying" or to pick comments to act on
- `moderate_comments`: Act on real comments, one or thousands at once
- `comment_task`: How a moderate_comments or cleanup_act task is going (done, waiting on Meta's rate limit, failed and why), or stop it with cancel
- `banned_people`: Who is banned (CommentWatchDog hides every comment they write) and who is blocked on Facebook (through CommentWatchDog), per channel or "all", with…
- `cleanup_posts`: The posts and ads Post cleanup knows on every connected channel, OLD ones included (the inbox only has comments from after a channel was connected)
- `cleanup_open`: Read one post or ad and all its comments (replies included) for Post cleanup
- `cleanup_comments`: Search the comments of a post Post cleanup has read (cleanup_open first)
- `cleanup_check`: Check the comments of up to 5 posts against the channel's own moderation rules (its filters, keywords, allowed links, whitelist, custom instructions)
- `cleanup_act`: Act on the comments of ONE post Post cleanup has read
- `find_people`: The people who messaged or commented (People in the app), newest first, 50 at a time
- `get_person`: One person in full
- `change_people`: Change people in People
- `save_segment`: Save a segment of People (a filter kept by name, shown on the People page and usable as find_people {segment})
- `forget_people`: Forget people for good (a privacy request
- `list_drafts`: The AI agents' drafts waiting for a person
- `answer_draft`: Send an agent's draft (as written, or with text
- `remove`: Remove something
- `restore`: Bring an archived automation or flow back, PAUSED (set_live turns it on with the person's yes)
- `rename_tag`: Rename a tag everywhere it is named
- `flow_versions`: A flow's saved versions, newest first (each save that changed it, with what changed and who), or with version
- `restore_version`: Put a PAUSED flow back to an earlier version (flow_versions)
- `get_moderation_results`: What moderation did on the channel (or "all") over a period
- `set_sending`: How fast a channel sends its automatic first DMs and public replies (per_hour
- `saved_replies`: The channel's saved replies (the ready answers teammates insert in the inbox)
- `list_media`: The workspace's media library
- `add_media`: Store a file in the workspace's media library from a public link (the person's own file
