Connect Follow Up Boss to Claude: Manage Deals, SMS & Appointments

If you need to connect Follow Up Boss to Claude to automate real estate deal flows, track external SMS communications, or oversee agent appointment schedules, you need a Model Context Protocol (MCP) server. This server acts as the secure translation layer between Claude's function calls and the Follow Up Boss REST API. You can choose to build and maintain this infrastructure entirely in-house, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL. If your team uses ChatGPT, check out our guide on /connect-follow-up-boss-to-chatgpt-sync-leads-tasks-pipelines/ or explore our broader architectural overview on /connect-follow-up-boss-to-ai-agents-automate-events-lead-flows/.

Giving a Large Language Model (LLM) read and write access to a highly specialized CRM like Follow Up Boss is an engineering challenge. You have to handle API key lifecycles, map massive nested JSON schemas to MCP tool definitions, and deal with real-estate-specific domain logic like "First To Claim" lead routing queues. Every time the vendor updates an endpoint, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Follow Up Boss, connect it natively to Claude Desktop, and execute complex pipeline and team management workflows using natural language.

The Engineering Reality of the Follow Up Boss API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against specialized B2B APIs is painful. Follow Up Boss is built to manage fast-paced real estate lead routing, complex agent commission structures, and multi-channel communications. Its API reflects that exact complexity.

If you decide to build a custom Follow Up Boss MCP server from scratch, here are the specific integration challenges you will face:

First-To-Claim (FTC) Lead Routing Logic Follow Up Boss does not simply "assign" leads via standard CRUD operations in high-velocity environments. It uses a First To Claim system where leads are offered to a pool of agents. To interact with this queue via API, an agent must pull the unclaimed list, issue a specific claim request (which can fail with a conflict if another agent beat them to it), or explicitly ignore the lead. Building an LLM tool for this requires mapping these stateful workflow endpoints accurately, otherwise the model will attempt standard PATCH requests on the person object and fail to trigger the internal CRM routing rules.

Tag Overwrites and Array Merging When updating a Person record via the Follow Up Boss API, passing an array of tags or phone numbers is a destructive action by default - it overwrites the entire existing array. If an AI agent attempts to simply add a "Motivated Buyer" tag by passing ["Motivated Buyer"] in a standard update payload, it will delete all historical tags on that contact. To prevent data loss, the API requires the mergeTags=true query parameter. A managed MCP server abstracts this danger by pre-configuring the schema and tool definitions to handle these domain-specific safety checks.

External Attachment Requirements Unlike generic CRMs where you can POST binary file data to an attachment endpoint, Follow Up Boss's attachment endpoints (create_a_follow_up_boss_person_attachment) require an external uri. This means the API expects the file to be hosted elsewhere (like an S3 bucket or Google Drive) and it only stores the reference link and metadata. If your LLM tries to upload a base64 encoded document directly to the API, it will fail. You have to design your architecture to handle intermediary blob storage.

Strict API Quotas and 429 Handling Follow Up Boss enforces strict rate limits across a 24-hour rolling window, alongside burst limits. When these limits are hit, the API returns an HTTP 429 status code. It is critical to note that Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Follow Up Boss API returns a 429, Truto passes that error directly to the caller. However, Truto does normalize the upstream rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The caller (your LLM orchestration framework or MCP client) is entirely responsible for reading these headers and managing its own retry and backoff strategy.

Generating the Follow Up Boss MCP Server

Instead of writing and maintaining a Node.js or Python server to handle JSON-RPC handshakes and Follow Up Boss API schemas, you can use Truto to generate a managed MCP server dynamically.

Truto derives tool definitions directly from the integration's documented API schema. A tool only appears in the MCP server if it has a corresponding documentation entry, ensuring the LLM only interacts with validated, well-described endpoints.

You can generate the MCP server in two ways: via the Truto UI for immediate testing, or programmatically via the Truto API for automated deployments.

Method 1: Via the Truto UI

For administrators setting up Claude Desktop for internal operations teams, the UI is the fastest path.

1. Navigate to the Integrated Accounts page in your Truto dashboard and select your active Follow Up Boss connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Configure the server parameters. You can filter by methods (e.g., read, write) or tags (e.g., deals, leads) to restrict what Claude can do.
5. Click Generate and copy the resulting MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the Truto API

For engineering teams embedding AI agents into production environments, you can generate MCP servers programmatically. This is ideal for provisioning ephemeral AI access to specific CRM domains.

Make a POST request to /integrated-account/:id/mcp:

curl -X POST https://api.truto.one/integrated-account/YOUR_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "FUB Deals Assistant",
    "config": {
      "methods": ["read", "write"],
      "tags": ["deals", "people", "appointments"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The API securely hashes a connection token and returns your ready-to-use URL:

{
  "id": "mcp_8f7d6c5b",
  "name": "FUB Deals Assistant",
  "config": { "methods": ["read", "write"], "tags": ["deals", "people", "appointments"] },
  "expires_at": "2026-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Connecting the MCP Server to Claude

Once you have the Truto MCP URL, connecting it to Claude requires zero additional coding.

Option A: Via the Claude UI

If your organization uses Claude Desktop, Claude for Teams, or ChatGPT Plus/Enterprise, you can paste the URL directly into the application settings.

For Claude Desktop/Web:

1. Open Claude and navigate to Settings -> Integrations -> Add MCP Server.
2. Paste the Truto MCP URL into the Server URL field.
3. Click Add. Claude will immediately initialize the JSON-RPC connection and discover the Follow Up Boss tools.

(Note: If you are using ChatGPT, you can achieve the same by going to Settings -> Apps -> Advanced settings, enabling Developer Mode, and adding the URL under Custom Connectors).

Option B: Via Manual Config File (SSE Transport)

If you are running custom infrastructure or managing Claude Desktop configurations via MDM (Mobile Device Management) for your team, you can define the server in the claude_desktop_config.json file. Because Truto uses Server-Sent Events (SSE) over HTTP for MCP, you will use the official @modelcontextprotocol/server-sse wrapper.

Edit your config file (typically located at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS):

{
  "mcpServers": {
    "follow_up_boss_crm": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/a1b2c3d4e5f6..."
      ]
    }
  }
}

Restart Claude Desktop. The agent now has direct, authenticated access to your Follow Up Boss instance.

Hero Tools for Follow Up Boss

Truto automatically generates a comprehensive suite of tools based on the Follow Up Boss integration schema. By presenting these endpoints with strict JSON schemas, Claude knows exactly what parameters are required and how to format them.

Here are 7 high-leverage hero tools that transform Claude into a fully capable real estate assistant.

1. List Unclaimed First-To-Claim Leads

follow_up_boss_people_list_unclaimed

This tool queries the First-To-Claim (FTC) queue for leads that are currently available to be claimed by the agent. Since FTC leads re-route if unacknowledged (typically within 15 minutes), checking this endpoint frequently is critical for fast-paced teams.

"Claude, check if there are any unclaimed leads in the First-To-Claim queue right now. If there are, give me a quick summary of their source and name."

2. Claim a Lead

follow_up_boss_people_claim

Once an unclaimed lead is identified, this tool allows Claude to actively claim it on behalf of the user. It requires the personId and returns the full lead object, locking it to the assigned agent and preventing round-robin reassignment.

"Claim lead ID 98234 for me, and output their primary phone number and email so I can reach out immediately."

3. Manage the Deal Pipeline

list_all_follow_up_boss_deals

This tool retrieves deals currently in the pipeline. It allows filtering by pipeline ID, user, or stage. Because deals contain financial projections (price, projectedCloseDate), Claude can use this data to run pipeline health analyses or generate forecasting summaries.

"Pull all active deals in the 'Escrow' stage for my pipeline. Calculate the total projected revenue for these deals closing this month."

4. Create an Appointment

create_a_follow_up_boss_appointment

Scheduling property showings or client calls is a massive time sink. This tool allows Claude to generate calendar events directly inside Follow Up Boss. It requires title, start, and end times, and will map the event to specific invitees.

"Create an appointment titled 'Property Showing - 123 Main St' for tomorrow at 2:00 PM to 3:00 PM. Add contact ID 5542 as an invitee."

5. Log External SMS Communications

create_a_follow_up_boss_text_message

This is a highly specific compliance tool. It allows external systems to log SMS messages sent via third-party providers (like Twilio) directly onto the contact's timeline in Follow Up Boss. Note: This tool logs the message - it does not send it via the Follow Up Boss network.

"Log a sent text message for contact ID 8871 that says 'Just checking in on the document signatures.' Mark it as sent from 555-0199 to 555-0102 just now."

6. Update Contact Context (Merge Tags)

update_a_follow_up_boss_person_by_id

Updates a lead or contact record. Because Follow Up Boss treats array updates destructively by default, Truto's schema setup allows Claude to manage context safely by providing the required payload structures to merge tags instead of erasing historical data.

"Update John Doe's record (ID 1122). Add the tag 'Q3 Buyer' and ensure you use the mergeTags parameter so we don't lose his previous tag history."

7. Merge Email/SMS Templates

follow_up_boss_templates_merge

Follow Up Boss relies heavily on dynamic variables (%contact_first_name%). This tool allows Claude to pass a templateId and a contact ID, and Follow Up Boss will return the fully rendered text with all merge fields accurately substituted against the CRM data.

"Merge template ID 44 with contact ID 1052. Give me the final substituted text so I can review it before we manually send the campaign."

To view the complete inventory of available Follow Up Boss tools, including webhooks, automations, smart lists, and ponds, visit the Truto Follow Up Boss integration page.

Workflows in Action

Individual tools are useful, but MCP's real power emerges when Claude chains these tools together to execute complex, multi-step real estate operations autonomously.

Scenario 1: The First-To-Claim Rescue & Log

In high-velocity real estate teams, speed to lead is everything. An agent asks Claude to check for missed opportunities and initiate contact.

"Check if there are any unclaimed leads right now. If you find one, claim it for me immediately. Once claimed, log a text message to their record saying we've received their inquiry and an agent will call them within 10 minutes."

How Claude executes this:

1. Calls follow_up_boss_people_list_unclaimed to check the FTC queue.
2. Identifies a lead (e.g., ID 7731) and extracts the phone number.
3. Calls follow_up_boss_people_claim passing personId: 7731.
4. Calls create_a_follow_up_boss_text_message passing the recipient phone, the user's provisioned number, and the message payload to log the interaction on the timeline.

Scenario 2: Post-Showing Deal Progression

After a successful property tour, an agent wants to move the deal forward and document the next steps.

"I just finished showing 742 Evergreen Terrace to the Smith family (Contact ID 4410). Update their person record with the tag 'Hot Lead'. Then, find their active deal, move the stage to 'Offer Prep', and create a note on their profile summarizing that they loved the backyard and want to move fast."

sequenceDiagram
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Server
    participant FUB as Follow Up Boss API
    
    Claude->>MCP: Call update_a_follow_up_boss_person_by_id (mergeTags=true)
    MCP->>FUB: PUT /v1/people/4410
    FUB-->>MCP: [Updated Person JSON]
    MCP-->>Claude: Success
    
    Claude->>MCP: Call list_all_follow_up_boss_deals (filter by personId)
    MCP->>FUB: GET /v1/deals?personId=4410
    FUB-->>MCP: [Deal JSON Array]
    MCP-->>Claude: Return Deals
    
    Claude->>MCP: Call update_a_follow_up_boss_deal_by_id (stageId)
    MCP->>FUB: PUT /v1/deals/8912
    FUB-->>MCP: [Updated Deal JSON]
    MCP-->>Claude: Success
    
    Claude->>MCP: Call create_a_follow_up_boss_note
    MCP->>FUB: POST /v1/notes
    FUB-->>MCP: [Note JSON]
    MCP-->>Claude: Success

Scenario 3: End-of-Week Pipeline Audit

Brokerage managers need to ensure agents aren't letting leads go stale.

"Pull all active deals for my pipeline. Identify any deals that have a projected close date in the past but are still marked as open. For each one, create a task assigned to me to 'Review stalled deal' with a due date of tomorrow."

How Claude executes this:

1. Calls list_all_follow_up_boss_deals to fetch the pipeline data.
2. Uses its internal reasoning to compare projectedCloseDate values against the current date.
3. Iterates over the stalled deals, extracting the personId associated with each.
4. Calls create_a_follow_up_boss_task sequentially for each stalled deal, mapping the personId and dueDate appropriately.

Security and Access Control

Connecting an LLM to a production CRM containing sensitive real estate transactions and PII requires strict governance. Truto's MCP servers provide granular access controls at the infrastructure level:

• Method Filtering: Limit the MCP server to read-only access by passing "methods": ["read"] during creation. This ensures Claude can query pipeline metrics or contact details but cannot physically delete deals or modify tags.
• Tag Filtering: Restrict tool discovery to specific integration resources by passing "tags": ["deals", "tasks"]. The LLM won't even know that user management or webhook configuration endpoints exist.
• Require API Token Auth: By setting require_api_token_auth: true, possession of the MCP URL is no longer enough to execute commands. The client framework must also pass a valid Truto API token in the Authorization header, enforcing strict identity verification.
• Ephemeral Servers: Set an expires_at timestamp when generating the server. Once the time is reached, Truto's underlying KV storage automatically invalidates the token, instantly severing the LLM's access to Follow Up Boss - ideal for temporary contractor access or limited-time audit workflows.

Moving Past Manual Data Entry

Providing an AI agent with MCP access to Follow Up Boss fundamentally changes how real estate teams operate. Instead of forcing agents to tab between SMS platforms, calendar apps, and pipeline views to manually update CRM records, you allow them to interact with their business data contextually through natural language.

By leveraging Truto's managed MCP architecture, your engineering team bypasses the boilerplate of OAuth token management, dynamic tool generation, and complex JSON schema mapping. You get a production-ready, secure integration layer that scales with your team's LLM workloads without the maintenance overhead of managing custom integration code.