Zapier Integration Guide

Quick answer: Automate Surmado reports with Zapier workflows. Trigger on new email from hi@surmado.com, extract Intelligence Token with regex pattern, fetch JSON via Webhooks by Zapier, parse metrics, send to Google Sheets/Slack/Notion. No coding required. 5 common workflows included: quarterly tracking, competitive alerts, Slack notifications, client reporting, Notion dashboards. Works with Signal, Scan, and Solutions.

Reading time: 18 minutes

In this guide:

• Build quarterly tracking automation by triggering on Gmail (Subject contains “Signal Report”), extracting token with Code by Zapier regex (SIG-\d{4}-\d{2}-[A-Z0-9]{5}), fetching JSON via Webhooks GET (https://api.surmado.com/intelligence/{token}), calculating percentages with Formatter (multiply by 100), and creating Google Sheets row automatically (5 Zapier tasks per report)
• Create competitive alerts for weak positioning using Filter by Zapier to continue only when competitive rank > 3, calculating rank with Python code comparing your_rate vs competitors array, then sending Slack message with “Ranked #X, Top 3 competitors: [names + rates]” only when actionable (6 tasks when triggered)
• Set up Notion database integration for Scan reports by creating database with properties (Overall Score, Technical SEO, Performance, Accessibility, Security, Issues Count, Status), extracting SCAN-YYYY-MM-XXXXX token, counting issues by severity with Python, formatting top 5 issues text, and creating Notion page with scores + issues automatically (7 tasks per report)
• Send Solutions email digests to leadership by formatting top 3 recommendations as HTML with Python (action, rationale, impact, cost, risk for each), including risk assessment summary and model perspectives (CFO/Market Realist views), delivering executive summary within minutes of Solutions report vs manual copy/paste (5 tasks per report)
• Build multi-client agency dashboard populating master Google Sheet with all 20 clients’ metrics (Client Name, Date, Token, Presence Rate, Authority Score, Ghost Influence, Top Competitor, Competitive Gap, Status) plus conditional Slack alerts for at-risk clients (Presence Rate < 30%), saving 20 hours/month manual data entry for $50/month Professional plan (140-160 tasks monthly)

Cost: Zapier Starter plan ($20/month) supports these workflows

---

Prerequisites

What You Need

1. Zapier account (Starter plan minimum for multi-step Zaps)
2. Surmado reports (Signal, Scan, or Solutions with Intelligence Tokens)
3. Gmail account receiving Surmado reports (or forwarding to Gmail)
4. Destination app account (Google Sheets, Slack, Notion, etc.)

Zapier Plan Requirements

Free plan:

• 100 tasks/month
• Single-step Zaps only
• Not sufficient for Intelligence Token workflows (need multi-step)

Starter plan ($20/month):

• 750 tasks/month
• Multi-step Zaps (required)
• Recommended minimum

Professional plan ($50/month):

• Unlimited Zaps
• Paths (conditional logic)
• Recommended for agencies with multiple clients

---

Workflow 1: Quarterly Tracking to Google Sheets

Use Case

Every time you run Signal, automatically add Presence Rate + Authority Score to Google Sheets tracking dashboard.

Setup Steps

Step 1: Create Google Sheet

Sheet name: Signal Tracking

Columns:

• A: Date
• B: Token
• C: Presence Rate (%)
• D: Authority Score
• E: Top Competitor Rate (%)
• F: Competitive Rank

Example row:

2025-11-10 | SIG-2025-11-A1B2C | 42.0 | 78 | 54.0 | #3

---

Step 2: Create Zap

Trigger: Gmail - New Email

Configuration:

• From: hi@surmado.com
• Subject: Contains Signal Report

Why Gmail: Surmado sends reports via email with Intelligence Token in subject line

---

Step 3: Extract Token with Code by Zapier

Action: Code by Zapier - Run Python

Input Data:

• email_subject: (Gmail trigger output “Subject”)

Code:

import re

subject = input_data.get('email_subject', '')

# Extract token pattern: SIG-YYYY-MM-XXXXX
pattern = r'(SIG-\d{4}-\d{2}-[A-Z0-9]{5})'
match = re.search(pattern, subject)

if match:
    output = {'token': match.group(1)}
else:
    output = {'token': 'NOT_FOUND'}

Output:

• token: Extracted Intelligence Token (e.g., SIG-2025-11-A1B2C)

---

Step 4: Fetch JSON with Webhooks by Zapier

Action: Webhooks by Zapier - GET

Configuration:

• URL: https://api.surmado.com/intelligence/{{token}}
  • (Use Step 3 output for {{token}})
• Method: GET
• Headers: None required
• Query String Parameters: None

Test: Zapier will fetch JSON and show preview

---

Step 5: Parse JSON

Zapier automatically parses JSON response. You’ll see fields like:

• metrics__presence_rate (note double underscore for nested fields)
• metrics__authority_score
• competitors__0__presence_rate (first competitor)
• created_at

---

Step 6: Calculate Percentage

Action: Formatter by Zapier - Numbers - Perform Math Operation

Configuration:

• Input: {{metrics__presence_rate}} (from Step 4)
• Operation: Multiply
• Value: 100

Output: Presence Rate as percentage (0.42 becomes 42)

Repeat for competitors__0__presence_rate if needed

---

Step 7: Add to Google Sheets

Action: Google Sheets - Create Spreadsheet Row

Configuration:

• Spreadsheet: Signal Tracking
• Worksheet: Sheet1

Column mapping:

• Date: {{created_at}} (from Step 4) or {{zap_meta_human_now}}
• Token: {{token}} (from Step 3)
• Presence Rate (%): (Step 6 output)
• Authority Score: {{metrics__authority_score}} (from Step 4)
• Top Competitor Rate (%): (Calculated from competitors__0__presence_rate)
• Competitive Rank: (Calculate with Code by Zapier if needed)

---

Step 8: Test and Enable

Test: Send yourself a test Signal report, verify Zap triggers and populates sheet

Enable: Turn on Zap

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

---

Complete Workflow Summary

1. Gmail: New email from hi@surmado.com with "Signal Report" in subject
   ↓
2. Code by Zapier: Extract token with regex
   ↓
3. Webhooks by Zapier: GET https://api.surmado.com/intelligence/{token}
   ↓
4. Formatter: Convert presence_rate to percentage (× 100)
   ↓
5. Google Sheets: Add row with date, token, metrics

Zapier tasks used per report: 5 tasks (within Starter plan limits)

---

Workflow 2: Competitive Alerts to Slack

Use Case

When Signal shows you’re ranked below #3 in competitive Presence Rate, send alert to Slack channel.

Setup Steps

Steps 1-4: Same as Workflow 1

(Gmail trigger, extract token, fetch JSON, parse)

---

Step 5: Calculate Competitive Rank with Code by Zapier

Action: Code by Zapier - Run Python

Input Data:

• your_rate: {{metrics__presence_rate}} (from Webhooks step)
• competitors: {{competitors}} (entire competitors array as JSON string)

Code:

import json

your_rate = float(input_data.get('your_rate', 0))
competitors_json = input_data.get('competitors', '[]')

try:
    competitors = json.loads(competitors_json)
except:
    competitors = []

# Calculate your rank
your_rank = 1
for comp in competitors:
    if comp.get('presence_rate', 0) > your_rate:
        your_rank += 1

output = {
    'your_rank': your_rank,
    'alert': your_rank > 3
}

Output:

• your_rank: Your competitive ranking (1-N)
• alert: True if ranked below #3, False otherwise

---

Step 6: Filter (Only Continue If Alert)

Action: Filter by Zapier

Configuration:

• Continue only if: {{alert}} (from Step 5) Exactly matches True

Result: Zap stops here if you’re ranked #1-3 (no alert needed)

---

Step 7: Send Slack Message

Action: Slack - Send Channel Message

Configuration:

• Channel: #marketing (or your team channel)

Message:

Competitive Presence Rate Alert

Your Signal report shows you're ranked *#{{your_rank}}* in competitive Presence Rate.

*Your Presence Rate*: {{presence_rate_percentage}}%
*Top 3 Competitors*:
• {{competitors__0__name}}: {{competitor_0_percentage}}%
• {{competitors__1__name}}: {{competitor_1_percentage}}%
• {{competitors__2__name}}: {{competitor_2_percentage}}%

<View full report: Intelligence Token {{token}}>

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

Formatting notes:

• Use *bold* for emphasis in Slack
• Calculate percentages with Formatter before this step
• Link to token reference page or internal dashboard

---

Step 8: Test and Enable

Test: Use a Signal report where you’re ranked below #3

Enable: Turn on Zap

Result: Alerts only when competitive position is weak

---

Complete Workflow Summary

1. Gmail: New Signal report
   ↓
2. Extract token
   ↓
3. Fetch JSON
   ↓
4. Calculate competitive rank (Python)
   ↓
5. Filter: Continue only if rank > 3
   ↓
6. Slack: Send alert message with metrics

Zapier tasks used: 6 tasks (only when alert triggers)

---

Workflow 3: Scan Results to Notion Database

Use Case

Create Notion database page for every Scan report with overall score, category scores, and top 5 issues.

Setup Steps

Step 1: Create Notion Database

Database name: Scan Reports

Properties:

• Title (Title): [Website] - [Date]
• Token (Text): Intelligence Token
• Overall Score (Number): 0-100
• Technical SEO (Number): 0-100
• Performance (Number): 0-100
• Accessibility (Number): 0-100
• Security (Number): 0-100
• Issues Count (Number): Total issues
• Status (Select): Good / Needs Work / Critical
• Report Date (Date)

---

Steps 2-4: Same Pattern

1. Gmail trigger (Subject contains “Scan Report”)
2. Extract token (pattern: SCAN-\d{4}-\d{2}-[A-Z0-9]{5})
3. Webhooks GET
4. Parse JSON

---

Step 5: Calculate Status with Formatter

Action: Formatter by Zapier - Text - Lookup Table

Input: {{overall_score}} (from Webhooks step)

Lookup Table:

• 0 to 60: Critical
• 61 to 75: Needs Work
• 76 to 100: Good

Output: Status text

---

Step 6: Count Issues

Action: Code by Zapier - Run Python

Input Data:

• issues: {{issues}} (entire issues array as JSON string)

Code:

import json

issues_json = input_data.get('issues', '[]')
try:
    issues = json.loads(issues_json)
    issues_count = len(issues)

    # Count by severity
    high = len([i for i in issues if i.get('severity') == 'high'])
    medium = len([i for i in issues if i.get('severity') == 'medium'])
    low = len([i for i in issues if i.get('severity') == 'low'])

    # Get top 5 issues (high severity first)
    sorted_issues = sorted(issues, key=lambda x: {'high': 0, 'medium': 1, 'low': 2}.get(x.get('severity', 'low'), 3))
    top_5 = sorted_issues[:5]

    # Format for Notion
    issues_text = '\n'.join([f"• [{i.get('severity', 'N/A').upper()}] {i.get('page', 'N/A')}: {i.get('issue', 'N/A')}" for i in top_5])

    output = {
        'issues_count': issues_count,
        'high_count': high,
        'medium_count': medium,
        'low_count': low,
        'top_5_text': issues_text
    }
except:
    output = {'issues_count': 0, 'top_5_text': 'Error parsing issues'}

Output:

• issues_count: Total issues
• high_count, medium_count, low_count: Counts by severity
• top_5_text: Formatted text for Notion

---

Step 7: Create Notion Page

Action: Notion - Create Database Item

Configuration:

• Database: Scan Reports

Property mapping:

• Title: {{website__url}} - {{created_at}}
• Token: {{token}}
• Overall Score: {{overall_score}}
• Technical SEO: {{category_scores__technical_seo}}
• Performance: {{category_scores__performance}}
• Accessibility: {{category_scores__accessibility}}
• Security: {{category_scores__security}}
• Issues Count: {{issues_count}} (from Step 6)
• Status: (from Step 5)
• Report Date: {{created_at}}

Page Content (Notion block):

## Top Issues

{{top_5_text}}

## Score Breakdown

Technical SEO: {{category_scores__technical_seo}}/100
Performance: {{category_scores__performance}}/100
Accessibility: {{category_scores__accessibility}}/100
Security: {{category_scores__security}}/100

## Intelligence Token

`{{token}}`

Use this token to fetch full JSON data via API: https://api.surmado.com/intelligence/{{token}}

---

Step 8: Test and Enable

Test: Run Scan, verify Notion page created with correct data

Enable: Turn on Zap

Result: Every Scan → automatic Notion database entry

---

Complete Workflow Summary

1. Gmail: New Scan report
   ↓
2. Extract token (SCAN-YYYY-MM-XXXXX)
   ↓
3. Fetch JSON from API
   ↓
4. Calculate status (Good/Needs Work/Critical)
   ↓
5. Count issues and format top 5
   ↓
6. Create Notion database page with scores + issues

Zapier tasks used: 7 tasks per Scan report

---

Workflow 4: Solutions to Email Digest

Use Case

When Solutions report delivered, send executive summary email to leadership team with top 3 recommendations.

Setup Steps

Steps 1-4: Standard Pattern

1. Gmail trigger (Subject contains “Solutions Report”)
2. Extract token (SOLUTIONS-\d{4}-\d{2}-[A-Z0-9]{5})
3. Webhooks GET
4. Parse JSON

---

Step 5: Format Recommendations with Code by Zapier

Action: Code by Zapier - Run Python

Input Data:

• recommendations: {{recommendations}} (JSON string)
• question: {{question__text}}

Code:

import json

recs_json = input_data.get('recommendations', '[]')
question = input_data.get('question', 'Strategic Question')

try:
    recs = json.loads(recs_json)

    # Top 3 recommendations
    top_3 = recs[:3]

    # Format as HTML
    html = f"<h2>Question Analyzed</h2><p>{question}</p><h2>Top 3 Recommendations</h2>"

    for idx, rec in enumerate(top_3, 1):
        html += f"""
        <h3>Option {idx}: {rec.get('action', 'N/A')}</h3>
        <p><strong>Rationale:</strong> {rec.get('rationale', 'N/A')}</p>
        <p><strong>Impact:</strong> {rec.get('estimated_impact', 'N/A')}</p>
        <p><strong>Cost:</strong> {rec.get('estimated_cost', 'N/A')}</p>
        <p><strong>Risk:</strong> {rec.get('risk', 'N/A').upper()}</p>
        <hr>
        """

    output = {'email_html': html}
except:
    output = {'email_html': '<p>Error formatting recommendations</p>'}

Output: email_html (HTML-formatted recommendations)

---

Step 6: Send Email via Gmail

Action: Gmail - Send Email

Configuration:

• To: leadership@yourcompany.com (or distribution list)
• Subject: Solutions Report: {{question__text}}
• Body Type: HTML

Body:

<p>Your Surmado Solutions report has been delivered.</p>

{{email_html}}

<h2>Risk Assessment</h2>
<p><strong>Overall Risk:</strong> {{risk_assessment__overall_risk}}</p>
<p><strong>Key Risks:</strong></p>
<ul>
  <li>{{risk_assessment__key_risks__0}}</li>
  <li>{{risk_assessment__key_risks__1}}</li>
  <li>{{risk_assessment__key_risks__2}}</li>
</ul>

<h2>Model Perspectives</h2>
<p><strong>CFO:</strong> {{model_perspectives__cfo__view}}</p>
<p><strong>Market Realist:</strong> {{model_perspectives__market_realist__view}}</p>

<p><a href="[link to full report PDF]">View Full Report</a></p>

<p><small>Intelligence Token: {{token}}</small></p>

---

Step 7: Test and Enable

Test: Run Solutions, verify email sent with correct formatting

Enable: Turn on Zap

Result: Leadership receives executive summary within minutes of Solutions report delivery

---

Complete Workflow Summary

1. Gmail: New Solutions report
   ↓
2. Extract token
   ↓
3. Fetch JSON
   ↓
4. Format top 3 recommendations as HTML
   ↓
5. Send email digest to leadership

Zapier tasks used: 5 tasks per Solutions report

---

Workflow 5: Multi-Client Agency Dashboard

Use Case

Agency running Signal for 20 clients monthly. Automatically populate master Google Sheet with all client metrics.

Setup Steps

Step 1: Create Master Sheet

Sheet name: Client Dashboard

Columns:

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

Example row:

Phoenix Cool Air | 2025-11-10 | SIG-2025-11-A1B2C | 42.0 | 78 | 28.0 | Competitor A | -12.0 | Needs Work

---

Steps 2-4: Standard Pattern

(Same as Workflow 1: Gmail trigger, extract token, fetch JSON)

---

Step 5: Extract Client Name from Email

Action: Formatter by Zapier - Text - Extract Pattern

Input: {{email_body}} (from Gmail trigger)

Pattern: Business: (.+) (assuming Surmado includes “Business: Phoenix Cool Air” in email body)

Alternative: Use a lookup table mapping tokens to client names

---

Step 6: Calculate Competitive Gap

Action: Code by Zapier - Run Python

Input Data:

• your_rate: {{metrics__presence_rate}}
• top_competitor_rate: {{competitors__0__presence_rate}}

Code:

your_rate = float(input_data.get('your_rate', 0)) * 100
top_rate = float(input_data.get('top_competitor_rate', 0)) * 100

gap = your_rate - top_rate  # Negative if you're behind

output = {
    'competitive_gap': round(gap, 1),
    'status': 'Leading' if gap > 0 else 'Behind'
}

Output:

• competitive_gap: Percentage point difference (e.g., -12.0 means 12 points behind)
• status: Leading or Behind

---

Step 7: Add to Master Sheet

Action: Google Sheets - Create Spreadsheet Row

Configuration:

• Spreadsheet: Client Dashboard
• Worksheet: Sheet1

Column mapping:

• Client Name: (from Step 5)
• Date: {{created_at}}
• Token: {{token}}
• Presence Rate (%): (calculated × 100)
• Authority Score: {{metrics__authority_score}}
• Ghost Influence (%): (calculated × 100)
• Top Competitor: {{competitors__0__name}}
• Competitive Gap (%): {{competitive_gap}} (from Step 6)
• Status: {{status}} (from Step 6)

---

Step 8: Conditional Slack Alert for At-Risk Clients

Action: Filter by Zapier

Configuration:

• Continue only if: {{metrics__presence_rate}} Less than 0.3 (30%)

Action: Slack - Send Channel Message

Message:

At-Risk Client Alert

*Client*: {{client_name}}
*Presence Rate*: {{presence_rate_percentage}}% (below 30% threshold)
*Competitive Gap*: {{competitive_gap}} points behind leader

Action needed: Schedule Solutions consultation or content optimization sprint.

<View report: {{token}}>

---

Step 9: Test and Enable

Test: Send test Signal reports for multiple clients

Enable: Turn on Zap

Result: All client Signal reports automatically populate master dashboard + alerts for at-risk clients

---

Complete Workflow Summary

1. Gmail: New Signal report (any client)
   ↓
2. Extract token
   ↓
3. Fetch JSON
   ↓
4. Extract client name from email
   ↓
5. Calculate competitive gap
   ↓
6. Add row to master Google Sheet
   ↓
7. [If Presence Rate < 30%] Send Slack alert

Zapier tasks used: 7-8 tasks per client report (depending on alert trigger)

For 20 clients/month: 140-160 tasks (within Professional plan limits)

---

Advanced Patterns

Pattern 1: Conditional Paths Based on Tier

Use case: Different workflows for Essential vs Pro reports

Setup:

1. Fetch JSON
2. Check {{tier}} field
3. Use Paths by Zapier (Professional plan)
   • Path A: If tier = pro → full dashboard update
   • Path B: If tier = essential → summary only

---

Pattern 2: Historical Comparison

Use case: Compare current report to previous quarter

Setup:

1. Fetch current report JSON
2. Google Sheets - Lookup Spreadsheet Row (find previous quarter token)
3. Webhooks GET for previous token
4. Code by Zapier - Calculate delta (current - previous)
5. Add comparison to sheet or email

Example output:

• Presence Rate: 42% (+8% vs Q3)
• Authority Score: 78 (+6 vs Q3)

---

Pattern 3: Multi-Destination Sync

Use case: Send same data to Google Sheets + Notion + Airtable

Setup:

1. Gmail trigger
2. Extract token
3. Fetch JSON
4. Google Sheets - Add row
5. Notion - Create page
6. Airtable - Create record

All destinations get same data (single API call, multiple outputs)

---

Pattern 4: Scheduled Competitive Monitoring

Use case: Weekly email with all competitors’ latest Presence Rates

Setup:

1. Schedule by Zapier - Every Monday 9 AM
2. Google Sheets - Lookup Rows (get all competitor tokens)
3. Looping by Zapier - For each token:
   • Webhooks GET
   • Parse presence_rate
4. Aggregate results
5. Send email summary

Note: Requires Professional plan for Looping

---

Troubleshooting

Issue 1: Token Not Extracted

Symptom: Code by Zapier outputs NOT_FOUND

Causes:

• Email subject doesn’t contain token (check if Surmado email format changed)
• Regex pattern incorrect

Fix:

• Check email subject format
• Update regex pattern
• Test with actual email subject in Zapier test

---

Issue 2: Webhooks GET Returns 404

Symptom: Webhooks step fails with 404 Not Found

Causes:

• Token extracted incorrectly (extra spaces, wrong format)
• Token doesn’t exist (test report, not real)

Fix:

• Verify token format: SIG-YYYY-MM-XXXXX (no spaces)
• Test token in browser: https://api.surmado.com/intelligence/{token}
• Check token in original email vs extracted token

---

Issue 3: JSON Fields Not Mapping

Symptom: Google Sheets or Notion shows blank values

Causes:

• Field mapping uses single underscore instead of double (metrics_presence_rate vs metrics__presence_rate)
• Field path incorrect (Zapier uses __ for nested JSON)

Fix:

• Use Zapier’s field picker (don’t type manually)
• Check JSON structure in Webhooks step output
• Nested fields always use double underscore: metrics__presence_rate

---

Issue 4: Zap Triggers Too Many Times

Symptom: Duplicate rows in Google Sheets for same report

Causes:

• Multiple emails from Surmado (confirmation + report)
• Email forwarding creating duplicates

Fix:

• Add Filter step: Continue only if subject contains exact string “Your Signal Report”
• Use Gmail Label filter (only trigger on specific label)
• Add deduplication in Google Sheets (check if token already exists)

---

Issue 5: Percentage Calculations Wrong

Symptom: Presence Rate shows 0.42 instead of 42

Causes:

• Forgot to multiply by 100 (API returns 0-1 decimals)

Fix:

• Add Formatter step: Multiply by 100
• Or use Code by Zapier: output = {'percentage': float(input_data['value']) * 100}

---

Best Practices

1. Use Consistent Naming

Zap names:

• Signal → Google Sheets (Client Dashboard)
• Scan → Notion Database
• Solutions → Email Leadership

Why: Easy to identify in Zapier dashboard (agencies with 50+ Zaps)

---

2. Add Error Notifications

Pattern: Add final step to all Zaps:

Action: Email or Slack

Condition: Only if previous steps failed

Message: Zap failed for token {{token}}. Check Zapier dashboard.

Why: Know immediately when automation breaks

---

3. Use Folders for Organization

Zapier folders (Professional plan):

• Client Reporting (all client dashboard Zaps)
• Internal Monitoring (your own Signal/Scan Zaps)
• Alerts (competitive alerts, at-risk clients)

Why: Easier to manage at scale

---

4. Cache API Responses When Possible

Pattern: After fetching JSON, store in Google Sheets or Airtable

Why: Don’t re-fetch same token multiple times (faster, cleaner logs)

---

5. Test with Real Reports

Don’t use placeholder data when testing Zaps.

Do: Run actual Signal/Scan/Solutions report, use real token for testing

Why: Real data catches edge cases (null values, long text, special characters)

---

Zapier Task Estimation

Single report workflows:

• Simple tracking (Gmail → Sheets): 5 tasks
• With alerts (Gmail → Sheets + Slack): 7-8 tasks
• Complex (Gmail → Notion + email): 8-10 tasks

Agency dashboards (20 clients/month):

• Basic: 100-140 tasks/month
• With alerts: 140-180 tasks/month

Recommended plan:

• 1-5 clients: Starter ($20/month, 750 tasks)
• 5-20 clients: Professional ($50/month, unlimited)
• 20+ clients: Professional + folders + paths

---

Frequently Asked Questions

Can I trigger Zaps without email?

Not currently. Surmado delivers reports via email. Zapier triggers on email delivery. Future API webhook support may enable direct triggers.

Do I need to pay for both Zapier and Surmado?

Yes. Zapier is separate automation platform. Surmado provides reports + API. Zapier connects the two.

Can I share Zaps with clients?

Yes (Professional plan). Use Zapier Transfer to copy Zap to client’s Zapier account. They can customize for their needs.

What if Surmado email format changes?

Regex patterns may need updates. Intelligence Token format is stable (SIG-YYYY-MM-XXXXX), but email subject wording could change. We’ll notify users of format changes.

Can I use Zapier for bulk historical analysis?

Partially. You can manually trigger Zaps with old emails (forward from archive). For bulk token analysis, use Python script with Intelligence Token API (see API Integration Overview).

Does Zapier work with Scan Pro content gap analysis?

Yes. Scan Pro JSON includes content_gaps and competitor_benchmarks arrays. Parse these the same way as issues array (use Code by Zapier for complex formatting).

---

Need help setting up Zapier integrations? Contact hi@surmado.com with your use case, we can provide custom Zap templates or integration support.