Monday → Memberships

Use a monday.com board as the access list of your members-only pages: when someone is added to the board or their role changes, their row in your Notion members database gets the right tiers; when they are set to Offboarded, archived or deleted, the access goes. Packaged as an AI skill - your AI assistant asks for your details and builds the automation for you in n8n, Make or Zapier.

monday board → n8n / Make / Zapier → Notion members database → Super lets them in

new item / role changed          → add or update the row, tiers from the role
Offboarded / archived / deleted  → remove the tiers, archive the row when none are left

The sync runs one way: the board is the source of truth, and edits made in the Notion rows are overwritten by the next change on the monday item.

Before you start

A Super site on the Personal plan or higher with Super Memberships connected to a Notion members database (Email + Tier multi-select) and at least one page protected by a tier.
A monday.com board with one item per person and the columns Email (email column), Role (status or dropdown) and Status (for example Active / Offboarded).
A Text property Monday item ID in the members database. Super ignores it; the automation uses it to find a row again when an item is deleted or an email changes.
An n8n, Make or Zapier account.

Download

monday-to-super-memberships.zip15.47 KiB

The zip holds the skill for Claude: instructions, the n8n workflow and the Make and Zapier steps. Everything is also below - open a section and copy it.

‣

Prompt - paste into ChatGPT or Notion AI

You are helping me use a monday.com board as the access list of the members-only pages of my Super website (super.so).

How Super Memberships works - keep to these facts:
- Super has no member API. It reads ONE Notion database: one row per member, an Email property (Email, Text or Title type) and a Tier property (Multi-select). A visitor gets into a gated page when their row has at least one of the tiers that page requires. Rows like *@company.com let a whole domain in.
- Members log in with a one-time email link (valid 1 hour). Super sends that link itself when they ask on a gated page; it sends nothing when a member is added.
- Tier options must already exist in Notion and be chosen on the page in Super (Pages → page → Protection → Membership). An automation must never invent a new tier name.
- Removed access ends within 24 hours for members who are already logged in.

Build me a one-way sync monday.com → Notion in {{n8n | Make | Zapier}} that does exactly this:
1. Trigger on my board {{board URL}}: item created, column changed (Email, Role, Status), item archived, item deleted. On n8n use a Webhook node with monday's Webhooks integration and answer monday's challenge: when the body has "challenge", reply with the same JSON {"challenge": "..."} and HTTP 200.
2. Re-read the item from the monday API (api.monday.com/v2, items(ids) { id name state board { id } column_values { id text } }) and decide from that, not from the webhook body. Ignore other boards.
3. Email = the Email column ({{column id}}), trimmed and lower-cased. Role column {{column id}} → tiers with this table: {{Employee → staff; Manager → staff, managers}}. Roles not in the table get no access.
4. Remove access when the item is deleted, archived (state is not active), the Status column {{column id}} is {{Inactive | Offboarded}}, or the role maps to no tier.
5. Find the row in my members database {{database URL}} by the Text property "Monday item ID", or by Email (properties Email = "{{…}}", Tier = "{{…}}").
6. Upsert: the role is the source of truth for the tiers in the table - set those exactly from the role, keep any other tier the row has (for example from a purchase). Found → update Tier, Email and Monday item ID. Not found → create the row with Name, Email, Tier and Monday item ID.
7. Remove: take away the tiers from the table; archive the row when no tier is left.
8. Notion API: header Notion-Version 2022-06-28 with parent.database_id; at most about 3 requests per second.
9. A one-off backfill that runs every item already on the board through the same logic.

Output:
- n8n: a complete workflow JSON I can import, using credentials (Monday.com API, Notion API) - no keys in the JSON.
- Make / Zapier: numbered module-by-module steps with the exact field values and formulas. Say plainly what the platform cannot see (Zapier has no trigger for archived or deleted monday items).
- Then a test plan: new item → Notion row with tiers → login link on the members page → page opens; role change → tiers change; Offboarded → access gone; the same change twice → no duplicate row.

If you have the Super MCP server (https://mcp.super.so/mcp) connected: look up my site with list_sites / list_pages first - each page shows membershipTierIds, the Notion option ids of the tiers that gate it - and match them to the Tier options in my Notion database before building. If you have Notion access, read the members database schema yourself instead of asking me.

‣

n8n workflow (JSON to import)

{
  "name": "monday.com → Super Membership (access list sync)",
  "nodes": [
    {
      "name": "Monday Webhook",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 2,
      "position": [
        0,
        0
      ],
      "id": "3e3d9d10-319e-489c-8f52-9321f2c04c1f",
      "webhookId": "a94047cd-526a-41fa-8e29-3a8655354d6d",
      "notes": "Paste the Production URL into monday: board -> Integrate -> Webhooks (item created, column changed, item archived, item deleted).",
      "parameters": {
        "httpMethod": "POST",
        "path": "monday-to-super-members",
        "responseMode": "responseNode",
        "options": {}
      }
    },
    {
      "name": "Is Challenge",
      "type": "n8n-nodes-base.if",
      "typeVersion": 2.2,
      "position": [
        208,
        0
      ],
      "id": "ac8cc8b6-60f8-42ff-b51a-55e02a8465ab",
      "parameters": {
        "conditions": {
          "options": {
            "caseSensitive": true,
            "leftValue": "",
            "typeValidation": "loose",
            "version": 2
          },
          "conditions": [
            {
              "id": "b9b64cfa-24f6-4e34-a6fb-b75174a967b1",
              "leftValue": "={{ !!($json.body && $json.body.challenge) }}",
              "rightValue": "",
              "operator": {
                "type": "boolean",
                "operation": "true",
                "singleValue": true
              }
            }
          ],
          "combinator": "and"
        },
        "looseTypeValidation": true,
        "options": {}
      }
    },
    {
      "name": "Respond: Challenge",
      "type": "n8n-nodes-base.respondToWebhook",
      "typeVersion": 1.1,
      "position": [
        416,
        -120
      ],
      "id": "2324c809-d200-4a96-99a2-090397719122",
      "notes": "monday verifies a new webhook URL by sending { challenge } and expects the same JSON back.",
      "parameters": {
        "respondWith": "json",
        "responseBody": "={{ { challenge: $json.body.challenge } }}",
        "options": {}
      }
    },
    {
      "name": "Respond: OK",
      "type": "n8n-nodes-base.respondToWebhook",
      "typeVersion": 1.1,
      "position": [
        416,
        80
      ],
      "id": "5d33c1e3-be4a-4242-aa74-e06cfc842cda",
      "parameters": {
        "respondWith": "noData",
        "options": {
          "responseCode": 200
        }
      }
    },
    {
      "name": "Backfill (run once)",
      "type": "n8n-nodes-base.manualTrigger",
      "typeVersion": 1,
      "position": [
        416,
        280
      ],
      "id": "ccc29a6b-c52a-49f5-a9e8-9a19a787a69c",
      "notes": "Click Execute workflow once to load every item that is already on the board.",
      "parameters": {}
    },
    {
      "name": "Settings",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        624,
        80
      ],
      "id": "e5f8b034-9c9b-4b0e-aea9-4456d66989ba",
      "parameters": {
        "jsCode": "// ---- EDIT THIS NODE ONLY -------------------------------------------------\n// Role (monday status/dropdown label) -> tiers. Every tier must be an EXISTING option\n// of the Tier multi-select in your Notion members database. Roles not listed get no access.\nconst ROLE_TIERS = {\n  \"Employee\": [\"staff\"],\n  \"Manager\": [\"staff\", \"managers\"],\n};\n\n// Status labels that end access (the item stays on the board, the member loses the tiers above).\nconst INACTIVE_STATUSES = [\"Inactive\", \"Offboarded\"];\n\nconst CONFIG = {\n  mondayBoardId: \"REPLACE_WITH_BOARD_ID\",       // the number in the board URL\n  emailColumnId: \"email\",                       // monday column ids: board -> column menu -> Copy column ID\n  roleColumnId: \"role\",\n  statusColumnId: \"status\",\n  notionDatabaseId: \"REPLACE_WITH_MEMBERS_DATABASE_ID\",\n  emailProperty: \"Email\",                       // the property Super uses as Email\n  emailPropertyType: \"email\",                   // \"email\", \"rich_text\" or \"title\" - the Notion type of that property\n  tierProperty: \"Tier\",                         // the multi-select property Super uses as Tier\n  nameProperty: \"Name\",                         // the title property (ignored when emailPropertyType is \"title\")\n  itemIdProperty: \"Monday item ID\",             // a Text property you add; links the row to the monday item\n};\n// ---------------------------------------------------------------------------\n\nconst config = { ...CONFIG, roleTiers: ROLE_TIERS, inactiveStatuses: INACTIVE_STATUSES };\nconst body = $input.first().json.body;\n\n// Manual run = backfill: load every item of the board once.\nif (!body || !body.event) return [{ json: { backfill: true, config } }];\n\nconst event = body.event;\n// Events from other boards end the run quietly.\nif (String(event.boardId) !== String(CONFIG.mondayBoardId)) return [];\nconst itemId = String(event.pulseId || event.itemId || \"\");\nif (!itemId) return [];\n// The event type is only a hint: the next node re-reads the item from monday,\n// so a forged or replayed request cannot add or remove anyone.\nreturn [{ json: { backfill: false, itemId, eventType: event.type, config } }];"
      }
    },
    {
      "name": "Is Backfill",
      "type": "n8n-nodes-base.if",
      "typeVersion": 2.2,
      "position": [
        832,
        80
      ],
      "id": "9379e6b9-8ab9-4be5-81e8-1c79e00239cd",
      "parameters": {
        "conditions": {
          "options": {
            "caseSensitive": true,
            "leftValue": "",
            "typeValidation": "loose",
            "version": 2
          },
          "conditions": [
            {
              "id": "85e627c2-683b-431d-897c-68ab33968b7d",
              "leftValue": "={{ $json.backfill === true }}",
              "rightValue": "",
              "operator": {
                "type": "boolean",
                "operation": "true",
                "singleValue": true
              }
            }
          ],
          "combinator": "and"
        },
        "looseTypeValidation": true,
        "options": {}
      }
    },
    {
      "name": "monday: List Board Items",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [
        1040,
        0
      ],
      "id": "3eb08c1d-5620-4ffa-ad14-652f6c8594dd",
      "notes": "Backfill: the first 500 items of the board.",
      "parameters": {
        "method": "POST",
        "url": "https://api.monday.com/v2",
        "authentication": "predefinedCredentialType",
        "nodeCredentialType": "mondayComApi",
        "sendBody": true,
        "specifyBody": "json",
        "jsonBody": "={{ JSON.stringify({ query: 'query ($board: [ID!]) { boards (ids: $board) { items_page (limit: 500) { cursor items { id name state board { id } column_values { id text } } } } }', variables: { board: [$json.config.mondayBoardId] } }) }}",
        "options": {}
      }
    },
    {
      "name": "monday: Get Item",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [
        1040,
        160
      ],
      "id": "56e25cb1-3a92-4b44-acfe-15c920e89450",
      "notes": "Re-reads the item, so the decision is based on monday's real data, not on the webhook body.",
      "parameters": {
        "method": "POST",
        "url": "https://api.monday.com/v2",
        "authentication": "predefinedCredentialType",
        "nodeCredentialType": "mondayComApi",
        "sendBody": true,
        "specifyBody": "json",
        "jsonBody": "={{ JSON.stringify({ query: 'query ($ids: [ID!]) { items (ids: $ids) { id name state board { id } column_values { id text } } }', variables: { ids: [$json.itemId] } }) }}",
        "options": {}
      }
    },
    {
      "name": "Unwrap Items",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        1248,
        80
      ],
      "id": "adcc9e95-5e77-4848-8bdd-46abf55353ce",
      "parameters": {
        "jsCode": "// Turns either monday response (one item by id, or a board page) into one n8n item per monday item.\nconst res = $input.first().json;\nif (res.errors && res.errors.length) throw new Error('monday API: ' + JSON.stringify(res.errors));\nconst data = res.data || {};\n\nif (data.boards) {\n  const page = (data.boards[0] || {}).items_page || { items: [] };\n  if (page.cursor) {\n    // More than 500 items: run the backfill again per group, or raise the limit when monday allows it.\n    console.log('Backfill: board has more than 500 items, only the first page was synced.');\n  }\n  return page.items.map(item => ({ json: { item } }));\n}\n\nconst settings = $('Settings').first().json;\nconst item = (data.items || [])[0];\n// Deleted items are no longer returned: treat them as removed.\nreturn [{ json: { item: item || null, itemId: settings.itemId } }];"
      }
    },
    {
      "name": "Map Member",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        1456,
        80
      ],
      "id": "22860d48-10c4-413f-b273-3ab840e59990",
      "parameters": {
        "jsCode": "// Decides, per monday item, whether the person should have access and with which tiers.\nconst config = $('Settings').first().json.config;\nconst managedTiers = [...new Set(Object.values(config.roleTiers).flat())];\nconst col = (item, id) => ((item.column_values || []).find(c => c.id === id) || {}).text || '';\n\nconst out = [];\nfor (const { json } of $input.all()) {\n  const item = json.item;\n  const itemId = String(item ? item.id : json.itemId);\n\n  let action = 'upsert';\n  let email = '';\n  let tiers = [];\n  let name = '';\n\n  if (!item || item.state !== 'active') {\n    action = 'remove';                                   // archived or deleted on monday\n  } else if (String(item.board && item.board.id) !== String(config.mondayBoardId)) {\n    continue;                                            // not our board\n  } else {\n    email = col(item, config.emailColumnId).trim().toLowerCase();\n    name = String(item.name || '').trim();\n    const status = col(item, config.statusColumnId).trim();\n    // A dropdown column returns \"Role A, Role B\"; a status column returns one label.\n    const roles = col(item, config.roleColumnId).split(',').map(s => s.trim()).filter(Boolean);\n    tiers = [...new Set(roles.flatMap(r => config.roleTiers[r] || []))];\n    if (config.inactiveStatuses.includes(status) || tiers.length === 0) action = 'remove';\n    else if (!/^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(email)) continue;   // no usable email yet\n  }\n\n  const byItemId = { property: config.itemIdProperty, rich_text: { equals: itemId } };\n  const byEmail = { property: config.emailProperty, [config.emailPropertyType]: { equals: email } };\n  const filter = action === 'upsert' ? { or: [byItemId, byEmail] } : byItemId;\n\n  out.push({ json: { action, itemId, email, name, tiers, managedTiers, config,\n    findBody: { filter, page_size: 5 } } });\n}\nreturn out;"
      }
    },
    {
      "name": "Notion: Find Member",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [
        1664,
        80
      ],
      "id": "73a4cb53-9975-4bca-8bbd-e6d8c29ea9dc",
      "parameters": {
        "method": "POST",
        "url": "={{ 'https://api.notion.com/v1/databases/' + $json.config.notionDatabaseId + '/query' }}",
        "authentication": "predefinedCredentialType",
        "nodeCredentialType": "notionApi",
        "sendHeaders": true,
        "headerParameters": {
          "parameters": [
            {
              "name": "Notion-Version",
              "value": "2022-06-28"
            }
          ]
        },
        "sendBody": true,
        "specifyBody": "json",
        "jsonBody": "={{ JSON.stringify($json.findBody) }}",
        "options": {
          "batching": {
            "batch": {
              "batchSize": 1,
              "batchInterval": 400
            }
          }
        }
      }
    },
    {
      "name": "Build Notion Change",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        1872,
        80
      ],
      "id": "f70401d9-e6b9-4e29-a12c-d1d07df31145",
      "parameters": {
        "jsCode": "// One Notion change per member. Tiers that this sync manages (every tier in ROLE_TIERS) follow\n// the monday role exactly; tiers granted by something else (e.g. a Stripe purchase) are kept.\nconst NOTION = 'https://api.notion.com/v1/pages';\nconst members = $('Map Member').all();\nconst out = [];\n\n$input.all().forEach((res, i) => {\n  const m = members[i].json;\n  const c = m.config;\n  const results = res.json.results || [];\n  // Prefer the row already linked to this monday item, then the row with the same email.\n  const row = results.find(r => {\n    const p = r.properties[c.itemIdProperty];\n    return p && (p.rich_text || []).map(t => t.plain_text).join('') === m.itemId;\n  }) || results[0];\n\n  const current = row ? ((row.properties[c.tierProperty] || {}).multi_select || []).map(o => o.name) : [];\n  const kept = current.filter(t => !m.managedTiers.includes(t));\n\n  if (m.action === 'remove') {\n    if (!row) return;                                               // nothing to remove\n    if (kept.length === 0) {\n      out.push({ json: { method: 'PATCH', url: `${NOTION}/${row.id}`, body: { archived: true } } });\n    } else {\n      out.push({ json: { method: 'PATCH', url: `${NOTION}/${row.id}`,\n        body: { properties: { [c.tierProperty]: { multi_select: kept.map(name => ({ name })) } } } } });\n    }\n    return;\n  }\n\n  const tiers = [...new Set([...kept, ...m.tiers])];\n  const text = (s) => [{ text: { content: s } }];\n  const properties = {\n    [c.tierProperty]: { multi_select: tiers.map(name => ({ name })) },\n    [c.itemIdProperty]: { rich_text: text(m.itemId) },\n  };\n  if (c.emailPropertyType === 'title') properties[c.emailProperty] = { title: text(m.email) };\n  else if (c.emailPropertyType === 'email') properties[c.emailProperty] = { email: m.email };\n  else properties[c.emailProperty] = { rich_text: text(m.email) };\n\n  if (row) {\n    out.push({ json: { method: 'PATCH', url: `${NOTION}/${row.id}`, body: { properties } } });\n  } else {\n    if (c.emailPropertyType !== 'title') properties[c.nameProperty] = { title: text(m.name || m.email) };\n    out.push({ json: { method: 'POST', url: NOTION,\n      body: { parent: { database_id: c.notionDatabaseId }, properties } } });\n  }\n});\nreturn out;"
      }
    },
    {
      "name": "Notion: Write Member",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [
        2080,
        80
      ],
      "id": "4b238858-9b9c-499a-a442-d75c0256a227",
      "parameters": {
        "method": "={{ $json.method }}",
        "url": "={{ $json.url }}",
        "authentication": "predefinedCredentialType",
        "nodeCredentialType": "notionApi",
        "sendHeaders": true,
        "headerParameters": {
          "parameters": [
            {
              "name": "Notion-Version",
              "value": "2022-06-28"
            }
          ]
        },
        "sendBody": true,
        "specifyBody": "json",
        "jsonBody": "={{ JSON.stringify($json.body) }}",
        "options": {
          "batching": {
            "batch": {
              "batchSize": 1,
              "batchInterval": 400
            }
          }
        }
      }
    }
  ],
  "connections": {
    "Monday Webhook": { "main": [[{ "node": "Is Challenge", "type": "main", "index": 0 }]] },
    "Is Challenge": { "main": [[{ "node": "Respond: Challenge", "type": "main", "index": 0 }], [{ "node": "Respond: OK", "type": "main", "index": 0 }]] },
    "Respond: OK": { "main": [[{ "node": "Settings", "type": "main", "index": 0 }]] },
    "Backfill (run once)": { "main": [[{ "node": "Settings", "type": "main", "index": 0 }]] },
    "Settings": { "main": [[{ "node": "Is Backfill", "type": "main", "index": 0 }]] },
    "Is Backfill": { "main": [[{ "node": "monday: List Board Items", "type": "main", "index": 0 }], [{ "node": "monday: Get Item", "type": "main", "index": 0 }]] },
    "monday: List Board Items": { "main": [[{ "node": "Unwrap Items", "type": "main", "index": 0 }]] },
    "monday: Get Item": { "main": [[{ "node": "Unwrap Items", "type": "main", "index": 0 }]] },
    "Unwrap Items": { "main": [[{ "node": "Map Member", "type": "main", "index": 0 }]] },
    "Map Member": { "main": [[{ "node": "Notion: Find Member", "type": "main", "index": 0 }]] },
    "Notion: Find Member": { "main": [[{ "node": "Build Notion Change", "type": "main", "index": 0 }]] },
    "Build Notion Change": { "main": [[{ "node": "Notion: Write Member", "type": "main", "index": 0 }]] }
  },
  "settings": {
    "executionOrder": "v1"
  }
}

‣

Claude skill file (instructions)

---
name: monday-to-super-memberships
description: Builds a one-way sync from a monday.com board (a staff or people list) into the Notion members database that Super Memberships reads - a new or changed item adds or updates the member row and sets its tiers from the item's role, and an archived or deleted item or a status such as Inactive or Offboarded removes the access. Produces an importable n8n workflow, a Make scenario plan or a Zapier Zap plan, checks the Super site and the Notion database through the Super and Notion MCP servers when they are connected, loads the existing board items once (backfill) and walks the user through testing. Use when someone wants their monday.com team, client or member board to control who can open members-only pages on a Super site, wants to automate the Notion access list from monday, or asks how to revoke access when someone leaves. Do not use for syncing Notion back to monday, for Super's own billing or plan upgrades, for payment-driven access (use stripe-to-super-memberships), for gating pages with a password, or for monday.com project tracking unrelated to page access.
---

# monday.com → Super Memberships (n8n, Make or Zapier)

Super Memberships has no member API. Super reads one Notion database (one row per member, an **Email**
property and a **Tier** multi-select) and lets an email in when its row holds one of the tiers a page
requires. So "use my monday board as the access list" always means:

~~~
monday.com board ──► automation (n8n / Make / Zapier) ──► row in the Notion members database ──► Super lets them in
 item created / changed      upsert by email, tiers from the role
 archived / deleted / Offboarded       remove the tiers (archive the row when none are left)
~~~

The direction is **monday → Notion only**. Edits made in the Notion rows are overwritten by the next change on
the monday item; tell the user to manage people on the board.

Super sends **no email** when a member is added. A member opens a members-only page, enters their email and gets
a one-time login link (valid 1 hour) from Super. If the user wants people to be told they now have access, add
an email step after the Notion write (see Step 4), or tell the team the members page URL.

## Step 1 - Gather the facts before building anything

Ask only for what you cannot look up. You need:

| Fact | How to get it |
|---|---|
| Automation platform: n8n, Make or Zapier | Ask |
| The Super site and its members-only pages | Super MCP: `list_sites` / `find_site`, then `list_pages`; every page returns `membershipTierIds` (Notion option ids of the tiers that gate it, empty = public) |
| The members database, its Email and Tier properties, the tier names | Notion MCP: fetch the database; map the multi-select option ids to names and match them to `membershipTierIds` from Super |
| The monday board id and the column ids of Email, Role and Status | Ask for the board URL (the number after `/boards/`). Column ids: column header menu → **Copy column ID** (or the monday API: `boards(ids: X) { columns { id title type } }`) |
| Which role grants which tiers, and which status labels end access | Ask; write it as a table, e.g. `Employee → staff`, `Manager → staff, managers`; `Inactive`, `Offboarded` end access |
| Should anything else be sent (welcome email, Slack note) | Ask; optional |

Check before you build, and stop with a clear explanation if any fails:

1. The site is on the **Personal plan or higher** and Membership is connected (the dashboard Membership card shows the database). If no page has `membershipTierIds`, tell the user to protect pages in **Pages → page → Protection → Membership** first.
2. The Tier property is a **Multi-select** and every tier in the role table already exists as an option. Never invent tier names: Super tracks tiers by option id, so a new option created by the automation gates nothing until the user picks it on a page.
3. The board's Email column holds one address per item. Items without a valid email are skipped, not created.
4. Add a **Text** property `Monday item ID` to the members database (Notion MCP can add it; Super ignores extra properties). It links each row to its monday item, so a deleted item can still be found and an email change updates the same row instead of creating a second one.

Without MCP access, ask the user to paste: the database URL and its property names, the tier names, the
members-only page URL, the board URL and the column ids.

## Step 2 - The sync logic (same on every platform)

1. **Trigger** - monday events on the board: item created, column value changed (Email, Role or Status), item archived, item deleted. On n8n these come from monday's **Webhooks** integration; Make and Zapier have native monday triggers for create and change (see the platform sections for what each can see).
2. **Challenge** - when a webhook URL is saved in monday, monday POSTs `{"challenge": "<token>"}` and expects the same JSON back with HTTP 200. Answer it, otherwise monday refuses the URL. Answer every other call with 200 at once.
3. **Re-read the item** from the monday API by its id (`items(ids: [...]) { id name state board { id } column_values { id text } }` on `https://api.monday.com/v2`). Decide from what monday returns, not from the webhook body: webhooks created in the monday UI carry no signature, so a forged call can at most make the workflow re-check a real item. Ignore items from other boards.
4. **Decide**:
   - item missing (deleted) or `state` is not `active` (archived) → **remove**;
   - Status label in the inactive list (`Inactive`, `Offboarded`) → **remove**;
   - Role maps to no tier → **remove** (roles not in the table get no access);
   - otherwise → **upsert** with the role's tiers. Email = the Email column text, trimmed and lower-cased.
5. **Find the row** - query the members database: by `Monday item ID`, or for an upsert by `Monday item ID` **or** Email.
6. **Upsert** - the role is the source of truth for the tiers this sync manages (every tier that appears in the role table). Set those exactly from the role and **keep any other tier the row already has** (for example one a Stripe purchase added). Found → `PATCH` Tier, Email, `Monday item ID`. Not found → `POST` a row with Name (item name), Email, Tier and `Monday item ID`.
   Why not "merge, never replace" as in purchase flows: in a staff directory a role change must take the old role's tiers away (a manager who becomes an employee loses `managers`). Restricting the replacement to the managed tiers gives that, without touching access granted elsewhere. If the user prefers pure merging (tiers only ever added), say that demotions then need a manual edit.
7. **Remove** - drop the managed tiers. If no tier is left, archive the Notion row (`PATCH /v1/pages/{id}` with `{"archived": true}`); otherwise write the remaining tiers. No row → nothing to do.
8. Optional: notify the team (Slack) or send a welcome email to new members.

Write Notion rows with the database id as `parent.database_id` and the header `Notion-Version: 2022-06-28`
(or the data source id as `parent.data_source_id` with API version `2025-09-03` and newer). Mixing the two is the
most common cause of a 404 from Notion. Notion allows about 3 requests per second; throttle bulk runs.

### n8n

There is no monday.com trigger node in n8n (the **monday.com** node only performs actions), so the workflow starts
with a **Webhook** node. Start from `references/n8n-workflow.json`:

**Monday Webhook → Is Challenge → Respond: Challenge | Respond: OK → Settings → Is Backfill → monday: Get Item
(or monday: List Board Items) → Unwrap Items → Map Member → Notion: Find Member → Build Notion Change → Notion: Write Member**,
plus a **Backfill (run once)** manual trigger that enters at Settings.

All settings live in the **Settings** node: `ROLE_TIERS`, `INACTIVE_STATUSES` and `CONFIG` (board id, column ids,
database id, property names and the Notion type of the Email property). Hand the user the JSON to import
(**Workflows → ⋯ → Import from file / paste**). Credentials: *Monday.com API* (a personal API token, used by the
two monday HTTP nodes) and *Notion API* (an internal integration shared with the members database). No key is
stored in the JSON.

Then, in monday: open the board → **Integrate** → **Webhooks** and add one automation per event, each with the
workflow's **Production URL** (activate the workflow first so the URL answers the challenge): when an item is
created, when a column changes, when an item is archived, when an item is deleted. Recipe wording in the monday
UI changes now and then; pick the closest match. The same webhooks can be created with the GraphQL API
(`create_webhook(board_id: X, url: "...", event: create_item)`, and `change_column_value`, `item_archived`,
`item_deleted`). Webhook runs count against the monday plan's monthly integration actions.

If the n8n instance MCP server is connected and allowed to create workflows, create it there directly, inactive,
and give the user the editor link.

### Make and Zapier

Follow `references/make.md` or `references/zapier.md`. They map each step above to that platform's modules.
Neither platform imports a generated file reliably, so give numbered click-by-click steps with the exact field
values, not a blueprint. **Zapier has no monday trigger for archived or deleted items**: on Zapier, access is
removed through the Status column; tell the team to set Status to Offboarded before archiving an item.

## Step 3 - Backfill the people already on the board

The triggers only see changes from now on. Load the existing items once:

- **n8n**: open the workflow, click **Execute workflow** on the **Backfill (run once)** trigger. It reads the first 500 items of the board (`items_page(limit: 500)`) and runs every item through the same logic. Larger boards: run it per group, or loop over `next_items_page(cursor)`.
- **Make**: run the one-off backfill scenario from `references/make.md` (List Board's Items → the same router) once, then delete or disable it.
- **Zapier**: no bulk run. Either touch a column on every item (in monday select all items and set a helper column such as `Sync` to `Yes`, which fires the column-change trigger for each item), or import the board export into Notion once (monday **Export to Excel** → Notion **Merge with CSV**), then let the Zap keep it current.

Run the backfill after the first test passes, and check a few rows in Notion afterwards.

## Step 4 - Optional: tell new members they have access

Super does not email a new member. If the user wants that, add a step after the Notion write that runs only for
new rows (`POST`): an email (Gmail, SendGrid, Resend) with the members page URL and the text "enter this email
address and click the login link you receive (valid one hour)". Show the member's email in bold; another address
will not be recognised. Send with click tracking off. The welcome email template of the stripe-to-super-memberships
skill fits as-is.

## Step 5 - Test before relying on it

1. Use a test board, or a test item on the real board with an email you can read.
2. Create the item with Role = a mapped role and Status = Active. Check: the run succeeded → the Notion row exists with the right tiers and `Monday item ID` → on the members page, entering that email sends a login link → the gated page opens. (Super MCP: `get_link` for the page URL; `check_member` tells whether an email has access; the dashboard **View login log** shows *Login requested / Link sent / Login succeeded*.)
3. Change the Role: the managed tiers change, other tiers stay.
4. Set Status to Offboarded: the managed tiers go; the row is archived when none are left.
5. n8n and Make: archive the item, then create another one and delete it: the access goes.
6. Run the same change twice: no duplicate row.

## What not to do

- Do not put API tokens, Notion secrets or webhook URLs into the workflow as plain text; use the platform's credential store.
- Do not trust the webhook body for decisions; re-read the item from monday.
- Do not create tier options from the automation; they must exist in Notion and be chosen on a page in Super.
- Do not touch tiers that are not in the role table.
- Do not sync Notion back to monday; the board is the single source of truth.
- Do not promise instant revocation: members who are already logged in keep access for up to 24 hours. Disconnecting and reconnecting the database in Super forces an immediate re-check.
- Super MCP cannot connect the members database, set page tiers or send login emails; those are dashboard steps or Super's own login flow. Say so instead of attempting them.

‣

Make scenario steps

# Make scenario - monday.com → Super Membership

Same logic as the n8n workflow, module by module. Module names can differ slightly between Make versions;
pick the closest match. In the formulas, `staff` and `managers` stand for the tiers in your role table (the
"managed" tiers) - list all of them.

Why a custom webhook and not the monday **Watch** triggers: monday's triggers in Make cover new items and column
changes, but archived and deleted items reach Make reliably only through monday's own **Webhooks** integration.
One custom webhook receives all four events, so one scenario handles them all.

## Scenario 1 - Sync (runs on every change)

| # | Module | Settings |
|---|---|---|
| 1 | **Webhooks → Custom webhook** | Add a webhook, copy its address. Leave **Determine data structure** until monday has sent the first event. |
| 2 | **Webhooks → Webhook response** | Status `200`, body `{"challenge":"{{1.challenge}}"}`. monday sends `{"challenge": …}` when you save the URL and expects it back; on normal events the body is ignored. |
| 3 | Filter on the link 2 → 4 | `{{1.event.boardId}}` *Equal to* your board id (stops the challenge call and other boards). |
| 4 | **monday.com → Get an Item** | Item ID `{{1.event.pulseId}}`. Re-reads the item, so decisions come from monday, not from the webhook body. Right-click → **Add error handler → Resume** with empty output: a deleted item no longer exists. |
| 5 | **Tools → Set multiple variables** | `email` = `{{lower(trim(first(map(4.column_values; "text"; "id"; "email"))))}}` (use your Email column id), `role` = same with the Role column id, `status` = same with the Status column id, `itemId` = `{{1.event.pulseId}}`. |
| 6 | **Tools → Switch** | Input `{{5.role}}`; cases `Employee` → `staff`, `Manager` → `staff,managers`; no match → empty. Output = the role's tiers, comma separated. |
| 7 | **Tools → Set variable** | `action` = `{{if(4.id = null \| 4.state != "active" \| 5.status = "Offboarded" \| 5.status = "Inactive" \| 6.output = null; "remove"; "upsert")}}` |
| 8 | **Notion → Make an API call** | `POST /v1/databases/<DATABASE_ID>/query`, header `Notion-Version: 2022-06-28`, body `{"filter":{"or":[{"property":"Monday item ID","rich_text":{"equals":"{{5.itemId}}"}},{"property":"Email","email":{"equals":"{{5.email}}"}}]},"page_size":1}`. For a remove with no email the email clause simply matches nothing. |
| 9 | **Tools → Set variable** | `kept` = `{{remove(map(8.body.results[1].properties.Tier.multi_select; "name"); "staff"; "managers")}}` - tiers this sync does not manage (for example a Stripe purchase). |
| 10 | **Router** | Four routes, each with a filter: |
| 10A | Upsert, new row - filter `action` = `upsert` and `{{length(8.body.results)}}` = 0 | **Notion → Make an API call** `POST /v1/pages`, body `{"parent":{"database_id":"<DATABASE_ID>"},"properties":{"Name":{"title":[{"text":{"content":"{{4.name}}"}}]},"Email":{"email":"{{5.email}}"},"Monday item ID":{"rich_text":[{"text":{"content":"{{5.itemId}}"}}]},"Tier":{"multi_select":[{"name":"{{join(split(6.output; ","); "\"},{\"name\":\"")}}"}]}}}` |
| 10B | Upsert, existing row - `action` = `upsert` and results > 0 | `PATCH /v1/pages/{{8.body.results[1].id}}`, body `{"properties":{"Email":{"email":"{{5.email}}"},"Monday item ID":{"rich_text":[{"text":{"content":"{{5.itemId}}"}}]},"Tier":{"multi_select":[{"name":"{{join(distinct(merge(9.kept; split(6.output; ","))); "\"},{\"name\":\"")}}"}]}}}` - the role sets the managed tiers, other tiers stay. |
| 10C | Remove, other tiers left - `action` = `remove`, results > 0, `{{length(9.kept)}}` > 0 | `PATCH /v1/pages/{{8.body.results[1].id}}`, body `{"properties":{"Tier":{"multi_select":[{"name":"{{join(9.kept; "\"},{\"name\":\"")}}"}]}}}` |
| 10D | Remove, nothing left - `action` = `remove`, results > 0, `length(9.kept)` = 0 | `PATCH /v1/pages/{{8.body.results[1].id}}`, body `{"archived":true}` (archives the row). |

For a removal, look the row up by `Monday item ID` only when the email is empty (deleted items): the `or` filter
above already does that, because an empty email matches no row.

Turn on the scenario (scheduling: **Immediately**). Then in monday: board → **Integrate** → **Webhooks**, and add
one automation per event with the webhook address from module 1: item created, column changed, item archived,
item deleted. Each save triggers the challenge, which module 2 answers. Webhook runs count against the monday
plan's monthly integration actions.

## Scenario 2 - Backfill (run once)

**monday.com → List Board's Items** (your board, limit high enough for all items) → **Iterator** (if the module
returns an array) → modules 5 to 10 of scenario 1, with `4.` replaced by the iterator's item. Run it once with
**Run once**, check a few Notion rows, then turn it off. Notion allows about 3 requests per second; with many
items add **Tools → Sleep** (400 ms) before the Notion calls.

## Notes

- Add a **Text** property `Monday item ID` to the members database first; Super ignores it.
- The Email property type decides the filter key: `email` for an Email property, `rich_text` for Text, `title` for a Title property.
- Optional welcome email: on route 10A add **Gmail → Send an email** (or SendGrid) to `{{5.email}}` with the members page URL and "enter this email and click the login link you receive".

‣

Zapier Zap steps

# Zapier Zap - monday.com → Super Membership

Same logic as the n8n workflow, step by step. Zapier step names change now and then (Notion's *Database Item* steps are now called *Data Source Item*); pick the closest match.
Zapier cannot import a generated Zap, so give the user these steps with their own values filled in.

**Limit:** Zapier's monday.com app has no trigger for archived or deleted items, and Webhooks by Zapier cannot
answer monday's challenge. On Zapier, access is removed through the **Status** column: the team sets Status to
`Offboarded` (or `Inactive`) before archiving or deleting an item. If archiving alone must revoke access, use
n8n or Make.

In the code steps, `MANAGED` lists every tier that appears in your role table.

| # | Step | Settings |
|---|---|---|
| 1 | **Trigger: monday.com → Specific Columns Values Changed in Board** (instant) | Board: your people board. Columns: Email, Role, Status. Fires for new items too, as soon as these columns are filled. (Use **New Item in Board** in a second Zap only if items are created with all columns already set by an import or form.) |
| 2 | **monday.com → Get Column Values** | Item = the trigger's item id. Returns Email, Role and Status of the item as monday has them now. |
| 3 | **Formatter → Text → Lowercase**, then **Formatter → Text → Trim Whitespace** | Input: the Email column value from step 2. |
| 4 | **Formatter → Utilities → Lookup Table** | Lookup key: Role from step 2. Rows: `Employee` → `staff`, `Manager` → `staff,managers`. Fallback: empty. |
| 5 | **Notion → Find Data Source Items** | Data source: your members database. Search property Email = step 3. Do **not** use *Find or Create* - step 6 decides. |
| 6 | **Code by Zapier → Run JavaScript** | Inputs: `existing` = step 5 Tier, `roleTiers` = step 4, `status` = step 2 Status, `found` = step 5 ID. Code below. |
| 7 | **Paths by Zapier** | Path A *Create* (`action` = `create`), Path B *Update* (`action` = `update`), Path C *Archive* (`action` = `archive`). |
| 7A | **Notion → Create Data Source Item** | Name = item name, Email = step 3, Tier = step 6 `tiers`, Monday item ID = the item id. |
| 7B | **Notion → Update Data Source Item** | Item = step 5 ID; Email = step 3, Tier = step 6 `tiers`, Monday item ID = the item id. |
| 7C | **Notion → Archive Data Source Item** | Item = step 5 ID. The row goes to the Notion trash; Super stops letting that email in. |

Code for step 6:

~~~javascript
const MANAGED = ['staff', 'managers'];                  // every tier in your role table
const INACTIVE = ['Inactive', 'Offboarded'];
const split = s => (s || '').split(',').map(t => t.trim()).filter(Boolean);
const kept = split(inputData.existing).filter(t => !MANAGED.includes(t));   // e.g. a tier from Stripe
const role = split(inputData.roleTiers);
const remove = INACTIVE.includes((inputData.status || '').trim()) || role.length === 0;
const tiers = remove ? kept : [...new Set([...kept, ...role])];
let action = 'skip';
if (!remove) action = inputData.found ? 'update' : 'create';
else if (inputData.found) action = tiers.length ? 'update' : 'archive';
return { action, tiers: tiers.join(',') };
~~~

The role sets the managed tiers exactly (a demoted manager loses `managers`), tiers from anywhere else stay.
Running the Zap twice for the same item changes nothing. Paths by Zapier needs a paid Zapier plan; on a free plan
build three Zaps with the same steps 1 to 6 and a **Filter** on `action` instead of the paths.

**Email changes:** this Zap finds the row by Email. When someone's email changes on the board, the old row keeps
its tiers; remove it by hand, or find the row by a `Monday item ID` Text property instead of Email.

**Backfill:** Zapier cannot load the existing items in bulk. Either touch a column on every item (in monday select
all items and set a helper column such as `Sync` to `Yes`, and add that column to the trigger), or import the board
once into Notion (monday **Export to Excel** → Notion **Merge with CSV**, mapping Role to the tier names), then let
the Zap keep it current.

**Optional welcome email:** on Path A add **Gmail → Send Email** (or SendGrid) to step 3 with the members page URL
and "enter this email and click the login link you receive". Avoid *Email by Zapier*; it often lands in spam.

Install in your AI assistant

Claude

Settings → Capabilities → Skills → Upload skill, choose monday-to-super-memberships.zip.
Settings → Connectors → Add custom connector, URL https://mcp.super.so/mcp, then sign in to Super. Add the Notion connector too, so Claude can read your members database (and add the Monday item ID property for you).
Ask: "Sync my monday staff board to Super Memberships with n8n."

Claude checks your site and its protected pages through the Super MCP server, reads the tiers from Notion, asks only for what it cannot look up (board, column ids, the role table), and hands you the finished workflow. With the n8n or Zapier MCP server connected as well, it can create the workflow in your account directly. In Claude Code, unzip the skill into ~/.claude/skills/.

ChatGPT

ChatGPT has no skill upload, so the skill becomes a project:

Create a Project, paste the Prompt into the project instructions and upload the files from the zip.
Connect Super: Settings → Apps & Connectors, add a custom connector with https://mcp.super.so/mcp (needs developer mode on your plan), and connect Notion.
Ask in the project: "Build it for Make."

Notion AI

Create a Custom Agent, paste the Prompt into its instructions and add the n8n, Make and Zapier sections as pages.
Notion AI already sees your workspace, so it can create the members database for you or fix one that does not match (Email property, Tier as multi-select, tier options, the Monday item ID property).
Super MCP: in the agent's Tools & Access → Custom MCP server, add https://mcp.super.so/mcp (Business or Enterprise plan; a workspace admin enables custom MCP servers first).
Notion AI cannot open n8n, Make or Zapier - it writes the workflow and you import it.

What each assistant can do

	Claude	ChatGPT	Notion AI
Install the skill	Upload zip	Project instructions + files	Custom Agent instructions
Read your Super site (MCP)	Yes	Yes, custom connector	Yes, Business/Enterprise
Read your members database	Notion connector	Notion connector	Native, can also create it
Create the workflow for you	With n8n / Zapier MCP	With n8n / Zapier MCP	No - import / follow steps

n8n, Make or Zapier?

	n8n	Make	Zapier
What you get	Workflow JSON - import and fill in	Module-by-module steps	Step-by-step Zap
monday trigger	Webhook node + monday Webhooks integration	Custom webhook + monday Webhooks integration	monday Specific Columns Values Changed in Board
Archived / deleted item removes access	Yes	Yes	No - set Status to Offboarded
Role change takes old tiers away	Code node	`remove()` / `merge()` formulas	Code by Zapier step
Backfill existing items	Built-in manual run	One-off scenario	Touch a column or CSV import
Best for	Self-hosting, full control	Visual builder, low cost	Fastest setup

Why the role sets the tiers

In a purchase flow, tiers are only ever added. A staff directory is different: when a manager becomes an employee, the managers tier has to go. So the role is the source of truth for the tiers in your role table - they are set exactly from the role - while any other tier on the row (for example one a Stripe purchase added) is left alone. When nothing is left, the row is archived.

Load the people already on the board

The triggers only see changes from now on. After the first test, run the backfill once: in n8n click Execute workflow on Backfill (run once) (first 500 items), in Make run the one-off backfill scenario, in Zapier touch a helper column on all items or import the board export into Notion once. Then check a few rows.

Test it

Add a test item with a mapped Role, Status Active and an email you can read.
Check: the run succeeded → the Notion row has the tiers and the Monday item ID → the members page sends a login link to that email → the page opens.
Change the Role: the tiers change. Set Status to Offboarded: the access goes.
n8n and Make: archive or delete an item: the access goes.
Make the same change twice: no duplicate row.

Removing a member (Offboarded, archived or deleted) ends access within 24 hours for members who are already logged in. Disconnect and reconnect the database in Super to force it immediately.

Still evolving. The Super MCP server, Notion and the AI assistants are all changing fast, so you may run into limits. Tell us in MCP feedback: we want to know, and if there is a workaround, we will help you with it.