zangor-dev

Every edit you make in Notion can land in Airtable automatically — no copy-paste, no manual exports, no data drift. If your team lives in Notion but your operations dashboard runs in Airtable, you already know the pain: the two fall out of sync within hours, someone gets the wrong status, and suddenly half your workday disappears into reconciliation. This guide shows you how to build an n8n workflow that polls your Notion database every 15 minutes and upserts each record straight into Airtable — new items get created, updated items get refreshed, and nothing gets duplicated.

Prefer to skip the setup? Grab the ready-made template → and be up and running in under 10 minutes.

What You’ll Build

1. A schedule-triggered n8n workflow fires every 15 minutes — no manual intervention needed.
2. The workflow fetches every page from your chosen Notion database and filters it down to only those edited in the last 15 minutes, so you’re never re-processing stale data.
3. A Code node extracts the Notion page properties (title, status, priority, email, due date, notes, and tags) into a clean, flat object.
4. The Airtable node upserts each record using the Notion page ID as the unique key — if the row already exists it updates it; if not it creates a new one.
5. Your Airtable base stays in near-real-time sync with Notion, with a direct link back to each Notion page for quick reference.

How It Works — The Big Picture

The workflow is a single linear pipeline: schedule → fetch → filter → transform → upsert. The magic is in the upsert step, which uses the Notion page ID as a match key so it can tell the difference between a record it’s seen before and a brand-new one.

┌──────────────────────────────────────────────────────────────────────┐
│  AUTO-SYNC NOTION DATABASE → AIRTABLE                                │
│                                                                      │
│  [Every 15 Min]                                                      │
│       │                                                              │
│       ▼                                                              │
│  [Fetch All Notion Pages]  ← polls your Notion database             │
│       │                                                              │
│       ▼                                                              │
│  [Filter: Modified in Last 15 Min]  ← skips unchanged records       │
│       │                                                              │
│       ▼                                                              │
│  [Extract & Map Fields]  ← Code node: flattens Notion properties    │
│       │                                                              │
│       ▼                                                              │
│  [Upsert in Airtable]  ← creates new rows OR updates existing ones  │
│                            matched by notion_page_id                 │
└──────────────────────────────────────────────────────────────────────┘

What You’ll Need

• n8n — self-hosted (v1.0+) or an n8n Cloud account
• Notion account — with a database you want to sync; free tier works
• Notion Integration — a connected integration with read access to your database (takes about 2 minutes to set up at notion.so/my-integrations)
• Airtable account — free tier works; you’ll need a base with a table that mirrors your Notion schema
• Airtable Personal Access Token — generated from your Airtable account settings with data.records:write scope

Estimated build time: 30–45 minutes from scratch, or under 10 minutes with the ready-made template.

Building the Workflow — Step by Step

1 Every 15 Minutes (Schedule Trigger)

This node kicks off the entire workflow on a recurring schedule. It doesn’t pass any data downstream — it’s just the heartbeat.

In n8n, add a Schedule Trigger node and configure it like this:

1. Set Trigger Interval to Minutes
2. Set Minutes Between Triggers to 15
3. Click Save

2 Fetch All Notion Pages (Notion node)

This node connects to your Notion database and retrieves all pages inside it. We’ll filter them down in the next step — here we just get everything so nothing slips through the cracks.

1. Add a Notion node and connect your Notion credential (or create one using your integration’s Internal Integration Secret)
2. Set Resource to Database Page
3. Set Operation to Get Many
4. In the Database ID field, paste the ID of your Notion database. You can find it in the database URL: notion.so/workspace/THIS-LONG-ID?v=...
5. Enable Return All so n8n fetches every page, not just the first 100

After this node runs, each output item represents one Notion page. The raw data looks something like this:

{
  "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "last_edited_time": "2026-04-04T09:47:00.000Z",
  "url": "https://www.notion.so/a1b2c3d4e5f67890abcdef1234567890",
  "properties": {
    "Name": { "title": [{ "plain_text": "Q2 Marketing Campaign" }] },
    "Status": { "select": { "name": "In Progress" } },
    "Priority": { "select": { "name": "High" } },
    "Email": { "email": "james.carter@gmail.com" },
    "Due Date": { "date": { "start": "2026-04-15" } },
    "Notes": { "rich_text": [{ "plain_text": "Coordinate with Emily on copy approval." }] },
    "Tags": { "multi_select": [{ "name": "Marketing" }, { "name": "Q2" }] }
  }
}

3 Filter: Modified in Last 15 Min (Filter node)

Without this filter, the workflow would re-upsert every record in your Notion database on every run — wasteful and slow. This node passes only the pages that were edited since the last trigger fired.

1. Add a Filter node
2. Add a condition with Left Value set to the expression:
   ={{ new Date($json.last_edited_time).getTime() }}
3. Set Operator to Greater Than or Equal
4. Set Right Value to:
   ={{ Date.now() - 15 * 60 * 1000 }}
5. Make sure Value Type is set to Number for both sides

4 Extract & Map Fields (Code node)

Notion’s property format is deeply nested — a simple title field is buried inside properties.Name.title[0].plain_text. This Code node flattens everything into a clean, Airtable-ready object with one pass.

1. Add a Code node
2. Set Mode to Run Once for Each Item
3. Paste in the following JavaScript:

// Extract Notion page properties into flat, Airtable-friendly fields
const page = $input.item.json;
const props = page.properties ?? {};

// Helper: safely read any Notion property type
const get = (key, type) => {
  const p = props[key];
  if (!p) return '';
  switch (type) {
    case 'title':        return p.title?.[0]?.plain_text ?? '';
    case 'rich_text':   return p.rich_text?.[0]?.plain_text ?? '';
    case 'select':      return p.select?.name ?? '';
    case 'multi_select': return p.multi_select?.map(s => s.name).join(', ') ?? '';
    case 'date':        return p.date?.start ?? '';
    case 'email':       return p.email ?? '';
    case 'number':      return p.number ?? 0;
    case 'checkbox':    return String(p.checkbox ?? false);
    case 'url':         return p.url ?? '';
    default:            return '';
  }
};

return {
  json: {
    notion_page_id: page.id,
    Name:           get('Name', 'title'),
    Status:         get('Status', 'select'),
    Priority:       get('Priority', 'select'),
    Email:          get('Email', 'email'),
    Due_Date:       get('Due Date', 'date'),
    Notes:          get('Notes', 'rich_text'),
    Tags:           get('Tags', 'multi_select'),
    Last_Edited:    page.last_edited_time,
    Notion_URL:     page.url,
  }
};

After this node runs, each item is a clean, flat object ready to be written to Airtable:

{
  "notion_page_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "Name": "Q2 Marketing Campaign",
  "Status": "In Progress",
  "Priority": "High",
  "Email": "james.carter@gmail.com",
  "Due_Date": "2026-04-15",
  "Notes": "Coordinate with Emily on copy approval.",
  "Tags": "Marketing, Q2",
  "Last_Edited": "2026-04-04T09:47:00.000Z",
  "Notion_URL": "https://www.notion.so/a1b2c3d4..."
}

5 Upsert in Airtable (Airtable node)

This is where the sync actually happens. The Airtable Upsert operation is the key: it checks whether a record matching your specified field already exists, updates it if so, and creates a new one if not — all in a single API call.

1. Add an Airtable node and connect your Airtable credential (Personal Access Token)
2. Set Operation to Upsert
3. Set Base to your Airtable base (select from the dropdown or paste the Base ID)
4. Set Table to your sync table
5. Under Fields to Match On, enter notion_page_id — this is the unique key that tells Airtable whether to create or update
6. In the field mapping section, map each field from the Code node output to the corresponding Airtable column

{
  "notion_page_id": "={{ $json.notion_page_id }}",
  "Name":           "={{ $json.Name }}",
  "Status":         "={{ $json.Status }}",
  "Priority":       "={{ $json.Priority }}",
  "Email":          "={{ $json.Email }}",
  "Due_Date":       "={{ $json.Due_Date }}",
  "Notes":          "={{ $json.Notes }}",
  "Tags":           "={{ $json.Tags }}",
  "Last_Edited":    "={{ $json.Last_Edited }}",
  "Notion_URL":     "={{ $json.Notion_URL }}"
}

The Airtable Table Schema

Your Airtable sync table needs to match the fields your Code node outputs. Here’s the recommended schema — create these columns in Airtable before running the workflow for the first time:

Here’s what a couple of synced rows look like in practice:

Full System Flow

Here’s the complete data journey from Notion edit to Airtable row, end to end:

┌─────────────────────────────────────────────────────────────────────────┐
│  NOTION (source of truth)                                               │
│  User edits a page → last_edited_time updates                           │
└──────────────────────────────┬──────────────────────────────────────────┘
                               │  (every 15 minutes)
                               ▼
┌─────────────────────────────────────────────────────────────────────────┐
│  n8n WORKFLOW                                                           │
│                                                                         │
│  Schedule Trigger (every 15 min)                                        │
│       │                                                                 │
│       ▼                                                                 │
│  Notion node: GET all pages from database                               │
│       │  returns N page objects with nested properties                  │
│       ▼                                                                 │
│  Filter node: keep only pages where                                     │
│               last_edited_time >= now - 15 min                          │
│       │  passes M ≤ N recently changed pages                            │
│       ▼                                                                 │
│  Code node: flatten Notion props → clean JSON object                    │
│       │  { notion_page_id, Name, Status, Priority, … }                  │
│       ▼                                                                 │
│  Airtable Upsert: match on notion_page_id                               │
│       ├─ Record found?  → UPDATE existing row                           │
│       └─ Record missing? → CREATE new row                               │
│                                                                         │
└──────────────────────────────┬──────────────────────────────────────────┘
                               │
                               ▼
┌─────────────────────────────────────────────────────────────────────────┐
│  AIRTABLE (reporting / ops layer)                                       │
│  Rows stay in sync with Notion — max 15 minutes behind                 │
└─────────────────────────────────────────────────────────────────────────┘

Testing Your Workflow

1. Make a test edit in Notion: Open your Notion database, pick any page, and change a field (e.g., update the Status to “In Review”). Save it — Notion updates last_edited_time automatically.
2. Run the workflow manually: In n8n, click Test Workflow (the play button) on the Schedule Trigger node to fire it immediately without waiting 15 minutes.
3. Check the Filter node output: The edited page should pass through. If the Filter passes 0 items, check that your system clock is correct and that the edited page’s last_edited_time is recent.
4. Check Airtable: Within a few seconds, the corresponding row should appear or update in your Airtable table. Verify the field values match what you changed in Notion.
5. Test the upsert (no-duplicate check): Run the workflow a second time immediately. The Airtable row should update in place — no duplicate rows should appear.

Frequently Asked Questions

What’s Next?

• Add a Slack notification: After the Airtable upsert, add a Slack node that posts a message to a channel whenever a high-priority record is synced — good for keeping the team aware of urgent changes without checking Airtable manually.
• Filter by status: Add an IF node after the Code step to only sync records that are “In Progress” or “Done” — useful if you want Airtable to act as a completed-work log rather than a full mirror.
• Reverse sync: Build a companion workflow that polls Airtable for changes and writes them back to Notion, creating a true bidirectional sync between both tools.
• Add error alerting: Wrap the Airtable upsert in a try/catch (or use n8n’s Error Workflow feature) to send yourself an email or Slack DM if the sync fails — so you’re never left with stale data and no idea why.