Customer testimonial pipeline: Intercom → Notion → Slack → Gmail

Create the app and generate an Access Token

developers.intercom.com → sign in → Developer Hub → Your Apps → New app, pick the workspace this reads from. A private app that only reads its own paid workspace's data skips Intercom's review process. Open the app → Authentication tab → generate the Access Token (Bearer).

Scope Permissions to Conversations: Read — nothing else

Permissions tab → turn on Conversations: Read and leave every other resource off: no Contacts, no Tags, no Write of any kind. GET /conversations/{id} already returns source.author.{id,type,name,email} inline, so the customer's email never needs a separate /contacts call, and this flow only ever writes to Notion — it never tags, notes, or replies inside Intercom itself.

Create the trigger tag — a name your team invents

Settings → Tags → New tag. Pick any name your team already uses for praise or an NPS recommendation — customer-love below is an example only, not an Intercom-built-in value. A support agent applying that tag to a conversation in the Inbox is the one human action that starts this whole flow.

Subscribe the webhook to the tag-applied topic

Webhooks tab → New webhook → set the Endpoint URL → subscribe to conversation_part.tag.created — Intercom's only topic for "a tag landed on this conversation." contact.user.tag.created and contact.lead.tag.created fire on a contact profile instead, so they don't apply here; there is no conversation.tag.created at all, despite how natural that name sounds. Tag a test conversation once before going live and check whether the payload gives you the tag name inline or only a tag id you'd have to resolve separately. If the payload only carries a tag id, copy that id into the job's allow-list once during setup and filter on it — do not turn on Tags: Read just to resolve the name on every event. Conversations: Read stays the only Intercom permission this flow needs.

conversation_part.tag.created

Know the response shape before you build the extraction step

GET /conversations/{id} returns source.body as the opening message and conversation_parts.conversation_parts[].body for every reply after it — both HTML, not plain text, capped at the most recent 500 parts. Strip the tags before handing any of this to an extraction model, or the quote you save will have markup baked into it. Take the customer email from source.author.email on this same response.

source.body                          # opening message, HTML
source.author.{id,type,name,email}   # customer identity — email included, no /contacts call needed
conversation_parts.conversation_parts[].body  # replies, HTML, most recent 500

Create an internal integration

notion.so/my-integrations → New integration → pick the workspace → copy the Internal Integration Secret.

Create the "Customer Testimonials" database

New page → Table (or type /database inside an existing page). Add exactly these properties — names matter, the API writes to them by name: Name (Title), Company (Text — optional; leave empty if you cannot infer it from the thread, and do not block the write), Quote (Text), Source conversation (URL), Tag type (Select: Praise / NPS promoter / Case study candidate), Permission status (Select: Not requested / Requested / Granted / Declined), Captured at (Date).

Add the integration to the database

Open the database → ••• (top right) → Connections → Add connection → pick the integration from step 1 → confirm access. Skip this and every write 404s on a database you can plainly see in the UI.

Retrieve the data source id once — required, not optional

GET /v1/databases/{database_id} once and keep its data_source_id; parent every page this flow creates on that id, not database_id. Notion's 2025-09-03 model split database from data source, and its own migration guide names "create a page with the database as parent" as one of the calls that breaks first — not immediately, but the day this database gains a second data source. This is a new database with no legacy callers, so start on data_source_id. Before every create, also query this same data source for an existing row whose Source conversation URL already matches the Intercom deep link `app.intercom.com/a/inbox/{workspace}/conversation/{id}` (workspace segment per your team; full example in the create-page snippet) — retagging the same conversation re-fires the webhook, and that check is what stops a duplicate row.

{
  "parent": { "type": "data_source_id", "data_source_id": "8f2c1d0e4b7a4c9f8e1d2c3b4a5f6e7d" },
  "properties": {
    "Name":                { "title": [{ "text": { "content": "Jamie Chen" } }] },
    "Company":              { "rich_text": [{ "text": { "content": "Northwind Co." } }] },
    "Quote":                { "rich_text": [{ "text": { "content": "This is the first tool that actually saved my team a full day every week." } }] },
    "Source conversation":  { "url": "https://app.intercom.com/a/inbox/xyz/conversation/48213" },
    "Tag type":             { "select": { "name": "Praise" } },
    "Permission status":    { "select": { "name": "Not requested" } },
    "Captured at":          { "date": { "start": "2026-08-09" } }
  }
}

Dedup filter shape for Source conversation

Query the testimonials data source with a URL equals filter on Source conversation before every create. Endpoint is the data source query; Notion-Version matches the create-page step.

{
  "filter": {
    "property": "Source conversation",
    "url": { "equals": "https://app.intercom.com/a/inbox/xyz/conversation/48213" }
  }
}

Create the app and add the one scope it needs

api.slack.com/apps → Create New App → From scratch → OAuth & Permissions → Bot Token Scopes → add chat:write. This step is a one-way broadcast into a fixed channel — no approval buttons, so no users:read.email or other identity-lookup scopes.

Install to Workspace and invite the bot

Install to Workspace → copy the Bot User OAuth Token into the execution environment's secrets store → /invite @your-app-name into #marketing-testimonials (or whatever channel your team wants these landing in).

Post the aggregated notification, not a plain mention

Intercom's own Workflows already have a "Notify Slack channel" action you could point at this same trigger tag — but it can only post fields Intercom itself has, like the conversation link and the customer's name. It cannot include the Notion page this flow just created or the cleaned quote AI pulled out of the thread, because neither exists yet at the moment Intercom would fire that native action. This step is the one that actually aggregates across apps.

{
  "channel": "#marketing-testimonials",
  "text": "New testimonial candidate from Jamie Chen (Northwind Co.) — <https://notion.so/xyz|view in Notion> · <https://app.intercom.com/a/inbox/xyz/conversation/48213|source conversation>"
}

Enable the Gmail API and create an OAuth client

Google Cloud Console → new or existing project → enable the Gmail API → create an OAuth client.

Set the consent screen to Testing, and use the compose scope

OAuth consent screen → Internal (Workspace) or External with Testing status, using your own address as the test user — that keeps this out of Google's verification queue and the annual CASA security assessment that publishing to real external users triggers. Use the gmail.compose scope below. Google documents it as "Manage drafts and send emails," not "manage drafts only" — the scope itself can send. Nothing about it stops that; the next step does, by construction.

https://www.googleapis.com/auth/gmail.compose

Authorize once to mint a refresh token

Walk through the OAuth authorization flow one time to get a refresh token, then store it in the execution environment's secrets store alongside the client id and secret. This click is the one step in Gmail setup that has to happen in a browser.

Create the draft — marketing sends it by hand

POST /gmail/v1/users/me/drafts (full URL in the snippet) with the customer's email from Intercom's source.author.email as the recipient, and AI-drafted body text that quotes the extracted line and asks whether it can be used as a case study or testimonial. This job never calls users.messages.send; that is a property of the code, not of the scope, since drafting and sending share the same permission. Marketing opens the draft in Gmail, edits it if they want, and clicks send themselves — the human gate on every outbound permission ask. If source.author.email came back empty — a channel Intercom didn't attach an address to — skip this step and flag the Notion row for a human to follow up on directly.

{
  "message": {
    "raw": "<base64url(RFC2822 message: To: jamie@northwind.co\r\nSubject: Quick permission check on your kind words\r\n\r\nHi Jamie, ...)>"
  }
}