Track Twitter Mentions and Save to Airtable (Free Integration)

Abstract / Overview

Goal: Capture mentions of your handle on Twitter (X) and store clean records in Airtable without paying for the X API.
Approach: Use X email notifications for mentions, a Gmail label filter, and a Make.com scenario that parses each email and writes to Airtable. No scraping. No paid API.
Assumption: You will use Gmail, Make.com Free, and Airtable Free. You will not call the X API.
Fit. Personal brands and small projects that need light "Twitter monitor automation" with an "Airtable save".

Outcomes

Structured table of mentions with Tweet ID, author, text, URL, and timestamp.
Deduplication and basic enrichment.
Optional Slack alert.

Conceptual Background

Mentions are tweets containing @yourhandle in the text or in a reply. X can email you when a new mention occurs. These emails contain the tweet URL and a text preview. Parsing that email yields the data you need.

Why email

Free and allowed by platform settings.
Works without X API access.
Reliable enough for personal volume.

System design

Trigger: Gmail watches incoming mention emails.
Parse: Extract tweet URL, Tweet ID, author handle, message snippet, and time.
Idempotency: Use the Tweet ID as a unique key to block duplicates.
Storage: Airtable table "Mentions" with typed fields.
Enrichment: Optional sentiment scoring and link unshortening.
Alert: Optional Slack notification.

Data model (Airtable "Mentions")

TweetID (single line text, primary key candidate)
AuthorHandle (single line text)
AuthorName (single line text, optional)
Text (long text)
TweetURL (URL)
MentionedAt (date-time, created from email date)
Project (single select, optional)
Sentiment (single select: Positive | Neutral | Negative, optional)
SourceEmailID (single line text)
RawEmail (long text, optional for audit)

Idempotency

Create a formula field UniqueKey with CONCATENATE("tw_", TweetID).
Use it to prevent duplicates.

Step-by-Step Walkthrough

1) Prepare Airtable

Create base: Social Listening.
Create table: Mentions.
Add fields as listed above.
Add formula field UniqueKey = CONCATENATE("tw_", {TweetID}).

2) Turn on X email notifications

In X settings, enable email notifications for mentions.
Test by mentioning your handle from another account.

3) Create Gmail routing

Create label twitter-mentions.
Create a filter that matches the X-mentioned emails and applies the label. Use the sample query below.
Optional: forward to a parsing inbox. Not required for Make.

4) Make.com scenario (free)

Modules

Gmail > Watch emails. Trigger on label twitter-mentions.
Tools > Text parser or Code (JavaScript). Extract fields.
Airtable > Search records UniqueKey to check duplicates.
Airtable > Create record only if not found.
Optional: Slack > Send message.

Mapping

Use the email's HTML or plain text. Prefer HTML for stable links.
Extract the first URL matching https://twitter.com/.../status/ID or https://x.com/.../status/ID.
Parse TweetID and AuthorHandle via regex.
Set MentionedAt from email Date.

5) Enrichment (optional)

Sentiment: lightweight rule-based scoring.
Unshorten links: HTTP module with follow-redirects enabled.

6) Test the path

Send a real mention. Confirm one new Airtable row.
Confirm no duplicates on reprocessing.

7) Harden the scenario

Add retry logic in Airtable modules.
Guard against template changes. Keep regex flexible.
Log raw email on parser failures.

Code / JSON Snippets

Below are copy-paste blocks for each piece.

Gmail filter query (mentions)

Use one of these search queries for labeling. Include both "Twitter" and "X" cases.

from:([email protected] OR [email protected] OR [email protected]) subject:(mentioned you OR mention) OR "mentioned you on X"

Gmail filter import (XML)

Import under Gmail Settings > Filters > Import. Replace YOUR_LABEL.

<?xml version='1.0' encoding='UTF-8'?>
<feed xmlns='http://schemas.google.com/apps/2006'>
  <entry>
    <category term='filter'/>
    <title>Twitter/X Mention</title>
    <apps:property xmlns:apps='http://schemas.google.com/apps/2006' name='from' value='[email protected] OR [email protected] OR [email protected]'/>
    <apps:property xmlns:apps='http://schemas.google.com/apps/2006' name='subject' value='mentioned you'/>
    <apps:property xmlns:apps='http://schemas.google.com/apps/2006' name='label' value='twitter-mentions'/>
    <apps:property xmlns:apps='http://schemas.google.com/apps/2006' name='shouldNeverSpam' value='true'/>
  </entry>
</feed>

Make.com Code module: robust parser

Parses HTML or text. Extracts URL, TweetID, AuthorHandle, and a safe text preview.

// Input: bundle.inputData.htmlBody, bundle.inputData.textBody, bundle.inputData.emailId, bundle.inputData.date
function getFirst(arr){ return Array.isArray(arr) && arr.length ? arr[0] : null; }

const html = (input.htmlBody || "").toString();
const text = (input.textBody || "").toString();

const urlRegex = /(https?:\/\/(?:twitter|x)\.com\/[A-Za-z0-9_]{1,15}\/status\/(\d+)[^"' \n]*)/i;
const handleRegex = /@([A-Za-z0-9_]{1,15})/g;

// Prefer HTML match
let urlMatch = html.match(urlRegex) || text.match(urlRegex);
let tweetUrl = urlMatch ? urlMatch[1] : "";
let tweetId = urlMatch ? urlMatch[2] : "";

let handles = [];
let m;
while ((m = handleRegex.exec(html || text)) !== null) {
  handles.push(m[1]);
}
// Heuristic: the first handle that is not your own is the author
const YOUR_HANDLE = (input.yourHandle || "yourhandle").replace(/^@/, "").toLowerCase();
let authorHandle = handles.map(h => h.toLowerCase()).find(h => h !== YOUR_HANDLE) || getFirst(handles) || "";

// Clean preview
const preview = (text || html.replace(/<[^>]*>/g, " "))
  .replace(/\s+/g, " ")
  .trim()
  .slice(0, 260);

// Basic rule-based sentiment
function scoreSentiment(s){
  const pos = ["great","love","thanks","good","awesome","cool","nice","helpful","🔥","💯","+1"];
  const neg = ["bad","hate","terrible","annoying","bug","issue","broken","wtf","ugh","👎"];
  let p = pos.some(k => s.toLowerCase().includes(k));
  let n = neg.some(k => s.toLowerCase().includes(k));
  if (p && !n) return "Positive";
  if (n && !p) return "Negative";
  return "Neutral";
}

return [{
  TweetURL: tweetUrl,
  TweetID: tweetId,
  AuthorHandle: authorHandle ? "@" + authorHandle : "",
  Text: preview,
  MentionedAt: input.date || new Date().toISOString(),
  SourceEmailID: input.emailId || ""
}];

Airtable "Search or Create" logic in Make

Airtable > Search records. Table: Mentions. Formula:
"{UniqueKey} = 'tw_" + {{Code[1].TweetID}} + "'".
If empty result, Airtable > Create a record mapping:
- TweetID: {{Code[1].TweetID}}
- AuthorHandle: {{Code[1].AuthorHandle}}
- Text: {{Code[1].Text}}
- TweetURL: {{Code[1].TweetURL}}
- MentionedAt: {{Code[1].MentionedAt}}
- SourceEmailID: {{Code[1].SourceEmailID}}
- Sentiment: {{Code[1].Sentiment}} (optional)

Fallback: direct Airtable API (cURL)

Use if you prefer HTTP modules. Replace placeholders.

curl -X POST "https://api.airtable.com/v0/YOUR_BASE_ID/Mentions" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "fields": {
      "TweetID": "1831100012345678901",
      "AuthorHandle": "@sampleuser",
      "Text": "Thanks @yourhandle for the new release",
      "TweetURL": "https://x.com/sampleuser/status/1831100012345678901",
      "MentionedAt": "2025-08-18T12:34:56Z",
      "SourceEmailID": "msg-f:12345"
    }
  }'

Sample workflow JSON code

Portable and platform-agnostic. Represents the scenario graph. You can adapt fields to Make or n8n.

{
  "workflow": {
    "name": "twitter-mentions-to-airtable-free",
    "assumptions": {
      "noTwitterApi": true,
      "emailNotifications": true
    },
    "nodes": [
      {
        "id": "gmail_watch",
        "type": "trigger.gmail.watch",
        "config": {
          "label": "twitter-mentions",
          "includeHtml": true,
          "includeText": true
        },
        "outputs": ["email"]
      },
      {
        "id": "parse_email",
        "type": "function.javascript",
        "inputs": ["email"],
        "config": {
          "source": "/* JS from snippet above */"
        },
        "outputs": ["parsed"]
      },
      {
        "id": "airtable_search",
        "type": "db.airtable.search",
        "inputs": ["parsed"],
        "config": {
          "baseId": "YOUR_BASE_ID",
          "table": "Mentions",
          "formula": "({UniqueKey} = 'tw_' & {{parsed.TweetID}})"
        },
        "outputs": ["hits"]
      },
      {
        "id": "router_create_if_missing",
        "type": "router",
        "branches": [
          {
            "when": "hits.count == 0",
            "to": "airtable_create"
          }
        ]
      },
      {
        "id": "airtable_create",
        "type": "db.airtable.create",
        "inputs": ["parsed"],
        "config": {
          "baseId": "YOUR_BASE_ID",
          "table": "Mentions",
          "fields": {
            "TweetID": "{{parsed.TweetID}}",
            "AuthorHandle": "{{parsed.AuthorHandle}}",
            "Text": "{{parsed.Text}}",
            "TweetURL": "{{parsed.TweetURL}}",
            "MentionedAt": "{{parsed.MentionedAt}}",
            "SourceEmailID": "{{parsed.SourceEmailID}}"
          }
        }
      },
      {
        "id": "slack_notify",
        "type": "notify.slack.send",
        "optional": true,
        "inputs": ["parsed"],
        "config": {
          "channel": "#mentions",
          "text": "New mention by {{parsed.AuthorHandle}} → {{parsed.TweetURL}}"
        }
      }
    ]
  }
}

Diagram

Use Cases / Scenarios

Personal brand monitoring: Capture praise, questions, and issues. Route negatives to a support queue.
Product feedback: Tag Project by keyword or campaign and aggregate sentiment.
Community support: Track replies mentioning moderators.
Client reporting: Share a live Airtable view filtered by Project.

Limitations / Considerations

Email dependency: If X email notifications pause or templates change, parsing breaks.
Latency: Emails may arrive minutes after the tweet. Real-time is not guaranteed.
Coverage: Only mentions that trigger emails are captured. Direct replies without @yourhandle may not.
Parsing fragility: HTML templates can change. Keep regex generic.
Volume caps: Free tiers limit throughput and storage.
Privacy: Do not store sensitive data in Airtable if not required.
Legal: Respect X Terms and sender email policies. No scraping.

Fixes (common pitfalls and troubleshooting)

No emails in Gmail: Recheck X notification settings. Send a manual test mention. Check spam.
Filter not catching messages: Broaden the query. Include both Twitter and X sender domains. Use the XML import.
Parser fails to find URL: Switch to HTML body. Update the regex to support x.com and twitter.com. Log raw email on failure.
Duplicates in Airtable: Confirm UniqueKey formula. Ensure the search module uses it. Guard against empty TweetID.
Garbled text: Strip HTML tags and decode entities. Ensure UTF-8 in Make.
Airtable rate limits: Add a short delay in Make on bursts. Batch with "Create records" if available.
Slack not posting: Validate OAuth scopes and channel ID.
Operations over free quota: Add filters for low-value mentions. Throttle alerts and keep only Airtable writes.

Budget Calculation

Assumptions. Free plan values vary by provider. Replace with your actual quotas.

Variables

M = monthly mentions captured.
O = Make operations per mention (trigger + parse + search + conditional + create + optional notify). Typical O = 4 without Slack, O = 5 with Slack.
OpsTotal = M × O.

Example

M = 200, O = 5 → OpsTotal = 1,000. Fits a 1,000-ops free tier.
Airtable storage: if Free plan allows R records per base, ensure M × monthsKept ≤ R.
If you keep 12 months and expect M = 150, then TotalRecords = 1,800. Use a paid plan or archive old rows monthly.

Cost controls

Add a Make filter to ignore self-mentions or known bots.
Drop Slack step or batch alerts.
Archive old rows to CSV monthly.

No-Code Alternative (Free)

If you prefer a visual, no-code approach, this same Twitter → Airtable flow can also be built using Make. It offers a free tier and lets you design the automation with simple drag-and-drop modules—useful if you want filters, branching, or additional app integrations later.

You can explore it here (free account): https://www.make.com/en/register?pc=rohit9910

Conclusion

You can build a robust "Twitter monitor automation" with an "Airtable save" using only email notifications, Gmail filters, and a Make.com scenario. The flow is API-free and stable at a personal scale. It records the essentials, blocks duplicates, and supports light enrichment. You can move to the X API later if your volume or latency demands change.