No-Code / Low-Code AI Systems

n8n Follow Up Boss Integration: Leads to Google Sheets with AI Scoring

You'll build an n8n workflow that catches every new Follow Up Boss lead, cleans the contact details and adds an OpenAI qualification score before writing one row to Google Sheets. It replaces daily copy and paste, catches duplicates and puts the hottest leads in front of your team first.

26 min read 15 views
A minimal white office desk with a laptop showing an automation workflow diagram with one orange step, a phone with an orange notification, house keys, property folders and an orange mug.

Key Takeaways

You'll build an n8n workflow that catches every new Follow Up Boss lead, cleans the contact details and adds an OpenAI qualification score before writing one row to Google Sheets. It replaces daily copy and paste, catches duplicates and puts the hottest leads in front of your team first.

This n8n follow up boss integration removes a job someone on most real estate teams does by hand every day: opening each new lead in Follow Up Boss, copying the name, email, phone, source and price into a shared Google Sheet, then reading the notes to decide who gets a call first. It's usually an admin, an inside sales agent or the team lead squeezing it between showings. Done by hand, rows get skipped, phone numbers get pasted in three different formats, the same lead lands in the sheet twice, and the hottest inquiry can sit unread until someone remembers to check. You'll build a workflow that does all of it the moment a lead is created.

Last updated: November 2026

By the end you'll have a live n8n workflow that receives a Follow Up Boss webhook, pulls the full contact record, cleans and enriches it, asks an OpenAI model to score the lead, and writes one tidy row per person to Google Sheets. No duplicates. No copy and paste.

Workflow at a glance

ItemDetail
Problem it solvesNew leads reach the team's tracking sheet late, inconsistently formatted, duplicated, or not at all, and nobody triages them until someone reads every record.
Manual steps it replacesChecking Follow Up Boss for new people; opening each record; copying name, email, phone, source, stage, price and tags; reformatting the phone; checking whether the lead is already in the sheet; reading the background notes; writing a priority and next action.
TriggerA Follow Up Boss peopleCreated webhook posting to an n8n Webhook node.
OutputOne row per lead in a Google Sheet tab called Leads, with cleaned contact fields plus AI score, tier, intent, timeline, reason and next action.
Toolsn8n (cloud or self-hosted), Follow Up Boss API, Google Sheets, OpenAI API.
Skill level neededComfortable with n8n nodes and pasting short JavaScript snippets. You don't need to write code from scratch.
ComplexityMedium. The node chain is short, but you have to register a webhook with system headers, handle rate limits and validate AI output.

What you need before you start

Gather these first. It saves a lot of back and forth later.

  • An n8n instance with a public HTTPS URL. n8n Cloud gives you one out of the box; a self-hosted instance needs a domain and SSL certificate, because Follow Up Boss only posts webhooks to secure endpoints.
  • A Follow Up Boss API key. In Follow Up Boss, open Admin, then API, and create a key. For registering webhooks you need the account owner's key, since only the owner can create, update or delete webhooks.
  • A registered system name and system key. Follow Up Boss asks integrations to identify themselves with two headers: X-System (your system's name) and X-System-Key (a secret it issues you). Register through the Identification section of the Follow Up Boss API reference. The webhook endpoints refuse requests without X-System.
  • A Google account and a Google Sheets credential in n8n. In n8n, go to Credentials, add Google Sheets, and sign in with OAuth2. The account needs edit access to the target spreadsheet.
  • An OpenAI API key. Create it in the API keys page of your OpenAI platform account, add billing, then add an OpenAI credential in n8n.
  • A test lead (create it in Follow Up Boss with a fake name and an email you control).

Then set up the spreadsheet. Create a new Google Sheet, rename the first tab to Leads, and paste this header row into row 1, one name per column:

fub_id | created_at | first_name | last_name | email | email_valid | email_domain | email_type | phone | phone_digits | source | source_url | stage | price | tags | lead_type | assigned_to | background | event_id | ai_score | ai_tier | ai_intent | ai_timeline | ai_reason | ai_next_action | processed_at

Column names matter. The n8n Google Sheets node maps by header text, so a typo here becomes an empty column later.

For sample data, create two or three test people in Follow Up Boss: one buyer with a price and a note like "wants to tour next weekend", one seller tagged Seller, and one with no email at all. You'll reuse them in the tests section.

How the workflow runs

Here's the full path a lead takes, with the fields handed from node to node.

  1. Trigger: Webhook node. Follow Up Boss posts JSON containing eventId, eventCreated, event, resourceIds (an array of person IDs) and uri. n8n answers 200 straight away.
  2. Split resource IDs (Code). Drops anything that isn't peopleCreated, then emits one item per ID with personId and eventId. Decision point: zero IDs means the workflow simply stops.
  3. Get person (HTTP Request). Calls GET /v1/people/{personId} with a fields list and returns id, created, firstName, lastName, emails, phones, source, sourceUrl, stage, price, tags, assignedTo, background.
  4. Normalize lead (Code). Produces flat fields: fub_id, email, email_valid, email_domain, email_type, phone_digits, lead_type and the rest of the sheet columns.
  5. Find existing row (Google Sheets, Get Row(s)). Looks up fub_id in the Leads tab.
  6. Is new lead? (IF). Branch: if a row already exists, the item goes to the false output and stops (no AI cost, no duplicate). If not, it continues.
  7. Score lead (OpenAI). Sends only non-identifying fields and gets back JSON with score, tier, intent, timeline, reason, next_action.
  8. Parse AI output (Code). Validates the JSON. Branch inside the code: bad or missing output sets ai_tier to needs_review instead of failing.
  9. Output: Write lead (Google Sheets, Append or Update Row). Matches on fub_id and writes the full row.

Build it step by step

Create a new workflow in n8n and name it FUB new lead to Sheets. Node labels in n8n shift a little between versions, so if a menu item reads slightly differently in yours, look for the closest match.

Step 1: Add the Webhook trigger

Click the plus button, search for Webhook, and add it as the first node. Set:

  • HTTP Method: POST
  • Path: fub-new-lead-7f3k2 (add your own random suffix so the URL is hard to guess)
  • Authentication: None. Follow Up Boss can't send custom auth headers on webhooks, which is why the random path matters.
  • Respond: Immediately, with response code 200.

Responding immediately is the key setting. Follow Up Boss expects a quick 2XX answer and keeps retrying when it doesn't get one, which is a classic source of duplicate rows.

Copy both URLs the node shows you: the Test URL (contains /webhook-test/) and the Production URL (contains /webhook/). Click Listen for test event, then send this from a terminal, swapping in the ID of your test person (you'll find it in the person's page URL in Follow Up Boss):

curl -X POST "https://YOUR-N8N-DOMAIN/webhook-test/fub-new-lead-7f3k2" \
  -H "Content-Type: application/json" \
  -d '{"eventId":"test-001","eventCreated":"2026-11-15T09:00:00+00:00","event":"peopleCreated","resourceIds":[REAL_TEST_PERSON_ID],"uri":"https://api.followupboss.com/v1/people?id=REAL_TEST_PERSON_ID"}'

Check: the Webhook node shows one item whose body contains event: "peopleCreated" and a resourceIds array with your test ID.

Step 2: Split the resource IDs

A single webhook can carry several person IDs at once. Add a Code node after the Webhook, rename it exactly Split resource IDs (later code refers to that name), set Mode to Run Once for All Items and Language to JavaScript, then paste:

// n8n Code node: "Split resource IDs"
// Mode: Run Once for All Items
const out = [];
for (const item of $input.all()) {
  const body = item.json.body || item.json;
  if (body.event !== 'peopleCreated') continue;
  const ids = Array.isArray(body.resourceIds) ? body.resourceIds : [];
  for (const id of ids) {
    out.push({ json: {
      personId: String(id),
      eventId: body.eventId || '',
      eventCreated: body.eventCreated || ''
    }});
  }
}
return out;

Check: run the node. You get one output item per ID, each with personId, eventId and eventCreated. Change event in your test body to peopleUpdated and you should get zero items.

Step 3: Fetch the full person from Follow Up Boss

The webhook only tells you which people were created, not their details. So you fetch them. Every call goes over HTTPS to the Follow Up Boss v1 API endpoint, which its docs list as the only API version.

First create the credential. In n8n, open Credentials, click Add credential, choose Basic Auth, name it FUB API, put your API key in User and leave Password empty. Follow Up Boss uses the key as the username in HTTP Basic authentication.

Now add an HTTP Request node named Get person:

  • Method: GET
  • URL: https://api.followupboss.com/v1/people/{{ $json.personId }}
  • Authentication: Generic Credential Type, then Generic Auth Type: Basic Auth, credential FUB API
  • Send Query Parameters: on. Name fields, value id,created,firstName,lastName,emails,phones,source,sourceUrl,stage,price,tags,assignedTo,background
  • Send Headers: on. X-System = your registered system name; X-System-Key = your system key
  • Options, Batching: Items per Batch 5, Batch Interval 2000 ms. This paces bursts so a bulk import doesn't hammer the API.

Then open the node's Settings tab and turn on Retry On Fail with Max Tries 3 and Wait Between Tries 5000 ms.

Why ask for specific fields? The allFields option is handy while exploring, but it returns much larger responses. Naming the fields keeps each response small and predictable.

Check: the output item has your test person's id, firstName, an emails array with objects like {"value": "...", "isPrimary": true}, and a tags array. A 401 means the key or Basic Auth setup is wrong.

Step 4: Normalize and enrich the contact

This is where the "enrich" part happens, without buying a data service. The code picks the primary email and phone, lowercases the email, checks its format, flags personal versus business domains, strips the phone to digits, joins tags into one cell, and labels the lead as Seller when it carries a Seller tag (otherwise Buyer). Check how your own account tags sellers before relying on that rule.

Add a Code node named Normalize lead, set Mode to Run Once for Each Item, and paste:

// n8n Code node: "Normalize lead"
// Mode: Run Once for Each Item
const p = $json;
const emails = Array.isArray(p.emails) ? p.emails : [];
const phones = Array.isArray(p.phones) ? p.phones : [];
const tags = Array.isArray(p.tags) ? p.tags : [];
const email = ((emails.find(e => e.isPrimary) || emails[0] || {}).value || '').trim().toLowerCase();
const phoneRaw = ((phones.find(x => x.isPrimary) || phones[0] || {}).value || '');
const phoneDigits = phoneRaw.replace(/\D/g, '');
const emailValid = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
const freeDomains = ['gmail.com','yahoo.com','outlook.com','hotmail.com','icloud.com','aol.com'];
const domain = emailValid ? email.split('@')[1] : '';
return { json: {
  fub_id: String(p.id || ''),
  created_at: p.created || '',
  first_name: (p.firstName || '').trim(),
  last_name: (p.lastName || '').trim(),
  email,
  email_valid: emailValid ? 'yes' : 'no',
  email_domain: domain,
  email_type: !domain ? '' : (freeDomains.includes(domain) ? 'personal' : 'business'),
  phone: phoneRaw,
  phone_digits: phoneDigits,
  source: p.source || '',
  source_url: p.sourceUrl || '',
  stage: p.stage || '',
  price: p.price || '',
  tags: tags.join(', '),
  lead_type: tags.includes('Seller') ? 'Seller' : 'Buyer',
  assigned_to: p.assignedTo || '',
  background: (p.background || '').slice(0, 2000),
  event_id: $('Split resource IDs').item.json.eventId
}};

Edit freeDomains to match the providers common in your market.

Check: output has flat fields only, no arrays. A lead with Jane@Example.COM shows email = jane@example.com, email_valid = yes, email_type = business.

Step 5: Look up the lead in the sheet

Before you spend a model call, find out whether this lead is already there. Add a Google Sheets node named Find existing row:

  • Operation: Get Row(s)
  • Document: pick your spreadsheet; Sheet: Leads
  • Filters: Column fub_id, Value {{ $json.fub_id }}

In the node's Settings tab, switch on Always Output Data. Without it, a "not found" result outputs nothing and the workflow quietly stops for every brand-new lead. Which is exactly the opposite of what you want.

Check: for a lead that isn't in the sheet, the node outputs one empty item. For a lead that is, it outputs the existing row.

Step 6: Branch on new versus existing

Add an IF node named Is new lead?. Condition: String, value 1 {{ $json.fub_id }}, operation is empty.

The true branch continues. Leave the false branch unconnected, or connect it to a No Operation node if you like seeing where duplicates end.

From here on, read lead data from the Normalize lead node rather than $json, because $json now holds the sheet lookup result.

Check: run with a fresh test lead and the item exits on true. Run the same webhook body again after Step 9 exists and it exits on false.

Step 7: Score the lead with OpenAI

Add an OpenAI node on the true branch, choose the Message a model action (under Text), and name it Score lead. Settings:

  • Credential: your OpenAI credential
  • Model: a small, current chat model from the dropdown. Lead scoring is a short classification task, so a large model rarely earns its price here.
  • Messages: one message with role System holding the system prompt from the templates section, and one with role User holding the user prompt template
  • Output Content as JSON: on
  • Options, Sampling Temperature: 0.2 for steadier scores

In the user prompt, replace $json with $('Normalize lead').item.json so the expressions read the cleaned lead, for example {{ $('Normalize lead').item.json.lead_type }}.

Notice what's missing from the prompt: name, email and phone. The model doesn't need them to judge intent, and keeping personal details out of the request is simply good hygiene.

Check: the output contains a JSON object (often under message.content) with all six keys, and tier is one of hot, warm, cold or unknown.

Step 8: Validate the AI output

Models occasionally return text that isn't valid JSON, or a tier you didn't ask for. Don't let that crash the run. Add a Code node named Parse AI output, Run Once for Each Item:

// n8n Code node: "Parse AI output"
// Mode: Run Once for Each Item
const lead = $('Normalize lead').item.json;
let raw = $json.message?.content ?? $json.output ?? $json.text ?? $json;
let ai = null;
try {
  ai = typeof raw === 'string' ? JSON.parse(raw) : raw;
} catch (e) {
  ai = null;
}
const tiers = ['hot', 'warm', 'cold', 'unknown'];
const ok = ai && tiers.includes(ai.tier) && Number.isInteger(ai.score)
  && ai.score >= 0 && ai.score <= 100;
return { json: {
  ...lead,
  ai_score: ok ? ai.score : '',
  ai_tier: ok ? ai.tier : 'needs_review',
  ai_intent: ok ? (ai.intent || '') : '',
  ai_timeline: ok ? (ai.timeline || '') : '',
  ai_reason: ok ? (ai.reason || '').slice(0, 500) : 'AI output failed validation',
  ai_next_action: ok ? (ai.next_action || '') : 'Review this lead by hand',
  processed_at: new Date().toISOString()
}};

The fallback chain on raw covers the different places n8n versions put the model's reply. If your output sits somewhere else, point raw at it.

Check: a normal run gives numeric ai_score and a valid ai_tier. Temporarily replace the first line with let raw = 'not json'; and you should see ai_tier = needs_review.

Step 9: Write the row to Google Sheets

Add a final Google Sheets node named Write lead:

  • Operation: Append or Update Row
  • Document and Sheet: same as Step 5
  • Column to match on: fub_id
  • Mapping Column Mode: Map Automatically (field names already equal the header names)

Matching on fub_id is your second line of defence against duplicates. Even if two webhook deliveries race past the lookup in Step 5, the second write updates the same row instead of adding another.

Check: a new row appears in Leads with every column filled except those the lead genuinely lacks.

Step 10: Register the Follow Up Boss webhook and go live

Save the workflow and toggle it to Active. Only the Production URL works while the editor isn't listening.

Now tell Follow Up Boss where to send events. Run this once from a terminal, with the account owner's API key:

curl -u "YOUR_FUB_API_KEY:" \
  -X POST "https://api.followupboss.com/v1/webhooks" \
  -H "Content-Type: application/json" \
  -H "X-System: YourRegisteredSystemName" \
  -H "X-System-Key: YOUR_SYSTEM_KEY" \
  -d '{"event":"peopleCreated","url":"https://YOUR-N8N-DOMAIN/webhook/fub-new-lead-7f3k2"}'

The response echoes back the webhook with an id and a status of Active. Save that id; you need it to delete or replace the webhook later with DELETE /v1/webhooks/{id}. To list what's registered, call GET /v1/webhooks with the same key and X-System header.

Optional hardening: every delivery carries a FUB-Signature header you can verify with your system key. The Webhooks page of the Follow Up Boss API reference explains the hashing; in n8n, the Crypto node can compute it, and you'll want the Webhook node's Raw Body option on so the bytes match exactly.

Check: create a real test person in Follow Up Boss. Within moments, a new execution appears under the workflow's Executions tab and a new row lands in the sheet.

Prompts and templates

Copy these as they are, then tune the scoring criteria to how your team actually prioritises.

System prompt (OpenAI node, System message):

You are a lead qualification assistant for a residential real estate team.
You receive one new lead record from a CRM. Judge how ready this person is to buy or sell, using ONLY the fields provided.

Rules:
- Never invent facts about the lead. If a field is empty, treat it as unknown.
- Do not judge the lead on name, ethnicity, gender, age, religion, family status, disability or national origin. Ignore those signals completely.
- Base the score on: stated price, lead source, lead type (Buyer or Seller), whether contact details look valid, and any intent or timeline words in the background notes.
- If there is too little information to judge, return tier "unknown" and a score of 0.
- Keep "reason" under 40 words and refer only to fields you were given.

Return ONLY a JSON object with exactly these keys:
score (integer 0 to 100), tier ("hot" | "warm" | "cold" | "unknown"), intent ("buy" | "sell" | "rent" | "unclear"), timeline ("now" | "soon" | "later" | "unclear"), reason (string), next_action (string, one short instruction for the agent).

User prompt template (OpenAI node, User message). Each {{ }} is an n8n expression; swap $json for $('Normalize lead').item.json as described in Step 7:

New lead from Follow Up Boss:
- Lead type: {{ $json.lead_type }}
- Source: {{ $json.source }}
- Source URL: {{ $json.source_url }}
- Stage: {{ $json.stage }}
- Price: {{ $json.price }}
- Tags: {{ $json.tags }}
- Email valid: {{ $json.email_valid }} ({{ $json.email_type }})
- Phone digits present: {{ $json.phone_digits ? 'yes' : 'no' }}
- Background notes: {{ $json.background }}

Score this lead and return the JSON object described in your instructions.

Expected output schema (this is an example of shape, not a real lead):

{
  "score": 72,
  "tier": "warm",
  "intent": "buy",
  "timeline": "soon",
  "reason": "Buyer lead from a property inquiry with a price set and valid email; notes mention wanting to tour this month.",
  "next_action": "Call today and offer two showing times."
}

The fairness line in the system prompt isn't decoration. Real estate is a regulated field, and the safest design is one where the model never sees protected traits in the first place. That's also why names stay out of the request.

Test it before you trust it

Run every row below before you point real lead flow at the workflow. Use the test URL with the editor listening, so you can inspect each node.

Test inputExpected output
Webhook with one new buyer ID; person has email, phone, price and a note about touring soonOne new row; email_valid yes; lead_type Buyer; ai_tier hot or warm; ai_reason mentions the note
New person tagged SellerOne row with lead_type Seller and ai_intent sell or unclear
Same webhook body sent twiceSecond run exits on the false branch of Is new lead?; still one row; only one OpenAI call in the executions log
Webhook with three IDs in resourceIdsThree rows, one per person, each with its own fub_id
Empty input: resourceIds is []Split resource IDs outputs zero items; no rows, no errors
Wrong event: event is peopleUpdatedZero items after Split resource IDs
Person with no email and no phoneRow written; email_valid no; phone_digits empty; ai_tier unknown or cold
Malformed data: email jane@@example, phone (555) abc-12email_valid no; phone_digits holds only the digits; run succeeds
Person ID that doesn't existGet person fails after retries with a 404; execution marked failed; no row written
Very large input: background note pasted many thousands of characters longbackground cut to 2000 characters before the prompt; row written; no oversized request
AI output forced to invalid JSON (edit Step 8 as described)ai_tier needs_review; ai_next_action "Review this lead by hand"

After the table passes, delete your test rows and test people. Leftover fakes skew whatever reporting you build on the sheet later.

Where it breaks and how to fix it

Most failures fall into five buckets. Here's how each one shows up.

Auth expiry or revoked keys

Symptom: Get person returns 401, or the Google Sheets nodes say the credential is invalid. Fix: generate a fresh Follow Up Boss key and update the FUB API credential; for Google, open the credential in n8n and reconnect the OAuth sign-in. If the person who created the key leaves, the key may stop working, so tie it to a shared admin login where your policies allow.

Rate limits

Symptom: HTTP 429 errors during bulk imports. Follow Up Boss measures rate limits over a sliding 10-second window and answers with HTTP 429 plus a Retry-After header when you go over. Its documented default global limit is 250 requests per 10-second window. That same page lists a default limit of 20 per window for GET /v1/events, which matters if you later add an events-polling fallback. Fix: lower the batch size in Step 3, raise Wait Between Tries above the Retry-After value you see, and check your consumption with the GET /v1/rateLimit/usage endpoint for rolling 24-hour totals.

Google Sheets has its own ceiling: 300 read requests per minute per project. Writes are capped separately at 300 write requests per minute per project. Going over can return 429: Too many requests, so keep batching on if you ever replay a backlog. Google's quotas refill every minute, and the docs say there is no daily request limit if you respect the per-minute quotas.

For OpenAI, check the OpenAI rate limits guide for your account's limits; it notes that official SDKs automatically retry eligible 429 and 503 responses. n8n's OpenAI node may not behave like an official SDK, so keep Retry On Fail switched on for Score lead too.

Schema drift

Symptom: rows suddenly show blank columns, or Normalize lead throws "cannot read properties of undefined". Someone renamed a sheet header, or a field changed shape. Fix: keep the header row locked (Data, Protect sheets and ranges in Google Sheets), and add new fields to the end of both the header and the fields parameter. Custom fields need to be named in fields explicitly; they aren't returned by default.

LLM output errors

Symptom: many rows with needs_review. Fix: open one failed execution and read the raw model reply. Usually it's wrapped in extra text or a key is misspelled; confirm JSON output is on, tighten the system prompt, and point raw in Step 8 at the right property. Filter the sheet by needs_review once a day so nothing falls through.

Duplicate runs

Symptom: the same fub_id appears twice, or the execution log shows repeated deliveries with the same eventId. Follow Up Boss retries any delivery that doesn't get a 2XX response. Fix: make sure the Webhook node responds immediately, not after the last node; keep the lookup in Step 5 and the fub_id match in Step 9; and don't register a second webhook for the same event and URL.

Running costs and limits

This workflow has four cost drivers. None of them are fixed numbers, so price them against your own lead volume.

Also see the OpenAI API pricing page before switching to a larger model.

Variations and extensions

  • Route hot leads instantly. After Parse AI output, add an IF node on ai_tier equals hot and send a Slack or SMS alert to the assigned agent from assigned_to.
  • Write the score back to Follow Up Boss. Create a custom field such as AI Tier, then add an HTTP Request node with PUT /v1/people/{id} to fill it, so agents see the tier inside the CRM. (Watch for loops if you also listen to peopleUpdated.)
  • Swap the destination. Replace the Google Sheets nodes with Airtable or a Postgres table; the normalized fields stay the same.
  • Track stage changes too, with a second webhook on peopleStageUpdated that updates the stage column.
  • Use Make or Zapier instead. The same chain works there: custom webhook, HTTP module for Follow Up Boss, a code or formatter step, OpenAI, then Sheets with a lookup-before-write step.

Hand this to ChatGPT or Claude

Paste the brief below (or this page's link) into an AI assistant and ask it to adapt the build to your stack, such as a different sheet layout, CRM fields or automation tool.

GOAL
When a new person is created in Follow Up Boss, fetch their full record, clean the contact data, score them with an OpenAI model, and write one row per lead to a Google Sheet without duplicates.

TRIGGER
Follow Up Boss webhook for the event peopleCreated, registered with POST https://api.followupboss.com/v1/webhooks using the account owner's API key plus X-System and X-System-Key headers. Target: an n8n Webhook node (POST, path fub-new-lead-7f3k2, respond immediately with 200).

STEPS
1. Webhook node: receive JSON with eventId, event, resourceIds, uri.
2. Code node "Split resource IDs": one item per ID in resourceIds, only when event = peopleCreated.
3. HTTP Request node "Get person": GET https://api.followupboss.com/v1/people/{personId}?fields=id,created,firstName,lastName,emails,phones,source,sourceUrl,stage,price,tags,assignedTo,background. Basic Auth (username = API key, password empty). Headers X-System, X-System-Key. Batching 5 items per 2000 ms. Retry on fail: 3 tries, 5000 ms wait.
4. Code node "Normalize lead": primary email lowercased, email_valid, email_domain, email_type (personal/business), phone_digits, tags joined, lead_type = Seller if tag "Seller" else Buyer.
5. Google Sheets "Get Row(s)": sheet Leads, filter fub_id = current fub_id. Always Output Data on.
6. IF node "Is new lead?": true when the lookup returned no fub_id.
7. OpenAI node "Message a model": system and user prompts below, JSON output on, low temperature.
8. Code node "Parse AI output": parse JSON, validate tier and score, fall back to tier needs_review.
9. Google Sheets "Append or Update Row": match on fub_id, map all columns.

DATA FIELDS
fub_id, created_at, first_name, last_name, email, email_valid, email_domain, email_type, phone, phone_digits, source, source_url, stage, price, tags, lead_type, assigned_to, background, event_id, ai_score, ai_tier, ai_intent, ai_timeline, ai_reason, ai_next_action, processed_at

PROMPTS
System: qualification assistant, use only given fields, ignore protected characteristics, return JSON with score, tier, intent, timeline, reason, next_action.
User: lead_type, source, source_url, stage, price, tags, email_valid, email_type, phone present, background.

ACCEPTANCE TESTS
- One new FUB lead creates exactly one row with all columns filled.
- Replaying the same webhook body creates no second row.
- A lead with no email gets email_valid = no and still gets a row.
- Invalid AI output produces ai_tier = needs_review, not a failed run.
- A webhook with several resourceIds produces one row per person.

CONSTRAINTS
- Respect Follow Up Boss rate limits (HTTP 429 with Retry-After) and Google Sheets per-minute quotas.
- Never put API keys in the webhook URL.
- Do not send the lead's name, email or phone to the model.
- Keep the n8n workflow active so the production webhook URL responds.

Frequently Asked Questions

Does n8n have a built-in Follow Up Boss node?

This build doesn't depend on one. It uses n8n's generic Webhook and HTTP Request nodes, which talk to the Follow Up Boss REST API directly, so you control every field and header. If a dedicated node exists in your n8n version, you can swap it in for Step 3.

Can I poll for new leads instead of using a webhook?

Yes. Use a Schedule Trigger and call GET /v1/people sorted by creation date, then rely on the fub_id lookup to skip leads you've already written. Webhooks react faster and use fewer API calls, but polling avoids needing owner access to register a webhook.

Why isn't my webhook firing?

Check four things: the workflow is Active, you registered the Production URL rather than the Test URL, the URL is HTTPS, and the registration call included the X-System header. Then call GET /v1/webhooks to confirm it's listed with an Active status.

Is it safe to send lead data to OpenAI?

The prompt here leaves out name, email and phone, which reduces what leaves your systems. Read OpenAI's data usage terms and your brokerage's privacy policy before going live, and tell your team what the model sees.

How do I backfill leads that already exist?

Build a separate manual-trigger workflow that pages through GET /v1/people using limit and offset, then feeds IDs into the same nodes from Step 3 on. Keep batching on so you stay inside both APIs' rate limits.

Can the AI score replace my agents' judgment?

No. Treat it as a triage hint that decides who gets looked at first. Agents still talk to the lead, and the ai_reason column lets them see why the model chose a tier and disagree with it.

Your first step

Today, create the Leads sheet with the header row above and generate your Follow Up Boss API key. Then build Steps 1 to 3 and fire the test curl at your Webhook node. Once you see a real person record come back, the rest is wiring.

Sources

Written by

Syswithai