Follow Up Boss AI Calling: Aircall vs JustCall vs Twilio

An AI calling stack for Follow Up Boss works by catching new-lead and call webhooks, handing the call to a dialer engine you control, then writing back dispositions and appointments to FUB using its REST API and webhooks. In production we pick Aircall, JustCall, or Twilio based on booking reliability, compliance posture, and how cleanly the sync behaves.

Definition: an AI dialer for Follow Up Boss is an orchestration where FUB webhooks and API connect to a phone vendor and an AI voice agent to call leads, qualify, and book, with bookings and dispositions written back to FUB in near real time.

This guide is for real estate teams on Follow Up Boss evaluating Aircall vs JustCall vs Twilio. We cover how the integration actually works, what tripped us up, and how we prevented false bookings while staying TCPA safe.

The problem it solves

AI calling only creates value if booked appointments show up in Follow Up Boss with the right owner, source, and audit trail. Manual click-to-call from the browser is slow, inconsistent across agents, and does not scale to work stale lists. A reliable stack needs three things: correct FUB triggers, a dialer that will not get you blocked, and deterministic writebacks that agents trust.

How the automation works

We keep Follow Up Boss as the source of truth and treat the dialer as a replaceable phone engine. The architecture standardizes on FUB webhooks and REST API so Aircall, JustCall, or a Twilio-based dialer can be swapped without touching CRM logic.

• FUB webhooks: We subscribe to events like people created, calls created or updated, texts, emails, tasks, and appointments. Webhooks are first-class in FUB and post to our endpoint when activity happens (https://docs.followupboss.com/reference/webhooks-post, https://docs.followupboss.com/reference/webhooks-guide).
• Events vs People for new leads: When we add a lead programmatically, we use the Events API instead of People so FUB automations fire and we avoid duplicates. This is explicitly recommended in FUB's lead-provider guide (https://docs.followupboss.com/docs/lead-provider-integration-guide).
• Dialer abstraction: The AI agent and call control talk to whichever dialer you prefer. We standardize on call-start and call-end webhooks from the dialer vendor, then map outcomes to FUB writebacks. This avoids relying on dialer-specific CRM plugins we cannot validate.
• Appointment creation: When the agent books a meeting, we create an Appointment via FUB's API and include the FUB user as an invitee. Calendars must be properly connected in FUB for invites to land on Google or Outlook (https://docs.followupboss.com/reference/appointments-post).
• Call logs and gaps: Some call data is only visible in-app. We capture vendor call IDs and recordings on our side and attach links in FUB activity so agents can review, bridging fields the API does not expose directly (https://docs.followupboss.com/reference/calls-get).

Step-by-step: how to build it

1) Register Follow Up Boss webhooks

Answer-first: post a handler URL in FUB so new leads and call events hit your orchestrator.

curl -u "$FUB_API_KEY:" \
  -H 'Content-Type: application/json' \
  -H 'X-System: ai-dialer-orchestrator' \
  -X POST https://api.followupboss.com/v1/webhooks \
  -d '{
    "target": "https://orchestrator.example.com/webhooks/fub",
    "events": ["peopleCreated", "callsCreated", "callsUpdated", "appointmentsCreated"]
  }'

Gotcha: Inbox App webhooks behave differently and are not managed via /v1/webhooks. Use the standard webhooks for dialer orchestration (https://docs.followupboss.com/docs/inbox-apps-webhooks).

2) Create leads via the Events API, not People

Answer-first: using Events triggers automations and reduces dupes.

// Node 18+ runtime
import fetch from 'node-fetch';
 
const FUB_KEY = process.env.FUB_KEY; // user API key
const auth = 'Basic ' + Buffer.from(`${FUB_KEY}:`).toString('base64');
 
export async function createLeadFromCall(lead) {
  const res = await fetch('https://api.followupboss.com/v1/events', {
    method: 'POST',
    headers: {
      'Authorization': auth,
      'Content-Type': 'application/json',
      'X-System': 'ai-dialer-orchestrator'
    },
    body: JSON.stringify({
      type: 'new_inquiry',
      source: 'AI Dialer',
      person: {
        firstName: lead.firstName,
        lastName: lead.lastName,
        emails: [{ value: lead.email }],
        phones: [{ value: lead.phone }],
        stage: 'WATCH' // example targeting, adjust to your process
      }
    })
  });
  if (!res.ok) throw new Error(`FUB Events failed: ${res.status}`);
  return res.json();
}

Gotcha: FUB notes that creating people directly will not trigger automations and can create duplicates. Use Events for inbound programmatic creation (https://docs.followupboss.com/docs/lead-provider-integration-guide).

3) Normalize dialer webhooks into dispositions

Answer-first: accept any vendor's call-end webhook and map it to a small, deterministic set of dispositions you write back to FUB.

// Express-style handler for a generic dialer callback
app.post('/webhooks/dialer/call-completed', async (req, res) => {
  const e = req.body; // {callId, phone, outcome, recordingUrl}
  const disp = normalizeOutcome(e.outcome); // "booked", "live", "vm", "no_answer", "bad_number"
 
  // Write a timeline note with recording link so agents can review
  await fetch('https://api.followupboss.com/v1/notes', {
    method: 'POST',
    headers: { 'Authorization': auth, 'Content-Type': 'application/json', 'X-System': 'ai-dialer-orchestrator' },
    body: JSON.stringify({
      person: { phone: e.phone },
      body: `AI dialer call ${disp}. VendorCallID: ${e.callId}${e.recordingUrl ? `\nRecording: ${e.recordingUrl}` : ''}`
    })
  });
 
  res.sendStatus(204);
});

Gotcha: some call data fields are not exposed via the API. Keep the vendor call ID and recording URL on your side and include links in FUB notes so nothing is lost to a black box (https://docs.followupboss.com/reference/calls-get).

4) Book the appointment and ensure calendars sync

Answer-first: create the Appointment in FUB and include the FUB user as an invitee so Google or Outlook picks it up.

export async function createAppointment({ personId, userId, startsAtISO, title }) {
  const payload = {
    title,
    startsAt: startsAtISO,
    endsAt: new Date(new Date(startsAtISO).getTime() + 30*60000).toISOString(),
    personId,
    attendees: [{ userId }]
  };
  const res = await fetch('https://api.followupboss.com/v1/appointments', {
    method: 'POST',
    headers: { 'Authorization': auth, 'Content-Type': 'application/json', 'X-System': 'ai-dialer-orchestrator' },
    body: JSON.stringify(payload)
  });
  if (!res.ok) throw new Error(`FUB appointment failed: ${res.status}`);
  return res.json();
}

Gotcha: for Google or Outlook to receive the invite, the FUB user's calendar must be properly connected in FUB, and the user must be an attendee on the appointment (https://docs.followupboss.com/reference/appointments-post).

5) Add a two-layer booking guard

Answer-first: gate bookings with an AI classifier and a deterministic phrase filter to eliminate false positives.

function passesBookingGuard(transcript) {
  const mustInclude = [/let.s? book/i, /tuesday|wednesday|thursday|am|pm/i, /email|calendar|invite/i];
  const mustNotInclude = [/not interested/i, /send me info only/i, /busy right now/i];
  const passAll = mustInclude.every(rx => rx.test(transcript));
  const passNone = mustNotInclude.every(rx => !rx.test(transcript));
  return passAll && passNone; // call your LLM classifier first, then enforce this check
}

Gotcha: in a real estate deployment we saw 32 of 44 booking-class calls register as false before we shipped server-side guards and tightened the classifier. After the fix, no new false bookings were observed.

6) Wire FUB webhooks into your orchestrator

Answer-first: your FUB webhook handler should treat events as idempotent and trigger the right call flow only once per lead.

app.post('/webhooks/fub', async (req, res) => {
  const { event, data } = req.body; // per FUB webhook payloads
  if (event === 'peopleCreated') {
    // schedule a call attempt in your dialer engine here
  }
  if (event === 'callsUpdated') {
    // update local state or retry logic
  }
  res.sendStatus(204);
});

Gotcha: CSV export exists for contacts if you need a one-time backfill, but ongoing syncs should use webhooks and the REST API to avoid drift (https://help.followupboss.com/hc/en-us/articles/360015269133-Export-Contacts-to-a-Spreadsheet).

Where it gets complicated

• Use Events API to create leads: Creating People directly will not trigger automations and can create duplicates. Events is the correct entry point for programmatic lead creation in FUB (https://docs.followupboss.com/docs/lead-provider-integration-guide).
• Call data blind spots: Some call fields are visible only in-app. Keep your own call ledger keyed by vendor call ID and include links in FUB notes so agents have full context (https://docs.followupboss.com/reference/calls-get).
• Inbox App webhooks are different: Do not assume the /v1/webhooks panel controls all webhook types. Inbox App webhooks behave differently and are documented separately (https://docs.followupboss.com/docs/inbox-apps-webhooks).
• Calendar sync requires the right attendee: FUB only pushes invites to connected calendars when the FUB user is an invitee on the appointment you create through the API (https://docs.followupboss.com/reference/appointments-post).
• Compliance lives in the script and the scheduler: Disclosures, opt-out capture, and do-not-call checks must be first-class. The TCPA sets statutory damages up to $500 per call, up to $1,500 if willful, which is reason enough to automate guardrails (FCC, 47 U.S.C. § 227: https://www.fcc.gov/stop-unwanted-calls).
• Vendor neutrality: Aircall and JustCall market native CRM plugins, and Twilio gives you deep control. We standardize on webhook-in and API-out so you can switch vendors without ripping up the FUB side. When a dialer lacks the event you need, bridge it in your orchestrator rather than depending on hidden syncs.

What this actually changes

For a real estate brokerage on Follow Up Boss, this stack turned outbound into a safe, repeatable engine. In one production deployment we processed 3,130 of 3,130 callable leads, logged 5,573 total calls, and after shipping the booking guard we saw no new false bookings. The same build paused automatically when a voice vendor crossed its usage quota to prevent surprise billing, then resumed on reset.

Speed-to-lead matters: companies that contacted a lead within an hour were 7 times more likely to qualify the lead than those who waited longer, and 60 times more likely than companies that waited 24 hours or more (Harvard Business Review: https://hbr.org/2011/03/the-short-life-of-online-sales-leads). AI calling moves you closer to that window without adding headcount.

Frequently asked questions

Does Follow Up Boss have an API we can use for AI calling?

Yes. Follow Up Boss exposes a REST API at https://api.followupboss.com/v1 with HTTP Basic auth using a user API key or OAuth 2.0. We use webhooks for inbound events and the API for writebacks like events and appointments (https://docs.followupboss.com/reference/getting-started, https://docs.followupboss.com/docs/getting-started-with-oauth).

Which plan do I need for the FUB API and webhooks?

Follow Up Boss documents an Open API with HTTP Basic and OAuth options. Plan gating varies and is documented by FUB. We scope access during kickoff and adjust the design if any endpoints are restricted for your account (https://help.followupboss.com/hc/en-us/articles/7787906777751-Follow-Up-Boss-Open-API).

How do you prevent duplicates when creating leads?

Create leads via the Events API rather than People. FUB's lead-provider guide calls this out and we have seen it in practice. Events trigger automations and reduce duplicates, where direct People inserts can create dupes and skip automations (https://docs.followupboss.com/docs/lead-provider-integration-guide).

Can this run in real time?

Yes. FUB webhooks deliver events for contacts, calls, texts, tasks, and appointments. We respond to webhooks, call via your chosen dialer, then write back via the API. Appointments include the FUB user so connected calendars receive invites (https://docs.followupboss.com/reference/webhooks-post, https://docs.followupboss.com/reference/appointments-post).

What does this cost monthly?

You pay for your dialer and AI usage plus a small amount of hosting. Follow Up Boss API usage does not add separate metered costs in our builds. The bigger lever is compliance: automating disclosures and opt-outs reduces TCPA exposure, which can be expensive per violation (FCC TCPA overview: https://www.fcc.gov/stop-unwanted-calls).

Can a non-developer owner set this up?

The dialer vendor accounts are straightforward. The orchestration requires engineering: registering webhooks, handling events idempotently, and writing back through the API. We designed it so the dialer is swappable and the FUB side remains clean.

If you want this wired into your Follow Up Boss account with a dialer you already use, we have shipped this exact pattern and run it in production. See our AI voice agents service for implementation details, read our related post on dialing the WATCH stage in Follow Up Boss, and book a short call to scope your stack.

• Services: /services#ai-voice-agents
• Related: /blog/automate-follow-up-boss-ai-calling
• Book: /book