---
title: "Connect Follow Up Boss to ChatGPT: Sync Leads, Tasks & Pipelines"
slug: connect-follow-up-boss-to-chatgpt-sync-leads-tasks-pipelines
date: 2026-09-28
author: Nidhi KN
categories: ["AI & Agents"]
excerpt: "Learn how to connect Follow Up Boss to ChatGPT via Truto's MCP Server. We cover auto-generating tools, engineering realities, and real-world AI workflows."
tldr: "Connect Follow Up Boss to ChatGPT using Truto's MCP Server to let AI agents read and write CRM data. Step-by-step guide on setup, hero tools, and security."
canonical: https://truto.one/blog/connect-follow-up-boss-to-chatgpt-sync-leads-tasks-pipelines/
---

# Connect Follow Up Boss to ChatGPT: Sync Leads, Tasks & Pipelines


If you need to connect Follow Up Boss to ChatGPT so your AI agents can sync leads, update pipelines, assign tasks, and log calls, you need a [Model Context Protocol (MCP) server](https://truto.one/blog/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This server acts as the translation layer between ChatGPT's tool calls and the Follow Up Boss REST API. You can either [build, host, and maintain this infrastructure yourself](https://truto.one/blog/build-vs-buy-the-hidden-costs-of-custom-mcp-servers/), or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

If your team uses Claude, check out our guide on [connecting Follow Up Boss to Claude](https://truto.one/connect-follow-up-boss-to-claude-manage-deals-sms-appointments/) or explore our broader architectural overview on [connecting Follow Up Boss to AI Agents](https://truto.one/connect-follow-up-boss-to-ai-agents-automate-events-lead-flows/).

Giving a Large Language Model (LLM) read and write access to a real estate CRM like Follow Up Boss is a significant engineering challenge. You must handle strict rate limits, manage complex relational data payloads, and map dynamic custom fields to MCP tool definitions. Every time a team updates a stage or a custom field, your custom server code has to handle the drift. 

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Follow Up Boss, [connect it natively to ChatGPT](https://truto.one/blog/bring-100-custom-connectors-to-chatgpt-with-superai-by-truto/), and execute complex workflows using natural language.

::cta{buttonText="Talk to us" buttonUrl="/book-a-demo/"}
Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
:::

## The Engineering Reality of the Follow Up Boss API

A custom MCP server is essentially a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, implementing it against the Follow Up Boss API comes with [distinct architectural pain points](https://truto.one/blog/build-vs-buy-the-hidden-costs-of-custom-mcp-servers/). 

If you decide to build a custom MCP server for Follow Up Boss, you own the entire API lifecycle. Here are the specific integration challenges you will face:

### Custom Fields and Schema Resolution
Follow Up Boss allows users to define custom fields for People and Deals. The API does not expose these in a static swagger file. To write data back to a custom field, your MCP server must first fetch the custom fields (`list_all_follow_up_boss_custom_fields`), store their mappings, and ensure the LLM injects the correct payload structures (relying on dynamic `name` properties instead of labels). Building static MCP schemas for a dynamic CRM means writing a schema parser that reads the user's configuration and dynamically generates the JSON-RPC tool definitions. If you skip this, your LLM will hallucinate payload keys and fail the requests.

### Strict Rate Limiting (No Absorbing 429s)
Follow Up Boss enforces strict 24-hour rolling rate limits and burst limits. When an LLM executes a loop - for example, querying 50 separate leads and updating them one by one - it is incredibly easy to blow past these thresholds. 

**A critical factual note on how Truto handles this:** Truto does *not* automatically retry, throttle, or apply backoff on rate limit errors. When the Follow Up Boss API returns an HTTP 429 (Too Many Requests), Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. The caller (your LLM client or agent framework) is entirely responsible for detecting the 429 error and orchestrating the retry or exponential backoff logic.

```mermaid
sequenceDiagram
    participant ChatGPT as ChatGPT
    participant Truto as Truto MCP Router
    participant FUB as FUB API

    ChatGPT->>Truto: Call: update_a_follow_up_boss_person_by_id
    Truto->>FUB: POST /v1/people/123
    FUB-->>Truto: HTTP 429 Too Many Requests
    Truto-->>ChatGPT: HTTP 429 (Standardized Ratelimit Headers)
    Note over ChatGPT: Client must wait<br>and retry request
```

### First-to-Claim Lead Routing Constraints
Automating lead claiming via `follow_up_boss_people_claim` requires managing tight collision windows. In Follow Up Boss, unclaimed leads are assigned to a fallback agent after a short time (default 15 minutes). If multiple agents - or an automated AI workflow - attempt to claim a lead simultaneously, the API will return conflict errors. Your MCP tools must be designed to gracefully handle these state changes, knowing that a lead available 30 seconds ago might no longer be claimable.

## Generating a Follow Up Boss MCP Server

Instead of building the routing, token hashing, and schema generation from scratch, you can use Truto to spin up an MCP server for Follow Up Boss in seconds. Truto scopes each MCP server to a single integrated account, generating a secure token URL that handles all downstream authentication.

You can create this server in two ways: via the Truto UI, or programmatically via the API.

### Method 1: Via the Truto UI
If you are setting this up for internal use or testing, the UI is the fastest path.

1. Log into your Truto dashboard and navigate to the **Integrated Accounts** page.
2. Click on your connected Follow Up Boss account.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (name, allowed methods, tags, and expiration).
6. Click Save and **copy the generated MCP server URL**. Treat this URL like a secret - it contains the cryptographic hash required to route and authenticate requests.

### Method 2: Via the Truto API
If you are provisioning MCP servers dynamically for your own customers, you will use the REST API. Truto validates that the integration has tools available, generates a secure token, stores it in a distributed key-value store at the edge, and returns a ready-to-use URL.

```bash
curl -X POST https://api.truto.one/integrated-account/<INTEGRATED_ACCOUNT_ID>/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "ChatGPT FUB Server",
    "config": {
      "methods": ["read", "write"],
      "tags": ["people", "tasks", "deals"]
    },
    "require_api_token_auth": false
  }'
```

The response will contain the `url` field (e.g., `https://api.truto.one/mcp/<token>`).

## Connecting the MCP Server to ChatGPT

Once you have the Truto MCP server URL, you must register it with ChatGPT so the LLM knows what tools are available and where to send the JSON-RPC payloads.

### Method A: Via the ChatGPT UI (Custom Connectors)
If you are using ChatGPT directly (Pro, Plus, Business, Enterprise, or Education accounts), you can add the server through the interface.

1. In ChatGPT, go to **Settings -> Apps -> Advanced settings**.
2. Enable **Developer mode** (MCP support requires this flag).
3. Under MCP servers / Custom connectors, click to add a new server.
4. **Name:** Enter a descriptive name (e.g., "Follow Up Boss via Truto").
5. **Server URL:** Paste the Truto MCP URL generated in the previous step.
6. Click **Save**. 

ChatGPT will immediately ping the server, perform the initialization handshake, and list the available Follow Up Boss tools.

### Method B: Via Manual Config File (Remote Transport)
If you are running a local MCP inspector or an agent framework that relies on a configuration file, you can wire it up using the official remote Server-Sent Events (SSE) transport. 

Add this to your `mcp.json` or equivalent configuration file:

```json
{
  "mcpServers": {
    "follow_up_boss": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/<token>"
      ]
    }
  }
}
```

## Hero Tools for Follow Up Boss

Truto automatically derives tool definitions from the integration's resource endpoints. Instead of raw REST paths, ChatGPT sees descriptive, snake_case function names with rigid JSON schemas indicating required and optional parameters.

Here are 6 high-leverage hero tools your AI agents can use to manipulate Follow Up Boss data.

### `get_single_follow_up_boss_person_by_id`
Retrieves a complete CRM record for a lead or contact. It returns the full person object including their first and last name, pipeline stage, source, assigned agent, tags, and arrays containing emails, phones, and physical addresses.

*Usage note:* This is almost always step two in a workflow, occurring right after a search identifies the correct ID.

> "Fetch the full Follow Up Boss contact profile for person ID 50211 so I can review their pipeline stage and assigned agent."

### `update_a_follow_up_boss_person_by_id`
Updates an existing contact record. You can modify their stage, arrays of emails and phones, and tags. 

*Usage note:* By default, sending a tags array will overwrite existing tags. You must instruct the LLM to pass `mergeTags=true` in the query parameters if you want to append a new tag without wiping out the historical ones.

> "Update person ID 50211 to move their stage to 'Hot Prospect' and append the tag 'spring-campaign'. Make sure to set mergeTags to true."

### `create_a_follow_up_boss_note`
Creates a note attached to a specific person. This is critical for logging AI interactions, summaries of phone calls, or chat bot transcripts back into the CRM.

*Usage note:* Requires the `personId`. You can pass `isHtml=true` if you want to retain specific formatting.

> "Log a note on person ID 8832. Set the subject to 'AI Qualification Call' and put the meeting summary in the body."

### `list_all_follow_up_boss_tasks`
Searches and lists open tasks in Follow Up Boss. It supports complex filtering by `personId`, `assignedTo`, `assignedUserId`, `type`, and due date ranges.

*Usage note:* Useful for having an agent perform a daily audit of overdue tasks for a specific sales rep.

> "List all uncompleted Follow Up Boss tasks assigned to user ID 14 to see what follow-ups they missed today."

### `create_a_follow_up_boss_task`
Creates a new task for a contact. You must provide the `personId` and the assignee (either `assignedTo` or `assignedUserId`).

*Usage note:* Often used at the end of an automated workflow to hand off a qualified lead to a human agent.

> "Create a task on person ID 50211 called 'Call to schedule property tour'. Make it due tomorrow and assign it to user ID 14."

### `follow_up_boss_people_search`
Checks whether a person already exists in Follow Up Boss using an email address or phone number. 

*Usage note:* Supply the `email` or `phone` inside the request body. It returns a boolean `found`, along with the `matchedBy` logic and the `assignedTo` user. This prevents you from creating duplicate leads.

> "Search Follow Up Boss to see if there is already an existing contact with the email 'johndoe@example.com'."

For the complete inventory of Follow Up Boss tools, including webhooks, appointments, custom fields, and email templates, visit the [Follow Up Boss integration page](https://truto.one/integrations/detail/followupboss).

## Workflows in Action

Providing an LLM with these tools allows you to chain multi-step logic that previously required hardcoded scripts or rigid Zapier workflows. Here is how ChatGPT handles real-world Follow Up Boss scenarios.

### Workflow 1: Lead Triage and Handoff
Instead of manually checking a shared inbox and copying data to the CRM, an AI agent can ingest an inbound request and orchestrate the entire triage process.

> "Check if johndoe@example.com exists in Follow Up Boss. If he does, grab his full record, add a note saying 'Expressed interest via chatbot', and create a task for his assigned agent to call him tomorrow."

**How the agent executes this:**
1. **`follow_up_boss_people_search`**: The agent searches for `johndoe@example.com`. The API returns `found: true` and the `id` of the matching person.
2. **`get_single_follow_up_boss_person_by_id`**: The agent retrieves the full record to find out who the `assignedUserId` is.
3. **`create_a_follow_up_boss_note`**: The agent posts the context of the chat interaction to the contact's timeline using the `personId`.
4. **`create_a_follow_up_boss_task`**: Finally, the agent creates the follow-up task, linking both the `personId` and the `assignedUserId` so it appears on the correct rep's daily dashboard.

```mermaid
flowchart TD
    A["User Prompt:<br>Check if lead exists, add note, and assign task."] --> B["follow_up_boss_people_search<br>(Find by email)"]
    B --> C["get_single_follow_up_boss_person_by_id<br>(Get assigned user)"]
    C --> D["create_a_follow_up_boss_note<br>(Log the context)"]
    D --> E["create_a_follow_up_boss_task<br>(Assign human follow-up)"]
```

### Workflow 2: Pipeline Review and Deal Advancement
Sales managers often need a quick pulse on deals and the ability to advance them based on new information.

> "Find the deal for '123 Main St', move it to the 'Under Contract' stage, and fetch the related contact's phone number so I can text them a congratulations message."

**How the agent executes this:**
1. **`list_all_follow_up_boss_deals`**: The agent searches the deals pipeline using the name filter for '123 Main St'. It extracts the `id` of the deal and the `stageId` for 'Under Contract' (if known, or it might list stages first).
2. **`update_a_follow_up_boss_deal_by_id`**: The agent patches the deal record with the new `stageId`.
3. **`get_single_follow_up_boss_person_by_id`**: The agent looks at the `peopleIds` array returned from the deal, picks the primary contact, and fetches their profile to extract the phone number.

## Security and Access Control

Exposing an entire CRM database to an AI model requires strict governance. Truto MCP servers enforce boundaries at the infrastructure level, so you do not have to rely on prompt engineering to restrict access.

When configuring a Truto MCP server via the API or UI, you can enforce the following rules:

*   **Method Filtering (`config.methods`)**: Restrict the server to specific HTTP verbs. Pass `["read"]` to allow `get` and `list` operations while blocking all `create`, `update`, and `delete` tools. This ensures a read-only agent cannot accidentally wipe out a pipeline.
*   **Tag Filtering (`config.tags`)**: Scope the available tools to specific integration resources. For example, passing `["deals", "tasks"]` ensures the LLM cannot access webhooks, system users, or email templates.
*   **Secondary Authentication (`require_api_token_auth`)**: By default, possessing the MCP URL grants access. Setting this flag to `true` forces the client to also pass a valid Truto API token in the `Authorization` header, adding a second layer of security for high-risk environments.
*   **Time-to-Live (`expires_at`)**: Pass an ISO datetime to create a short-lived MCP server. Truto's cleanup alarms will automatically tear down the server and purge its tokens from the edge runtime exactly when it expires - perfect for temporary contractor access or ephemeral CI/CD test runs.

## Unblock Your AI Roadmap

Connecting Follow Up Boss to ChatGPT requires more than just knowing the API endpoints. You have to handle rate limits, schema resolution for custom fields, token hashing, and dynamic payload mappings. 

Truto abstracts this away entirely. We handle the auth lifecycle, protocol routing, and [dynamic tool generation](https://truto.one/blog/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) so your engineering team can focus on building intelligent workflows instead of parsing JSON schemas. 

Generate an MCP server in seconds, hand the URL to ChatGPT, and let the model do the rest.