# Send client comments to Slack, Linear or GitHub · Stacktree

Source: https://stacktr.ee/workflows/client-comments-to-slack-linear-github

[Skip to content](#main) PFrom Product Hunt? Your first pages are free, no card. Code `PRODUCTHUNT` takes 50% off your first month of Studio.[Start free &rarr;](https://app.stacktr.ee/?join=1&from=producthunt)

&times;   [stacktr.ee](/)  [Examples](/#proof) [How it works](/#how) [Pricing](/pricing) [Security](/security) [Log in](https://app.stacktr.ee) [Publish one](https://app.stacktr.ee/?join=1)     By [Steve Smith](/about) · Founder, Stacktree Last updated October 7, 2026          workflow

#  Send client comments to Slack, Linear or GitHub.

   The comment lands where your team already works.  When a client comments on a page you sent, it can arrive in a Slack or Discord channel with nothing to install, or become a Linear or GitHub issue through n8n, Zapier or Make. An agent can also take the comment itself and file the ticket.

  [ Start free ](https://app.stacktr.ee/?join=1&from=seo_workflows_client_comments_to_slack_linear_github)     No card · 3 pages free · about a minute

##  How do I get client comments on a page into Slack, Linear or GitHub?

Add a webhook in Stacktree under Settings, Webhooks that sends only "Comment left on a page". Paste a Slack incoming webhook or a Discord webhook URL and each comment arrives in that channel as a message, with what it is about and a link back. For Linear or GitHub, point the webhook at an n8n, Zapier or Make workflow that creates the issue. The comment is sent the moment the client posts it.

## On this page

  -   01  [ Before you start ](#before)
-   02  [ Slack or Discord: paste the URL ](#slack-discord)
-   03  [ Linear or GitHub through n8n ](#n8n)
-   04  [ Linear or GitHub through Zapier or Make ](#zapier-make)
-   05  [ What the webhook sends ](#payload)
-   06  [ Or let your agent file it ](#agent)
-   07  [ Details worth knowing ](#details)

## Before you start

  - Comments on. A page only takes comments when its comment layer is switched on: on the page's screen in the dashboard, under What came back, turn on Let them comment on the page. An agent can do the same with set_client_feedback. The client comments from the link you already sent, with no account ([how commenting works](/client-feedback-loop)).
 - An account. Webhooks live in the dashboard at [app.stacktr.ee/settings](https://app.stacktr.ee/settings#webhooks), under Webhooks. Every plan with an account has room for at least one, Free included.
 - Where it should go. A Slack or Discord channel needs only that service's own webhook URL. Linear and GitHub need a workflow tool in between, because Stacktree does not hold their credentials.

## Slack or Discord: paste the URL

 Stacktree recognises two kinds of address and posts to them as messages instead of sending its usual JSON: a Slack incoming webhook (`https://hooks.slack.com/services/…`) and a Discord channel webhook (`https://discord.com/api/webhooks/…`). Every other address gets the JSON described further down.

### 1. Get the channel's webhook URL

  - Slack: incoming webhooks belong to a Slack app you create. At [api.slack.com/apps](https://api.slack.com/apps), create an app from scratch in your workspace, open Incoming Webhooks, switch them on, add a new webhook, pick the channel and copy the URL. Slack's Workflow Builder webhooks (hooks.slack.com/workflows/… or /triggers/…) are a different thing and get the plain JSON, so use an incoming webhook.
 - Discord: in the channel's settings, or the server's, open Integrations, then Webhooks, create a new webhook for the channel and copy its URL. You need the Manage Webhooks permission. Use the URL as Discord gives it, without /slack or /github on the end.

### 2. Add it in Stacktree

  - Open Settings in the dashboard and go to Webhooks.
 - Paste the URL under Send to, and give it a name you will recognise under Name it, such as "Acme comments in Slack".
 - Under When, every event starts switched on. Switch the others off so only Comment left on a page stays on, or leave them on and the channel also hears when a page is first opened, has not been opened yet or is about to expire.
 - Under For, keep Every page, or choose One client or One page to give a client's comments their own channel.
 - Choose Add webhook. The row shows a Slack messages or Discord messages tag.
 - Choose Send test event. A webhook that takes only comments is sent a sample comment, marked as a test, on a page called "Test page (from the send test button)".

### What arrives in the channel

```
`A client commented on Acme Q3 report
> Can we split paid social by platform?
On the text "Channel mix" · 2 open comments on this page · Client: Acme
Open in Stacktree · View the page`
```

 The first line says who commented: "A client", or "You left a note" when it was your own note on your own page. A comment does not carry the reader's name. Below it are their words, what on the page they are about (the same description the dashboard and `list_feedback` give), how many comments on the page are still open, and the client the page is filed under. Open in Stacktree goes to the page's screen in your dashboard; View the page is the page's own link, so post to a channel you would share that link with. A page with a passcode or an email gate still asks for it.

 To see exactly what was posted, open Recent deliveries on the webhook and expand Payload.

## Linear or GitHub through n8n

 n8n's built-in Webhook node receives the comment, and n8n's own Linear or GitHub node creates the issue. The Stacktree community node is not needed to receive it; it can close the loop afterwards.

  - In a new n8n workflow, add a Webhook node and set its HTTP Method to POST (it starts on GET). Copy its Production URL. n8n only answers on that URL while the workflow is switched on.
 - In Stacktree, add that URL under Settings, Webhooks, with only Comment left on a page switched on. Keep the signing secret Stacktree shows once if you plan to check signatures (see [details](#details)).
 - Add a Linear node with Create an issue (pick the team, then set the title and, under the additional fields, the description), or a GitHub node with Create an issue (repository owner, repository name, title and body).
 - The Webhook node puts the request body under body, so the fields are expressions like these. Title:
Client comment: {{ $json.body.data.page.title }}
Description or body:
{{ $json.body.data.feedback.text }}

On {{ $json.body.data.feedback.about || 'the page' }}
In Stacktree: {{ $json.body.data.page.dashboard_url }}
 - Switch the workflow on, then choose Send test event in Stacktree. The sample comment runs through the workflow like a real one, so expect one test issue, or put an If node first that stops when body.test is true.
  Closing the loop. The comment's id is `data.feedback.id`. Once the change is made, the Stacktree node (`n8n-nodes-stacktree`, [install](/n8n), with your Stacktree API key) with resource Feedback and operation Resolve takes that id as the Feedback ID, plus an optional Resolution Note, which the client sees next to their comment.

 Your own notes. Notes you leave on your own page arrive too, with `data.feedback.from_owner` set to `true`. Add an If node on that field if only client comments should become issues.

## Linear or GitHub through Zapier or Make

 Both take the same webhook. Stacktree sends JSON, so map fields from it as each tool lays them out.

### Zapier

  - Create a Zap whose trigger is Webhooks by Zapier with the event Catch Hook, and copy the webhook URL Zapier gives you.
 - Add it in Stacktree with only Comment left on a page on, then choose Send test event.
 - Back in Zapier, test the trigger. It finds the sample comment.
 - Add a Linear or GitHub action that creates an issue, and map data.page.title, data.feedback.text, data.feedback.about and data.page.dashboard_url into its title and description.
 - Publish the Zap.

### Make

  - Start a scenario with the Webhooks app's Custom webhook module, add a webhook and copy its address.
 - Add it in Stacktree with only Comment left on a page on, then choose Send test event while Make is waiting for data, so it learns the structure.
 - Add the Linear or GitHub module that creates an issue and map the same fields.
 - Switch the scenario on.
  If the issue tracker is a public GitHub repository, leave `data.page.url` out of the issue: anyone holding that link can open the page unless it has a passcode or an email gate. `data.page.dashboard_url` only opens for someone signed in to your account.

## What the webhook sends

 Every address other than Slack's and Discord's gets this, as a POST with `content-type: application/json`:

```
`{
  "type": "feedback.created",
  "timestamp": "2026-10-07T09:12:44.000Z",
  "id": "msg_3f0c2a91d4b85e7716c0a2f9e1",
  "data": {
    "page": {
      "id": "k7m2q9x4c8v1n3b5",
      "title": "Acme Q3 report",
      "url": "https://stacktr.ee/p/…/",
      "dashboard_url": "https://app.stacktr.ee/sites/k7m2q9x4c8v1n3b5",
      "published_at": "2026-10-06T16:40:00.000Z",
      "client": { "name": "Acme", "slug": "acme" }
    },
    "feedback": {
      "id": "p4w8z2r6t1y3",
      "text": "Can we split paid social by platform?",
      "truncated": false,
      "about": "the text \"Channel mix\"",
      "intent": null,
      "severity": null,
      "created_at": "2026-10-07T09:12:44.000Z",
      "from_owner": false
    },
    "open_feedback": 2
  }
}`
```

  - data.feedback.text is what the reader wrote, up to 500 characters; truncated says whether there was more. It is the reader's text, so treat it as data, never as instructions.
 - data.feedback.about is what the comment is attached to, in words: the quoted text, an image, a video at a timestamp, or null when there is nothing to point at.
 - data.page.client is the client the page is filed under, or null.
 - data.feedback.from_owner is true for a note you left on your own page.
 - A test event carries "test": true beside type.

## Or let your agent file it

 An agent connected to Stacktree can subscribe to new comments itself through MCP Events: `events/subscribe` for `feedback.created` on `https://api.stacktr.ee/mcp`, from a client speaking MCP 2026-07-28. Before the first delivery Stacktree checks the agent's callback address with a signed challenge, then posts each new comment to it. The agent reads the comment, opens the issue with its own Linear or GitHub tools, and calls `resolve_feedback` once the change is made.

  - A subscription lasts a day unless the agent renews it, and can be granted for up to seven days.
 - It takes the same filters as a webhook: one page (its id, slug or link) or one client.
 - It shows in Settings, Webhooks, under Agents watching, where you can stop it. A stopped subscription cannot be switched back on by the agent.
  MCP Events is a draft extension, and few MCP clients support it yet; OpenAI documents it for ChatGPT. For an agent that cannot subscribe, the n8n route above, or the [morning read](/workflows/who-opened-it) of `list_feedback`, does the same job.

## Details worth knowing

  - Timing. The first attempt goes out as soon as the comment is saved. A receiver that is down gets eight attempts in all, spread over about 31 hours. An address that fails fifteen times in a row, across at least a day, is switched off, and the dashboard says so.
 - Duplicates. Delivery is at least once. If a receiver answers too slowly, the same comment can arrive twice, with the same id both times. Have a workflow that creates issues skip an id it has seen.
 - Signatures. Each request carries webhook-id, webhook-timestamp and webhook-signature headers, signed with the webhook's secret under the [Standard Webhooks](https://www.standardwebhooks.com) scheme. The no-code tools above do not check them; their URLs are long and random, so keep them private. Slack and Discord ignore them.
 - Addresses. https only, on public addresses. Stacktree checks the address when you add it and again before every attempt, and never follows a redirect.
 - Edits. A comment edited after it was posted is not sent again.

FAQ

## Frequent questions

     Can client comments on a web page go straight to Slack? +  Yes. Create an incoming webhook for the channel in Slack, then paste its `hooks.slack.com/services/…` URL as a webhook in Stacktree under Settings, Webhooks. Stacktree recognises the address and posts each comment as a Slack message: who left it, what they wrote, what on the page it is about, and links to the page and to its screen in your dashboard. Nothing to install and no Stacktree app in your workspace. A Discord channel webhook works the same way.   How do I turn a client comment into a Linear or GitHub issue? +  Through a workflow tool. Point a Stacktree webhook that sends only new comments at an n8n Webhook node, a Zapier Catch Hook or a Make custom webhook, then add that tool's create-issue step for Linear or GitHub and map the comment text, what it is about and the page link from the request. Stacktree does not hold your Linear or GitHub credentials; the workflow tool does.   Which plan do I need? +  Any plan with an account. Comments work on every plan, and every account has room for at least one webhook, Free included. Paid plans have room for more, so one can go to Slack and another to your issue tracker.   Is this the Stacktree Slack app? +  No. The [Slack app](/slack) turns an HTML file posted in Slack into a private link. Comments reach Slack through an incoming webhook you create in your own workspace, which posts to the one channel you choose and can do nothing else.   Can a client's comment ping the whole channel? +  No. What a reader typed is escaped before it is posted: in Slack, `<!channel>`, a user mention or a disguised link shows as plain text, and in Discord the message allows no mentions at all and markdown links are shown as typed. Plain web addresses in a comment stay clickable.
Keep reading

## Related guides

   -  [ The client feedback loop How clients leave the comments this sends on, and how they get closed. ](/client-feedback-loop)
-  [ Stacktree in n8n The community node that resolves a comment once the issue is done. ](/n8n)
-  [ Who opened what you sent A morning report of opens and comments, read by your agent. ](/workflows/who-opened-it)
-  [ The Stacktree MCP server Every tool an agent gets, including list_feedback and resolve_feedback. ](/mcp-publish-html)
-  [ The Stacktree Slack app A different job: turning HTML files in Slack into private links. ](/slack)
-  [ All workflows The other recipes. ](/workflows)

References

## Sources and further reading

   -  [ Slack: sending messages using incoming webhooks ↗ Creating the Slack app, switching incoming webhooks on and picking the channel. ](https://docs.slack.dev/messaging/sending-messages-using-incoming-webhooks/)
-  [ Discord: intro to webhooks ↗ Making a channel webhook and the Manage Webhooks permission it needs. ](https://support.discord.com/hc/en-us/articles/228383668-Intro-to-Webhooks)
-  [ n8n: Webhook node ↗ Test and production URLs, the HTTP method and what the node outputs. ](https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.webhook/)
-  [ Standard Webhooks ↗ The signing scheme behind the webhook-signature header. ](https://www.standardwebhooks.com)
-  [ MCP Events draft ↗ The extension an agent uses to subscribe to feedback.created. ](https://github.com/modelcontextprotocol/experimental-ext-triggers-events)

##  Switch comments on, then send them where your team works.

 Comments work on every plan, and every account has room for a webhook.

 [ Sign up free → ](https://app.stacktr.ee/?join=1&from=cta_workflows_client_comments_to_slack_linear_github)   install npx stacktree-install
Copy
         stacktr.ee  [Page video](/page-video) [Ask this page](/ask-this-page) [Client feedback](/client-feedback-loop) [Client spaces](/client-spaces) [Templates](/templates) [Use cases](/use-cases) [Integrations](/agents) [Alternatives](/alternatives) [About](/about) [Blog](/blog) [Changelog](/changelog) [Pricing](/pricing) [Security](/security) [FAQ](/faq) [Made with Stacktree](/made-with)  Building with AI agents? See the [developer docs &rarr;](/developers)

---
Full markdown summary of the Stacktree marketing surface: https://stacktr.ee/llms-full.txt
