Slack + Linear: turn ✅ reactions into clean tickets
Your support Slack channel is busy, loud, and weirdly fragile. One “quick question” turns into a thread, then vanishes under a dozen new pings, and suddenly nobody remembers what was promised.
This is where Slack Linear tickets automation pays off. Support leads feel it first, but ops managers and client-facing agency owners get dragged into the same mess. Missed requests, duplicate work, and ticket writeups that look like they were typed mid-meeting.
This workflow turns a simple ✅ reaction into a clean Linear issue, rewritten and prioritized by AI. You’ll see how it works, what you need, and what changes once Slack stops being your ticketing system.
How This Automation Works
The full n8n workflow, from trigger to final output:
n8n Workflow Template: Slack + Linear: turn ✅ reactions into clean tickets
flowchart LR
subgraph sg0["Schedule Flow"]
direction LR
n0["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/slack.svg' width='40' height='40' /></div><br/>Slack"]
n1@{ icon: "mdi:brain", form: "rounded", label: "OpenAI Chat Model", pos: "b", h: 48 }
n2@{ icon: "mdi:robot", form: "rounded", label: "Structured Output Parser", pos: "b", h: 48 }
n3@{ icon: "mdi:play-circle", form: "rounded", label: "Schedule Trigger", pos: "b", h: 48 }
n4@{ icon: "mdi:swap-vertical", form: "rounded", label: "Get Values", pos: "b", h: 48 }
n5@{ icon: "mdi:swap-horizontal", form: "rounded", label: "Create New Ticket?", pos: "b", h: 48 }
n6["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/linear.svg' width='40' height='40' /></div><br/>Get Existing Issues"]
n7@{ icon: "mdi:robot", form: "rounded", label: "Generate Ticket Using ChatGPT", pos: "b", h: 48 }
n8["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/linear.svg' width='40' height='40' /></div><br/>Create Ticket"]
n9["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/merge.svg' width='40' height='40' /></div><br/>Merge"]
n10@{ icon: "mdi:swap-vertical", form: "rounded", label: "Get Hashes Only", pos: "b", h: 48 }
n11@{ icon: "mdi:cog", form: "rounded", label: "Collect Descriptions", pos: "b", h: 48 }
n9 --> n5
n0 --> n4
n4 --> n9
n4 --> n6
n10 --> n9
n3 --> n0
n1 -.-> n7
n5 --> n7
n6 --> n11
n11 --> n10
n2 -.-> n7
n7 --> n8
end
%% Styling
classDef trigger fill:#e8f5e9,stroke:#388e3c,stroke-width:2px
classDef ai fill:#e3f2fd,stroke:#1976d2,stroke-width:2px
classDef aiModel fill:#e8eaf6,stroke:#3f51b5,stroke-width:2px
classDef decision fill:#fff8e1,stroke:#f9a825,stroke-width:2px
classDef database fill:#fce4ec,stroke:#c2185b,stroke-width:2px
classDef api fill:#fff3e0,stroke:#e65100,stroke-width:2px
classDef code fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
classDef disabled stroke-dasharray: 5 5,opacity: 0.5
class n3 trigger
class n2,n7 ai
class n1 aiModel
class n5 decision
classDef customIcon fill:none,stroke:none
class n0,n6,n8,n9 customIcon
The Problem: Slack support requests don’t become trackable work
Slack is great for fast conversations. It’s not great for accountability. A customer drops a bug report in a shared channel, your team reacts, someone says “I’ll take it,” and then the message gets buried. Later, you’re reconstructing context from half a thread, guessing priority, and rewriting the request into something an engineer can actually act on. That translation step is where things slip. Honestly, it’s also where time disappears, because you do it over and over.
The friction compounds. Here’s where it breaks down in real teams.
- A “we’ll fix it” message never becomes a ticket, so it never gets scheduled.
- Ticket writeups are inconsistent, which means more back-and-forth and slower resolution.
- Duplicates show up because nobody knows a similar issue already exists in Linear.
- Support handoffs get messy, since Slack context doesn’t map cleanly to a trackable workflow.
The Solution: ✅ in Slack becomes a Linear ticket (with AI doing the cleanup)
This workflow watches a support Slack channel and looks for messages your team “approves” with a ✅ reaction. On a schedule, it searches for those marked messages, pulls the key fields (who said it, what they said, and any useful context), and checks Linear to see if the problem already exists. If it’s new, an AI model rewrites the raw Slack message into a proper support ticket: clearer title, cleaner description, sensible priority, and a consistent structure your team recognizes. Then it creates the issue in Linear so it lands directly in the same system you plan and ship from.
The workflow starts with a scheduled trigger, then gathers approved Slack messages and normalizes the data. Next, it compares against existing Linear issues to reduce duplicates. Finally, ChatGPT drafts the ticket content and n8n creates the Linear ticket automatically.
What You Get: Automation vs. Results
| What This Workflow Automates | Results You’ll Get |
|---|---|
|
|
Example: What This Looks Like
Say your channel produces about 20 “real” support requests a week that deserve tickets. Manually, writing each one up in Linear takes maybe 6 minutes (copy the message, rewrite it, add context, set priority), which is roughly 2 hours. With this workflow, the human step is just reacting ✅ in Slack, which takes seconds. The scheduled run and AI drafting happen in the background, so your weekly admin drops to a quick review pass instead of full rewrites.
What You’ll Need
- n8n instance (try n8n Cloud free)
- Self-hosting option if you prefer (Hostinger works well)
- Slack for the support channel and reactions.
- Linear to create and track issues.
- OpenAI API key (get it from the OpenAI API dashboard)
Skill level: Intermediate. You’ll connect accounts, set permissions, and adjust a couple of fields so the ticket format matches your team.
Don’t want to set this up yourself? Talk to an automation expert (free 15-minute consultation).
How It Works
A scheduled check scans Slack. The workflow runs on a schedule and searches a specific Slack channel for messages that have been tagged with a ✅ reaction by your team.
Slack messages get cleaned up and normalized. n8n maps the message fields into a predictable structure (think “title,” “description,” “reporter,” and a few identifiers), so downstream steps aren’t guessing.
Linear is queried to prevent duplicates. It retrieves existing issues and aggregates their descriptions, then extracts hashes/identifiers so the workflow can decide if a “new” request is actually already in your backlog.
AI drafts the ticket and Linear receives it. If the ticket should be created, ChatGPT rewrites the raw Slack request into a clean issue and n8n creates the Linear ticket with the right formatting.
You can easily modify the Slack channel being monitored to support multiple customer channels based on your needs. See the full implementation guide below for customization options.
Step-by-Step Implementation Guide
Step 1: Configure the Schedule Trigger
Set the workflow to run on a schedule so it regularly scans Slack for ticket markers.
- Add the Scheduled Automation Trigger node as the workflow trigger.
- Set the Rule interval field to
minutes(as configured in the node). - Connect Scheduled Automation Trigger to Slack Message Search.
Step 2: Connect Slack Search and Map Message Data
Search for Slack messages that contain ticket markers and map required fields for downstream processing.
- Open Slack Message Search and set Operation to
search. - Set Query to
in:#n8n-tickets has::ticket:and Limit to10. - Credential Required: Connect your slackApi credentials.
- In Map Message Fields, set Mode to
rawand JSON Output to={ "id": "#{{ $json.permalink.split('/').last() }}", "type": "{{ $json.type }}", "title": "__NOT_SET__", "channel": "{{ $json.channel.name }}", "user": "{{ $json.username }} ({{ $json.user }})", "ts": "{{ $json.ts }}", "permalink": "{{ $json.permalink }}", "message": "{{ $json.text.replaceAll('\"','\\\\\"').replaceAll('\n', '\\n') }}"}. - Connect Slack Message Search to Map Message Fields.
Step 3: Build the Existing-Issue Check and Parallel Data Streams
Fetch existing Linear issues, aggregate descriptions, extract hashes, and combine them with the Slack message data for duplication checks.
- Connect Map Message Fields to both Combine Data Streams and Retrieve Existing Issues in parallel.
- Retrieve Existing Issues: set Operation to
getAlland connect Credential Required: your linearApi credentials. - In Aggregate Descriptions, set Field to Aggregate to
descriptionand Output Field Name todescriptions. - In Extract Issue Hashes, add an assignment named hashes with value
={{ $json.descriptions.map(desc => desc.match(/hash\:\s([\w#]+)/i)[1]) }}. - Configure Combine Data Streams with Mode
combineand Combination Modemultiplex.
hash: entry, the regex in Extract Issue Hashes can fail. Ensure existing tickets follow the same metadata format.Map Message Fields outputs to both Combine Data Streams and Retrieve Existing Issues in parallel.
Step 4: Set Up the Ticket Creation Gate and AI Drafting
Stop duplicate ticket creation and generate structured ticket data with the OpenAI chain.
- Connect Combine Data Streams to Ticket Creation Check.
- In Ticket Creation Check, set the boolean condition to
={{ Boolean(($json.hashes ?? []).includes($json.id)) }}and compare tofalseso only new messages pass. - Open Draft Ticket with ChatGPT and set Prompt Type to
define. - Set the Text prompt to
=The "user issue" is enclosed by 3 backticks: ``` {{ $('Map Message Fields').item.json.message }} ``` You will complete the following 4 tasks: 1. Generate a title intended for a support ticket based on the user issue only. Be descriptive but use no more than 10 words. 2. Summarise the user issue only by identifying the key expectations and steps that were taken to reach the conclusion. 3. Offer at most 3 suggestions to debug or resolve the user issue only. ignore the previous issues for this task. 4. Identify the urgency of the user issue only and denote the priority as one of "low", "medium", "high" or "urgent". If you cannot determine the urgency of the issue, then assign the "low" priority. Also consider that requests which require action either today or tomorrow should be prioritised as "high".. - Attach OpenAI Chat Engine as the language model for Draft Ticket with ChatGPT and Structured Result Parser as the output parser.
- Credential Required: Connect your openAiApi credentials in OpenAI Chat Engine (do not add credentials to Structured Result Parser).
Step 5: Configure Linear Ticket Creation
Create a new Linear ticket using the structured AI output and original Slack metadata.
- Open Create Linear Ticket and set Title to
={{ $json.output.title }}. - Set Team ID to
[YOUR_ID]and update State ID to[YOUR_ID]in Additional Fields. - Set Priority ID to
={{ { 'urgent': 1, 'high': 2, 'medium': 3, 'low': 4 }[$json.output.priority.toLowerCase()] ?? 0 }}. - Set Description to
=## {{ $json.output.summary }} ### Suggestions {{ $json.output.ideas.map(idea => '* ' + idea).join('\n') }} ## Original Message {{ $('Map Message Fields').item.json["user"] }} asks: > {{ $('Map Message Fields').item.json["message"] }} ### Metadata channel: {{ $('Map Message Fields').item.json.channel }} ts: {{ $('Map Message Fields').item.json.ts }} permalink: {{ $('Map Message Fields').item.json.permalink }} hash: {{ $('Map Message Fields').item.json.id }}. - Credential Required: Connect your linearApi credentials in Create Linear Ticket.
Step 6: Test and Activate Your Workflow
Run a manual test to confirm Slack search, duplication checks, AI drafting, and Linear ticket creation work as expected.
- Click Execute Workflow and verify that Slack Message Search returns messages with
:ticket:in#n8n-tickets. - Confirm Ticket Creation Check only passes items not found in hashes.
- Check Draft Ticket with ChatGPT outputs a structured object with
title,summary,ideas, andpriority. - Verify a new issue appears in Linear with the formatted description and metadata from Map Message Fields.
- Once successful, toggle the workflow to Active so Scheduled Automation Trigger runs on schedule.
Common Gotchas
- Slack credentials can expire or need specific permissions. If things break, check your n8n Slack credential status and the Slack app scopes first.
- If you’re using Wait nodes or external rendering, processing times vary. Bump up the wait duration if downstream nodes fail on empty responses.
- Default prompts in AI nodes are generic. Add your brand voice early or you’ll be editing outputs forever.
Frequently Asked Questions
About 30 minutes if Slack, Linear, and OpenAI are ready.
No. You’ll connect accounts and adjust a few mapping fields in n8n.
Yes. n8n has a free self-hosted option and a free trial on n8n Cloud. Cloud plans start at $20/month for higher volume. You’ll also need to factor in OpenAI API costs (usually a few cents per ticket).
Two options: n8n Cloud (managed, easiest setup) or self-hosting on a VPS. For self-hosting, Hostinger VPS is affordable and handles n8n well. Self-hosting gives you unlimited executions but requires basic server management.
Yes, but you’ll swap the Linear nodes for Jira equivalents and keep the same Slack + AI pattern. In practice, you replace “Retrieve Existing Issues” and “Create Linear Ticket” with Jira search/create actions, then adjust the field mapping so the AI output matches your Jira project fields. Common customizations include changing the priority labels, writing tickets in your internal template, and routing certain categories to different projects.
Usually it’s expired credentials or missing Slack app scopes for searching messages and reading reactions. Reconnect Slack in n8n and confirm the workflow has access to the specific channel you’re monitoring. If it only fails sometimes, Slack rate limits can also cause intermittent errors when you’re scanning a lot of history at once.
If you self-host, it’s mainly limited by your server and API rate limits; dozens or even a few hundred tickets a day is realistic for small teams. On n8n Cloud, the limit is driven by your monthly executions, so higher-volume support teams typically move to a larger plan or self-host.
Often, yes. This workflow benefits from logic that’s a little more “real world”: branching decisions, checking Linear before creating issues, and shaping AI output into a structured result. n8n is strong here because you can self-host (so you’re not paying per tiny step) and you can keep the flow readable even when it grows. Zapier and Make can still work if you want a very simple “reaction creates ticket” rule and you’re fine doing the rewriting manually. If you’re unsure, Talk to an automation expert and you’ll get a straight recommendation.
Once ✅ becomes the only “intake” your team needs, Slack gets quieter and Linear gets cleaner. Set it up once, then let the workflow do the boring part.
Need Help Setting This Up?
Our automation experts can build and customize this workflow for your specific needs. Free 15-minute consultation—no commitment required.