How to Automate Slack Messages into Google Sheets Using Make.com

Introduction

Manual Slack logging is one of those admin chores that quietly eats your week. You see an update in #ops, #support, or a project channel, then you copy it into Google Sheets so someone else can analyze it later. Inevitably you miss messages, paste duplicates, or spend time fixing timestamps and formatting.

In this guide you will build a Cross-Platform Automation (XPA) that automatically moves selected Slack messages into Google Sheets using Make.com. By the end, you will know how to wire the trigger, normalize fields, dedupe with Slack ts, and add an error route so failures do not silently disappear.

What You'll Need

• Make.com account (use the scenario builder)
• Slack app permissions to read messages from the target channel (Make.com needs access)
• Google Sheets permission to add rows to your spreadsheet
• A Google Sheet tab with the right columns

Recommended Google Sheets tab headers (Slack_Log):

• Channel
• User
• Message
• Slack_Ts
• Thread_Ts
• Message_Link
• Created_At_UTC

How It Works (The Logic)

When a new Slack message arrives in your chosen channel, Make.com:

1. extracts the message text, author, channel, Slack timestamp (ts), and thread identifier (if present)
2. formats values into a consistent shape for Sheets
3. checks Google Sheets for an existing row where Slack_Ts matches the incoming Slack_Ts
4. creates a new row only when the message is not already logged
5. routes any errors to a dedicated error tab

That trigger to action flow is the core of Cross-Platform Automation (XPA) reliability.

Step-by-Step Setup

1) Create the destination Google Sheet schema

1. In your Google Sheet, add a tab called Slack_Log.
2. Add the headers in this exact order: Channel, User, Message, Slack_Ts, Thread_Ts, Message_Link, Created_At_UTC.
3. Add a second tab called Slack_Log_Errors for failure logging.

2) Create the Make.com scenario

1. In Make.com, create a new scenario.
2. Add your first module: Slack trigger for New message in channel (or the closest “new message” trigger available for your setup).
3. Configure it to watch only the channel you want, for example #ops.

Gotcha: Keep the initial test scope narrow. Watching too broad a message history can generate unexpected volume during setup.

3) Filter before you write to Sheets

Add a Filter module immediately after the Slack trigger.

Common examples:

• Log only messages that contain #log
• Log only incident posts that contain [INC]

This is where you keep your XPA focused and cheap, since every message that passes the filter becomes a write attempt.

4) Normalize fields for stable dedupe

Add a formatting step (Make module name varies by your module set, often something like formatter or set variables) to normalize the incoming data:

• Message: trim whitespace, keep line breaks consistent (or collapse them)
• Slack_Ts: store the raw Slack ts as the canonical value
• Created_At_UTC: write timestamps in a consistent UTC format

Gotcha: Dedupe will fail if you accidentally “pretty print” Slack_Ts differently across runs. Keep Slack_Ts canonical.

5) Capture thread context (if applicable)

If your Slack trigger provides thread_ts:

• map it to Thread_Ts
• if the trigger does not include it for channel posts, write blank

6) Dedupe by Slack_Ts using Google Sheets lookup

1. Add a Google Sheets module to search rows (or find rows).
2. Target your Slack_Log tab.
3. Search for a row where Slack_Ts equals the incoming Slack_Ts.

7) Create row only when not found

Add an If / Router step after the lookup:

• If no match exists, use Google Sheets > Add a row.

• Map fields:

  • Channel: channel name
  • User: Slack username (or resolved name if you have it)
  • Message: normalized message text
  • Slack_Ts: raw Slack ts
  • Thread_Ts: thread identifier or blank
  • Message_Link: optional, if your trigger provides a permalink
  • Created_At_UTC: timestamp in UTC

• If a match exists, route to a “skip” branch.

Why this matters: On retries, Make can re-run parts of a scenario. Slack_Ts idempotency prevents duplicates.

8) Add an error logging route

1. In scenario settings, enable an error handling route.
2. Create a branch that writes failure details into Slack_Log_Errors.
3. Include at least:
   • error time
   • Slack_Ts
   • channel
   • error message

9) Test with controlled messages

1. Post 3 messages that match your filter.
2. Post 2 messages that do not match.
3. Run the scenario, then confirm:
   • only matching messages create rows
   • re-running does not create duplicates
   • error tab stays empty for successful runs

If duplicates appear, stop and confirm you are searching on the exact same Slack_Ts value you write.

Real-World Business Scenario

A customer support team uses Slack for real-time ticket intake. Their agents post incident-style updates into #support with a tag like [INC]. They want a clean audit trail for weekly reporting without manually copying each message into Sheets.

With this Cross-Platform Automation (XPA), every [INC] Slack message becomes a structured row in Google Sheets, keyed by Slack_Ts. The team now builds a simple dashboard filtered by week, and they can jump back to the original message using Message_Link when it is available from the trigger.

If you are designing more than logging and want to extend the pipeline, you will probably like how we think about end-to-end flows in Cross-Platform Automation (XPA).

Common Variations

1. Only log threads

   • Add a filter condition: Thread_Ts is not empty.
   • Write the parent and reply details into separate columns.

2. Update existing rows instead of skipping

   • Use an “edited message” trigger (if available in your Slack module set).
   • When Slack_Ts already exists, update the row rather than skip.

3. Notify a Slack channel when a row is created

   • After the Google Sheets add row step, add a Slack action to post a short confirmation to #ops-log.
   • Keep notifications gated behind the same filter.

A setup you can trust day after day

You built a Slack-to-Google-Sheets XPA in Make.com that filters noise, stores canonical Slack timestamps, prevents duplicates, and logs failures to an error tab. That combination is what makes this kind of automation usable in the real world.

Olmec Dynamics builds these Cross-Platform Automation (XPA) workflows for teams that need reliable integrations and clean operational data. If you want a version tailored to your Slack channels, Sheets schema, and error reporting rules, start with Cross-Platform Automation (XPA), then share your current fields and we will map it into a build plan.