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.
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
| Item | Detail |
|---|---|
| Problem it solves | New 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 replaces | Checking 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. |
| Trigger | A Follow Up Boss peopleCreated webhook posting to an n8n Webhook node. |
| Output | One row per lead in a Google Sheet tab called Leads, with cleaned contact fields plus AI score, tier, intent, timeline, reason and next action. |
| Tools | n8n (cloud or self-hosted), Follow Up Boss API, Google Sheets, OpenAI API. |
| Skill level needed | Comfortable with n8n nodes and pasting short JavaScript snippets. You don't need to write code from scratch. |
| Complexity | Medium. 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) andX-System-Key(a secret it issues you). Register through the Identification section of the Follow Up Boss API reference. The webhook endpoints refuse requests withoutX-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.
- Trigger: Webhook node. Follow Up Boss posts JSON containing
eventId,eventCreated,event,resourceIds(an array of person IDs) anduri. n8n answers 200 straight away. - Split resource IDs (Code). Drops anything that isn't
peopleCreated, then emits one item per ID withpersonIdandeventId. Decision point: zero IDs means the workflow simply stops. - Get person (HTTP Request). Calls
GET /v1/people/{personId}with afieldslist and returnsid,created,firstName,lastName,emails,phones,source,sourceUrl,stage,price,tags,assignedTo,background. - Normalize lead (Code). Produces flat fields:
fub_id,email,email_valid,email_domain,email_type,phone_digits,lead_typeand the rest of the sheet columns. - Find existing row (Google Sheets, Get Row(s)). Looks up
fub_idin theLeadstab. - 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.
- Score lead (OpenAI). Sends only non-identifying fields and gets back JSON with
score,tier,intent,timeline,reason,next_action. - Parse AI output (Code). Validates the JSON. Branch inside the code: bad or missing output sets
ai_tiertoneeds_reviewinstead of failing. - Output: Write lead (Google Sheets, Append or Update Row). Matches on
fub_idand 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, valueid,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 Interval2000ms. 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.2for 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 input | Expected output |
|---|---|
| Webhook with one new buyer ID; person has email, phone, price and a note about touring soon | One new row; email_valid yes; lead_type Buyer; ai_tier hot or warm; ai_reason mentions the note |
New person tagged Seller | One row with lead_type Seller and ai_intent sell or unclear |
| Same webhook body sent twice | Second 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 resourceIds | Three 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 peopleUpdated | Zero items after Split resource IDs |
| Person with no email and no phone | Row written; email_valid no; phone_digits empty; ai_tier unknown or cold |
Malformed data: email jane@@example, phone (555) abc-12 | email_valid no; phone_digits holds only the digits; run succeeds |
| Person ID that doesn't exist | Get person fails after retries with a 404; execution marked failed; no row written |
| Very large input: background note pasted many thousands of characters long | background 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.
- n8n executions. Each webhook delivery is one execution. n8n Cloud plans meter executions; self-hosting swaps that for server costs. Check n8n's own pricing page for the current plans.
- OpenAI tokens. OpenAI's pricing page lists separate input, output and cached-input prices for each model. Your cost per lead depends on the model you pick and the prompt length, which is why the prompt is kept short and duplicates never reach the model.
- Follow Up Boss API calls. One GET per lead, plus retries. Check your configured limits with the GET /v1/rateLimit/limits endpoint, which returns configured limits. Your API access depends on your Follow Up Boss subscription, so confirm it with your account admin.
- Google Sheets API requests. Two per lead (one read, one write). Google recommends keeping a single Sheets API request payload to 2 MB at most. Each lead row is tiny, so this only matters if you rewrite the workflow to bulk-load history.
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_tierequalshotand send a Slack or SMS alert to the assigned agent fromassigned_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 topeopleUpdated.) - 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
peopleStageUpdatedthat updates thestagecolumn. - 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.