Send client comments to Slack, Linear or GitHub.

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).
• An account. Webhooks live in the dashboard at app.stacktr.ee/settings, 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, 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

1. Open Settings in the dashboard and go to Webhooks.
2. Paste the URL under Send to, and give it a name you will recognise under Name it, such as "Acme comments in Slack".
3. 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.
4. Under For, keep Every page, or choose One client or One page to give a client's comments their own channel.
5. Choose Add webhook. The row shows a Slack messages or Discord messages tag.
6. 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.

1. 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.
2. 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).
3. 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).
4. 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 }}

5. 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, 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

1. Create a Zap whose trigger is Webhooks by Zapier with the event Catch Hook, and copy the webhook URL Zapier gives you.
2. Add it in Stacktree with only Comment left on a page on, then choose Send test event.
3. Back in Zapier, test the trigger. It finds the sample comment.
4. 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.
5. Publish the Zap.

Make

1. Start a scenario with the Webhooks app's Custom webhook module, add a webhook and copy its address.
2. 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.
3. Add the Linear or GitHub module that creates an issue and map the same fields.
4. 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 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 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.