Make.com Integration Guide

Quick answer: Make.com (formerly Integromat) enables visual workflow automation for Surmado Intelligence Tokens. Watch Gmail for new reports, extract tokens with regex, fetch JSON via HTTP module, parse metrics, route to multiple destinations (Google Sheets, Slack, Airtable). More powerful than Zapier: advanced data transformation, error handling, conditional routing, scheduling. 5 complete scenario templates included.

Reading time: 17 minutes

In this guide:

• Build Signal to Google Sheets tracker using Gmail Watch Emails trigger (From: hi@surmado.com, Subject contains “Signal Report”), Text Parser → Match Pattern (SIG-\d{4}-\d{2}-[A-Z0-9]{5}), HTTP → Make a Request (GET https://api.surmado.com/intelligence/{token}), Set Variable for calculations (presence_rate × 100, competitive_gap), Google Sheets → Add Row (5 operations total)
• Create competitive alerts with filtering by calculating competitive rank with Python code comparing your_rate vs competitors array, using Filter module (Continue only if rank > 3), then Slack → Create Message showing “Ranked #X, Top 3 competitors: [names + rates]” only when actionable, saving team from alert fatigue
• Set up multi-destination routing using Router module to split flow into 3 parallel paths (Google Sheets detailed tracking, Slack team notification, Airtable records) from single Signal report, delivering data to all platforms simultaneously vs sequential Zapier tasks (7 operations: 1 trigger + 1 parser + 1 HTTP + 1 variable + 1 router + 3 destinations)
• Build scheduled competitive monitoring with Schedule Trigger (Cron: 0 9 * * 1 for Monday 9 AM), Set Variable token array, Iterator for each token, HTTP requests (runs 4× for 4 tokens), Array Aggregator combining results, Text Aggregator formatting email, Send Email with weekly summary (12 operations for complete competitive analysis)
• Implement error handling and retry logic by right-clicking HTTP module → Add error handler → Sleep 5 seconds → Retry for network failures, plus email notifications when Notion/Airtable APIs fail with permissions/rate limits, ensuring robust automation vs silent failures in simpler tools

Make.com advantages: Visual flow editor, built-in JSON parsing, advanced logic, better pricing

---

Prerequisites

What You Need

1. Make.com account (Free plan: 1,000 operations/month)
2. Surmado reports with Intelligence Tokens
3. Gmail account (or email forwarding to Gmail)
4. Destination apps (Google Sheets, Slack, Airtable, etc.)

Make.com Plan Comparison

Free plan:

• 1,000 operations/month
• 15 minuteute execution interval (scheduled scenarios)
• 2 active scenarios
• Sufficient for personal tracking (5-10 reports/month)

Core plan ($9/month):

• 10,000 operations/month
• 1-minute execution interval
• Unlimited scenarios
• Recommended for regular use

Pro plan ($16/month):

• 10,000 operations/month
• Custom variables
• Full-text search
• Recommended for agencies

---

Scenario 1: Signal to Google Sheets Tracker

Use Case

Every Signal report automatically adds row to Google Sheets tracking dashboard.

Setup Steps

Step 1: Create Google Sheet

Sheet name: Signal Tracking

Headers (row 1):

• A: Date
• B: Token
• C: Business Name
• D: Presence Rate (%)
• E: Authority Score
• F: Ghost Influence (%)
• G: Top Competitor
• H: Competitive Gap (%)
• I: Rank

---

Step 2: Create Make.com Scenario

1. Go to make.com
2. Click Create a new scenario
3. Name: Signal → Google Sheets Tracking

---

Step 3: Add Gmail Trigger

Module: Gmail → Watch Emails

Configuration:

• Folder: Inbox
• Criteria:
  • From: hi@surmado.com
  • Subject: Contains Signal Report
• Maximum number of results: 1

Schedule: Every 15 minutes (Free plan) or Every 1 minute (Core/Pro)

Test: Run once, verify module fetches Signal report email

---

Step 4: Extract Token with Text Parser

Module: Text Parser → Match Pattern

Configuration:

• Text: {{1.subject}} (Gmail module output)
• Pattern: SIG-\d{4}-\d{2}-[A-Z0-9]{5}
• Case sensitive: No
• Multiline: No

Output: Extracted token (e.g., SIG-2025-11-A1B2C)

Test: Verify token extracted correctly

---

Step 5: Fetch JSON with HTTP Module

Module: HTTP → Make a Request

Configuration:

• URL: https://api.surmado.com/intelligence/{{2.0}}
  • (Use Text Parser output {{2.0}} for extracted token)
• Method: GET
• Headers: None required

Parse response: Yes (Make.com auto-parses JSON)

Test: Run module, verify JSON response visible

---

Step 6: Calculate Metrics with Set Variable

Module: Tools → Set Variable

Variables:

• presence_rate_pct: {{5.metrics.presence_rate}} * 100
• ghost_influence_pct: {{5.metrics.ghost_influence}} * 100
• top_competitor_rate: {{5.competitors[].presence_rate}} * 100 (first item)
• competitive_gap: {{presence_rate_pct}} - {{top_competitor_rate}}

Formula syntax: Make.com supports mathematical operations directly

Test: Verify calculations correct

---

Step 7: Determine Competitive Rank with Tools

Module: Tools → Set Variable

Variable: rank

Formula:

{{if(5.metrics.presence_rate > 5.competitors[].presence_rate; 1; if(5.metrics.presence_rate > 5.competitors[].presence_rate; 2; if(5.metrics.presence_rate > 5.competitors[].presence_rate; 3; 4)))}}

Simplified approach: Use Iterator + Aggregator (see Advanced Patterns below)

For now: Manually set or calculate in Google Sheets

---

Step 8: Add Row to Google Sheets

Module: Google Sheets → Add a Row

Configuration:

• Spreadsheet: Signal Tracking
• Sheet: Sheet1

Column mapping:

• A (Date): {{formatDate(5.created_at; "YYYY-MM-DD")}}
• B (Token): {{2.0}}
• C (Business Name): {{5.business.name}}
• D (Presence Rate): {{6.presence_rate_pct}}
• E (Authority Score): {{5.metrics.authority_score}}
• F (Ghost Influence): {{6.ghost_influence_pct}}
• G (Top Competitor): {{5.competitors[].name}}
• H (Competitive Gap): {{6.competitive_gap}}
• I (Rank): (leave blank or use formula)

Test: Run entire scenario, verify row added to Google Sheets

---

Step 9: Save and Activate

1. Click Save (bottom right)
2. Turn Scheduling ON
3. Set interval: Every 15 minutes (or 1 minute for Core/Pro)
4. Click Run once to test full flow

Result: Every Signal report email → automatic Google Sheets tracking row

---

Complete Scenario Flow

[Gmail: Watch Emails]
    ↓
[Text Parser: Extract Token]
    ↓
[HTTP: GET Intelligence Token API]
    ↓
[Set Variable: Calculate Metrics]
    ↓
[Google Sheets: Add Row]

Operations per run: 5 operations (within Free plan for 200 reports/month)

---

Scenario 2: Competitive Alerts to Slack

Use Case

When Signal shows competitive gap > 10 percentage points, send alert to Slack.

Setup Steps

Steps 1-5: Same as Scenario 1

(Gmail trigger → Extract token → HTTP GET → Calculate metrics)

---

Step 6: Filter for Alert Condition

Module: Flow Control → Filter

Configuration:

• Label: Alert if Gap > 10
• Condition: {{6.competitive_gap}} Numeric less than -10
  • (Negative gap means competitor ahead)

Result: Scenario continues only if you’re 10+ points behind top competitor

---

Step 7: Send Slack Message

Module: Slack → Create a Message

Configuration:

• Channel: #marketing (or your team channel)

Message:

*Competitive Presence Rate Alert*

Your Signal report shows a significant competitive gap.

*Your Presence Rate*: {{6.presence_rate_pct}}%
*Top Competitor*: {{5.competitors[].name}} ({{6.top_competitor_rate}}%)
*Gap*: {{6.competitive_gap}} percentage points

*Top 3 Competitors:*
1. {{5.competitors[].name}}: {{5.competitors[].presence_rate * 100}}%
2. {{5.competitors[].name}}: {{5.competitors[].presence_rate * 100}}%
3. {{5.competitors[].name}}: {{5.competitors[].presence_rate * 100}}%

View full report: Intelligence Token `{{2.0}}`

Consider running Solutions to get strategic recommendations for closing the gap.

Formatting: Slack markdown (bold, code)

---

Step 8: Test and Activate

Test: Use Signal report with large competitive gap, verify Slack message sent

Activate: Turn on scheduling

Result: Alerts only when competitive position weak (gap > 10 points)

---

Complete Scenario Flow

[Gmail: Watch Emails]
    ↓
[Text Parser: Extract Token]
    ↓
[HTTP: GET API]
    ↓
[Set Variable: Calculate Gap]
    ↓
[Filter: Gap > 10?] → (if No, stop)
    ↓ (if Yes)
[Slack: Send Alert]

Operations per run: 6 operations (only when alert triggers)

---

Scenario 3: Multi-Destination with Router

Use Case

Send Signal data to Google Sheets AND Slack AND Airtable simultaneously.

Setup Steps

Steps 1-5: Standard Flow

(Gmail → Extract token → HTTP GET → Calculate metrics)

---

Step 6: Add Router Module

Module: Flow Control → Router

Purpose: Split flow into multiple parallel paths

Paths:

1. Path 1: Google Sheets
2. Path 2: Slack notification
3. Path 3: Airtable

---

Path 1: Google Sheets

Module: Google Sheets → Add a Row

Configuration: (Same as Scenario 1)

---

Path 2: Slack

Module: Slack → Create a Message

Configuration:

• Channel: #marketing

Message:

New Signal Report

*Business*: {{5.business.name}}
*Presence Rate*: {{6.presence_rate_pct}}%
*Authority Score*: {{5.metrics.authority_score}}/100

Token: `{{2.0}}`

---

Path 3: Airtable

Module: Airtable → Create a Record

Configuration:

• Base: (Your Airtable base)
• Table: Signal Reports

Fields:

• Date: {{formatDate(5.created_at; "YYYY-MM-DD")}}
• Token: {{2.0}}
• Presence Rate: {{6.presence_rate_pct}}
• Authority Score: {{5.metrics.authority_score}}

---

Step 7: Test and Activate

Test: Run scenario, verify all 3 destinations receive data

Activate: Turn on scheduling

Result: One Signal report → synced to 3 platforms simultaneously

---

Complete Scenario Flow

[Gmail: Watch Emails]
    ↓
[Text Parser: Extract Token]
    ↓
[HTTP: GET API]
    ↓
[Set Variable: Calculate]
    ↓
[Router]
    ├─→ [Google Sheets: Add Row]
    ├─→ [Slack: Send Message]
    └─→ [Airtable: Create Record]

Operations per run: 7 operations (1 trigger + 1 parser + 1 HTTP + 1 variable + 1 router + 3 destinations)

---

Scenario 4: Scheduled Competitive Monitoring

Use Case

Every Monday 9 AM, fetch your latest Signal token + 3 competitor tokens, compare metrics, send summary email.

Setup Steps

Step 1: Schedule Trigger

Module: Tools → Schedule

Configuration:

• Interval: Weekly
• Day: Monday
• Time: 9:00 AM (your timezone)

---

Step 2: Set Tokens with Array

Module: Tools → Set Variable

Variable: tokens

Value (array):

[
  "SIG-2025-11-A1B2C",
  "SIG-2025-11-COMP1",
  "SIG-2025-11-COMP2",
  "SIG-2025-11-COMP3"
]

Note: Update tokens manually each quarter, or store in Google Sheets and fetch dynamically

---

Step 3: Iterator for Each Token

Module: Flow Control → Iterator

Configuration:

• Array: {{2.tokens}}

Purpose: Loop through each token individually

---

Step 4: HTTP GET for Each Token

Module: HTTP → Make a Request

Configuration:

• URL: https://api.surmado.com/intelligence/{{3.value}}
• Method: GET

Result: Fetches data for each token in array

---

Step 5: Aggregate Results

Module: Tools → Array Aggregator

Configuration:

• Source module: HTTP module (step 4)
• Group by: (leave empty to aggregate all)

Aggregated fields:

• business_name: {{4.business.name}}
• presence_rate: {{4.metrics.presence_rate * 100}}
• authority_score: {{4.metrics.authority_score}}

Output: Array of all results

---

Step 6: Format Email with Text Aggregator

Module: Tools → Text Aggregator

Configuration:

• Source module: HTTP module (step 4)

Text:

{{4.business.name}}: {{4.metrics.presence_rate * 100}}% Presence Rate, {{4.metrics.authority_score}} Authority Score

Separator: Newline

Output: Text list of all competitors

---

Step 7: Send Email

Module: Email → Send an Email

Configuration:

• To: you@yourcompany.com
• Subject: Weekly Competitive Signal Summary

Body:

Here's your weekly competitive Presence Rate summary:

{{6.text}}

---
Tokens analyzed: {{join(2.tokens; ", ")}}

Run new Signal reports if data is outdated.

---

Step 8: Test and Activate

Test: Run once manually, verify email received with all competitors

Activate: Turn on scheduling

Result: Every Monday, automated competitive summary email

---

Complete Scenario Flow

[Schedule: Weekly Monday 9 AM]
    ↓
[Set Variable: Token Array]
    ↓
[Iterator: For Each Token]
    ↓
[HTTP: GET API] (runs 4× for 4 tokens)
    ↓
[Array Aggregator: Combine Results]
    ↓
[Text Aggregator: Format Email]
    ↓
[Email: Send Summary]

Operations per run: about 12 operations (1 trigger + 1 variable + 4 HTTP + 1 aggregator + 1 text + 1 email)

---

Scenario 5: Scan to Notion with Error Handling

Use Case

Create Notion database page for every Scan report, with retry logic if API fails.

Setup Steps

Steps 1-5: Standard Pattern

1. Gmail trigger (watch for “Scan Report”)
2. Extract token (SCAN-\d{4}-\d{2}-[A-Z0-9]{5})
3. HTTP GET Intelligence Token API
4. Parse JSON
5. Calculate status (Good/Needs Work/Critical based on overall_score)

---

Step 6: Error Handler for HTTP Module

Right-click HTTP module → Add error handler

Module: Tools → Sleep

Configuration:

• Delay: 5 seconds

Then: Retry (reconnect to HTTP module)

Purpose: If API fails (network issue), wait 5 seconds and retry

---

Step 7: Create Notion Page

Module: Notion → Create a Database Item

Configuration:

• Database ID: (your Scan database ID)

Properties:

• Title: {{5.website.url}} - {{formatDate(5.created_at; "YYYY-MM-DD")}}
• Token: {{2.0}}
• Overall Score: {{5.overall_score}}
• Performance: {{5.category_scores.performance}}
• Accessibility: {{5.category_scores.accessibility}}
• Status: {{6.status}} (from calculation step)

Page content:

## Score Breakdown

Technical SEO: {{5.category_scores.technical_seo}}/100
Performance: {{5.category_scores.performance}}/100
Accessibility: {{5.category_scores.accessibility}}/100
Security: {{5.category_scores.security}}/100

## Intelligence Token

`{{2.0}}`

---

Step 8: Error Handler for Notion Module

Right-click Notion module → Add error handler

Module: Email → Send an Email

Configuration:

• To: you@yourcompany.com
• Subject: Make.com Error: Scan to Notion Failed

Body:

Failed to create Notion page for Scan token: {{2.0}}

Error: {{7.message}}

Retry manually or check Notion integration permissions.

Purpose: If Notion API fails (permissions, rate limit), send error notification

---

Step 9: Test and Activate

Test: Run with valid Scan token, verify Notion page created

Test error handling: Temporarily use invalid Notion database ID, verify error email sent

Activate: Turn on scheduling

Result: Robust Scan automation with error recovery

---

Complete Scenario Flow

[Gmail: Watch Emails]
    ↓
[Text Parser: Extract Token]
    ↓
[HTTP: GET API] → (error handler: Sleep 5s → Retry)
    ↓
[Set Variable: Calculate Status]
    ↓
[Notion: Create Page] → (error handler: Send Error Email)

Operations per run: 6 operations (no errors) or 8+ (with retries)

---

Advanced Patterns

Pattern 1: Conditional Routing Based on Tier

Use case: Send Pro reports to detailed dashboard, Essential reports to summary only

Setup:

Module: Flow Control → Router

Route 1 Filter: {{5.tier}} Equal to pro → Google Sheets (detailed columns)

Route 2 Filter: {{5.tier}} Equal to essential → Google Sheets (summary columns only)

---

Pattern 2: Data Store for Historical Comparison

Use case: Compare current Presence Rate to last quarter’s value

Setup:

Module: Data Store → Search Records

Configuration:

• Data store: Signal History
• Key: {{5.business.name}}

Result: Retrieves last saved Presence Rate

Module: Tools → Set Variable

Variable: delta Value: {{5.metrics.presence_rate * 100}} - {{previous_rate}}

Module: Data Store → Add Record

Configuration:

• Key: {{5.business.name}}
• Value: {{5.metrics.presence_rate * 100}}

Purpose: Store current value for next comparison

---

Pattern 3: Parallel Processing with Parallel Paths

Use case: Fetch multiple tokens simultaneously (faster than iterator)

Setup:

Module: Flow Control → Router

Path 1: HTTP GET for Token 1 Path 2: HTTP GET for Token 2 Path 3: HTTP GET for Token 3

Then: Aggregator to combine results

Advantage: 3 tokens fetched in parallel (faster than sequential iterator)

---

Pattern 4: Custom Webhook for Real-Time Triggers

Use case: Trigger scenario immediately when report delivered (no 15 minute delay)

Setup:

Module: Webhooks → Custom Webhook

URL: Make.com provides unique webhook URL (e.g., https://hook.us1.make.com/abc123)

Configure email forwarding (Gmail filter):

• From: hi@surmado.com
• Forward to: abc123@forward.make.com (Make.com email-to-webhook)

Alternative: Use external service to monitor email and POST to webhook

Advantage: Instant triggering (no polling interval)

---

Error Handling Best Practices

1. Always Add Error Handlers to API Modules

Modules to protect:

• HTTP requests (network failures)
• Notion/Airtable/Google Sheets (rate limits, permissions)

Handler options:

• Retry (with delay)
• Send error notification
• Log to data store
• Continue with default values

---

2. Use Ignore Directive for Expected Failures

Use case: If token doesn’t exist, continue without failing entire scenario

Setup:

• Right-click HTTP module → Error handler
• Module: Flow Control → Ignore

Result: Scenario continues even if HTTP returns 404

---

3. Commit Data Store Updates

Pattern: Save to data store, then commit

Why: If scenario fails mid-run, partial data isn’t saved (prevents corruption)

---

4. Log All Runs to Google Sheets

Add final module: Google Sheets → Add a Row (to “Logs” sheet)

Columns:

• Timestamp: {{now}}
• Scenario: Signal Tracking
• Status: Success or Error
• Token: {{2.0}}

Why: Track scenario execution history for debugging

---

Troubleshooting

Issue 1: “No bundles processed”

Symptom: Gmail module returns 0 results

Causes:

• No new emails matching criteria
• Email already processed (Make.com tracks processed emails)

Fix:

• Check Gmail for new Signal reports
• Reset Gmail module (Force re-process emails)

---

Issue 2: JSON Parsing Fails

Symptom: HTTP module shows “Failed to parse response”

Causes:

• Token doesn’t exist (404 response)
• API returned error HTML instead of JSON

Fix:

• Verify token format (no spaces, correct pattern)
• Add error handler to HTTP module
• Check API response manually in browser

---

Issue 3: “Execution timed out”

Symptom: Scenario fails with timeout error

Causes:

• Too many operations (hitting Make.com timeout limit)
• Slow API responses

Fix:

• Reduce operations per run (split into multiple scenarios)
• Add Sleep modules between heavy operations
• Upgrade to higher Make.com plan (longer timeout)

---

Issue 4: Google Sheets Row Duplicate

Symptom: Same Signal report creates multiple rows

Causes:

• Scenario runs multiple times (polling interval catches same email)
• Email filter too broad (catches confirmation + report email)

Fix:

• Add deduplication filter: Check if token already exists in sheet before adding
• Refine Gmail filter (exact subject match)

---

Make.com vs Zapier

When to Use Make.com

Advantages:

• Visual flow editor (easier to understand complex workflows)
• Better data transformation (built-in JSON parsing, array operations)
• More cost-effective (10,000 operations for $9 vs Zapier’s $20)
• Advanced routing (routers, filters, iterators)

Use Make.com when:

• Complex logic (multiple conditions, loops)
• Multiple destinations (router to 3+ apps)
• Budget-conscious (better operations-per-dollar ratio)

---

When to Use Zapier

Advantages:

• Simpler interface (less intimidating for non-technical users)
• More pre-built app integrations
• Better documentation for common apps

Use Zapier when:

• Simple workflows (trigger → action, no branching)
• Team members uncomfortable with visual programming
• Need specific app integration Make.com doesn’t support

---

Frequently Asked Questions

Can I trigger Make.com scenarios from Surmado directly?

Not currently. Make.com scenarios trigger on email delivery or webhooks. Future Surmado webhook support may enable direct triggering.

How many operations does a typical Signal scenario use?

5-7 operations: 1 trigger (Gmail) + 1 parser (extract token) + 1 HTTP (API) + 1 variable (calculate) + 1-3 destinations (Sheets/Slack/etc.). Well within Free plan for 100-200 reports/month.

Can I use Make.com for bulk historical imports?

Yes. Use Schedule trigger + Set Variable (array of tokens) + Iterator + HTTP + destination. Process 50+ tokens in one run.

Does Make.com work with Scan Pro content gap analysis?

Yes. Scan Pro JSON includes content_gaps and competitor_benchmarks arrays. Use Iterator to process each gap/benchmark individually, then aggregate for summary.

Can I schedule scenarios to run at specific times?

Yes. Use Schedule module (not Gmail trigger). Set specific day/time (e.g., “Every Monday at 9 AM”). Useful for weekly competitive summaries or monthly tracking.

---

Need help building custom Make.com scenarios? Contact hi@surmado.com with your workflow requirements. We can provide scenario templates or integration consulting.