Connect Wealthbox to Claude: Sync Events, Notes, and Projects

If you need to connect Wealthbox to Claude to automate CRM data entry, sync calendar events, or orchestrate client onboarding projects, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's LLM tool calls and Wealthbox's REST API. You can either build and maintain this infrastructure yourself, 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 connecting Wealthbox to ChatGPT or explore our broader architectural overview on connecting Wealthbox to AI Agents.

Giving a Large Language Model (LLM) read and write access to a financial CRM like Wealthbox is an engineering challenge. You have to handle strict OAuth 2.0 token lifecycles, map massive JSON schemas to MCP tool definitions, and deal with Wealthbox's specific relational data models. Every time the vendor updates an endpoint or deprecates a field, 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 Wealthbox, connect it natively to Claude, and execute complex workflows using natural language.

The Engineering Reality of the Wealthbox 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 vendor APIs is painful. If you decide to build a custom MCP server for Wealthbox, you own the entire API lifecycle. Here are the specific challenges you will face with the Wealthbox architecture:

Polymorphic Entity Links Wealthbox uses a highly relational data model where supplementary records (like Notes, Tasks, and Events) do not just attach to a simple contact_id. They rely on a linked_to array concept. A single task might be linked to a Contact, an Opportunity, and a Project simultaneously. When mapping this to an MCP tool, you have to ensure Claude understands exactly how to format these polymorphic reference arrays. If an LLM hallucinates an entity type or ID format, the request fails. Truto handles this by surfacing the exact OpenAPI schema requirements for the linked_to object directly in the MCP tool definition, providing Claude with strict formatting boundaries.

Strict Workspace and Team Isolation Data in Wealthbox is strictly partitioned by workspaces and user groups. Many endpoints require precise assigned_to or user ID parameters to function correctly. If Claude attempts to assign a task without specifying the correct user ID derived from the current workspace context, the operation drops into a void or returns a 400 Bad Request. Exposing the list_all_wealthbox_users endpoint alongside operational endpoints is mandatory to give the model the context it needs to route data correctly.

Rate Limits and 429 Passthrough Wealthbox enforces API rate limits. If your AI agent gets stuck in a loop or tries to paginate through thousands of contact records too quickly, the API will return an HTTP 429 Too Many Requests response. It is critical to understand that Truto does not retry, throttle, or apply backoff on rate limit errors. When Wealthbox returns a 429, Truto passes that error directly to the caller. However, Truto does normalize the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF spec. The client (your agent framework or wrapper) is strictly responsible for inspecting these headers and implementing exponential backoff.

Instead of writing boilerplate JSON-RPC handlers and OAuth refresh loops from scratch, you can use Truto. Truto normalizes authentication and pagination, exposing Wealthbox's endpoints as ready-to-use MCP tools.

How to Generate a Wealthbox MCP Server with Truto

Truto dynamically derives MCP tools directly from the integration's internal resource definitions and documentation records. A tool only appears in the server if it has an underlying schema, acting as a quality gate for LLM consumption.

Every MCP server is scoped to a single integrated account (a specific tenant's Wealthbox connection) and is backed by Cloudflare KV and a D1 database record. You can generate this server in two ways.

Method 1: Via the Truto UI

For testing, prototyping, or internal tooling, you can generate the server directly from the dashboard.

1. Navigate to the Integrated Accounts page in your Truto dashboard and select the connected Wealthbox account.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., naming the server, restricting methods to read operations, or setting an expiration date).
5. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the API

For production use cases where you need to programmatically provision AI agents for your end-users, you generate the server via the REST API. The API validates the configuration, generates a secure token using an HMAC signing key, stores the configuration in the database, and returns the endpoint URL.

Request:

POST https://api.truto.one/integrated-account/<integrated_account_id>/mcp
Authorization: Bearer <YOUR_TRUTO_API_KEY>
Content-Type: application/json
 
{
  "name": "Wealthbox Sync Agent",
  "config": {
    "methods": ["read", "write"],
    "require_api_token_auth": false
  }
}

Response:

{
  "id": "mcp_9x8y7z6w",
  "name": "Wealthbox Sync Agent",
  "config": {
    "methods": ["read", "write"],
    "require_api_token_auth": false
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}

This URL is fully self-contained. The cryptographic token in the path resolves the authentication context, meaning you hand this URL straight to Claude and it immediately gains access to the specified Wealthbox instance.

Connecting the MCP Server to Claude

Once you have the Truto MCP URL, you need to register it with Claude. You can do this via the application interface or by manually editing the configuration file.

Method A: Via the Claude UI

If you are using the Claude desktop or web application (on a supported pro/enterprise plan that allows custom connectors):

1. Open Claude and navigate to Settings.
2. Click on Integrations (or Connectors) -> Add MCP Server.
3. Give the server a descriptive name like Wealthbox CRM.
4. Paste the Truto MCP URL into the endpoint field.
5. Click Add.

Claude will immediately hit the initialize endpoint, complete the JSON-RPC handshake, and index the available tools via the tools/list endpoint.

Method B: Via Manual Config File

If you are running custom agents, using the Claude Desktop local application, or orchestrating via a CLI, you will modify the claude_desktop_config.json file. Because Truto provides an HTTP endpoint, you use the standard SSE (Server-Sent Events) transport adapter provided by the MCP reference implementation.

Modify your claude_desktop_config.json file (typically located at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS or %APPDATA%\Claude\claude_desktop_config.json on Windows):

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

Restart Claude Desktop. The agent will read the config, spin up the SSE client, and establish a connection to Truto's proxy router.

Hero Tools for Wealthbox

Truto automatically translates the integration's OpenAPI schema into snake_case MCP tools. Because Truto utilizes a flat input namespace, query parameters (like limit or status) and body parameters (like first_name) are processed by Claude as a single JSON object. Truto's internal router handles splitting the arguments into the correct API payload based on the schema definitions.

Here are the highest-leverage tools available for Wealthbox workflows.

list_all_wealthbox_contacts

Retrieves a paginated list of contacts in the CRM. Supports deep filtering by name, email, phone, tags, active status, and modification timestamps. Crucial for agentic entity resolution.

"Search Wealthbox for any active contacts with the email domain '@acmecorp.com' and return their full names and internal IDs."

update_a_wealthbox_contact_by_id

Modifies an existing contact. Because Wealthbox expects structured payloads, the agent can pass partial objects. Useful for data enrichment pipelines.

"Update the contact with ID 189234. Add the job title 'VP of Engineering' and append the tag 'Enterprise Lead'."

create_a_wealthbox_note

Creates a text note and associates it with specific entities. This is the primary mechanism for logging interaction history, meeting summaries, and unstructured context.

"Create a note on contact ID 189234 summarizing our Q3 sync. Link the note to the opportunity ID 55432 so it appears on both timelines."

list_all_wealthbox_tasks

Fetches operational tasks. Can be filtered by assignee, due date, or completion status. This allows the AI agent to audit its own assigned work or monitor team capacity.

"List all incomplete tasks assigned to team ID 9982 due within the next 7 days, and summarize the top priorities."

create_a_wealthbox_task

Generates actionable items. Requires specifying a name and an assignee (user or team). The agent can derive assignee IDs by chaining a call to list_all_wealthbox_users beforehand.

"Create a task called 'Follow up on MSA redlines' due next Friday. Assign it to the user with the email 'sarah@ourfirm.com' and link it to the 'Acme Migration' project."

list_all_wealthbox_opportunities

Retrieves deal pipeline data. This allows Claude to aggregate pipeline values, check stage progression, and identify stalled deals without manual reporting.

"Pull all opportunities in the 'Negotiation' stage created this quarter. Calculate the total expected pipeline value and identify any deals that haven't had a note added in 14 days."

create_a_wealthbox_project

Spins up a new project record, typically used for tracking long-term engagements like client onboarding or portfolio reviews.

"Create a new project titled 'Q4 Tax Optimization - Smith Family'. Set the status to Active and link it to the Smith Household ID."

For the complete tool inventory and granular schema details, refer to the Wealthbox integration page.

Workflows in Action

Giving Claude raw tool access is just the baseline. The real value is chaining these tools together to execute multi-step operations that usually require human intervention.

Scenario 1: Post-Meeting Debrief and Task Orchestration

A financial advisor finishes a client review. Instead of spending 20 minutes doing CRM data entry, they drop the raw transcript into Claude and ask it to process the outcome.

"Read this transcript from my meeting with John Doe. Find his contact record in Wealthbox. Create a detailed note summarizing our discussion about trust planning. Then, create two tasks: one for me to email the estate attorney next Tuesday, and one for the compliance team to review the updated risk profile. Link everything to John's contact record."

Execution Steps:

1. Claude calls list_all_wealthbox_contacts with name="John Doe" to retrieve the contact ID (e.g., id: 88712).
2. Claude calls list_all_wealthbox_users to map "me" and "compliance team" to internal Wealthbox IDs.
3. Claude calls create_a_wealthbox_note using the contact ID, passing the parsed summary as the text payload.
4. Claude calls create_a_wealthbox_task twice, setting specific due dates, assignees, and linking both tasks to contact ID 88712.

sequenceDiagram
    participant User as "Advisor (User)"
    participant Claude as "Claude AI"
    participant Truto as "Truto MCP"
    participant API as "Wealthbox API"
    
    User->>Claude: "Process John Doe transcript..."
    Claude->>Truto: call tool [list_all_wealthbox_contacts]<br>query: {name: "John Doe"}
    Truto->>API: GET /v1/contacts?name=John%20Doe
    API-->>Truto: { id: 88712 }
    Truto-->>Claude: Result: Contact ID 88712
    Claude->>Truto: call tool [create_a_wealthbox_note]<br>body: {text: "Summary...", linked_to: [{id: 88712, type: "Contact"}]}
    Truto->>API: POST /v1/notes
    API-->>Truto: 201 Created
    Truto-->>Claude: Result: Note Created
    Claude->>Truto: call tool [create_a_wealthbox_task]<br>body: {name: "Email attorney", assigned_to: ...}
    Truto->>API: POST /v1/tasks
    API-->>Truto: 201 Created
    Truto-->>Claude: Result: Task Created
    Claude-->>User: "CRM updated. Note and tasks assigned."

Scenario 2: Automated Pipeline Injection

A sales representative receives a high-intent inbound email from a prospect. They want Claude to parse the email, verify if the prospect exists, and inject them into the active deal pipeline.

"Check if Jane Smith (jane@techcorp.com) exists in Wealthbox. If she doesn't, create her contact profile using her signature details. Once you have her profile, create a new Opportunity called 'TechCorp Implementation' with an estimated value of $50,000 in the 'Discovery' stage, linked to her contact."

Execution Steps:

1. Claude calls list_all_wealthbox_contacts searching for jane@techcorp.com.
2. If the result set is empty, Claude extracts her phone number, title, and company from the prompt and calls create_a_wealthbox_contact.
3. Wealthbox returns the new ID (e.g., id: 99451).
4. Claude immediately calls create_a_wealthbox_opportunity using the newly acquired ID, setting the stage, value, and name.

flowchart TD
    A["Receive Email Prompt"] --> B["Tool: list_all_wealthbox_contacts<br>(email='jane@techcorp.com')"]
    B --> C{Exists?}
    C -->|Yes| E["Extract existing ID"]
    C -->|No| D["Tool: create_a_wealthbox_contact<br>(first_name='Jane', last_name='Smith')"]
    D --> E
    E --> F["Tool: create_a_wealthbox_opportunity<br>(name='TechCorp Implementation', value=50000)"]
    F --> G["Workflow Complete"]

Security and Access Control

Connecting an LLM to a system of record demands strict governance. Truto implements several controls directly at the MCP token level:

• Method Filtering: Limit the server to specific operations. Setting config.methods: ["read"] ensures the server will only generate tools for get and list endpoints. Claude physically cannot mutate data because the write tools do not exist in the JSON-RPC schema.
• Tag Filtering: Group tools by functional area. You can restrict an agent to only see tools tagged with ["crm", "tasks"], preventing access to sensitive endpoints like billing or internal user administration.
• Require API Token Auth: By default, possession of the MCP URL is sufficient to execute tools. Setting require_api_token_auth: true forces a secondary middleware check, requiring the client to pass a standard Truto API token in the Authorization header. This ensures only authenticated internal services can execute operations.
• Expiration (expires_at): MCP servers can be given a strict Time-to-Live (TTL). Once the expires_at timestamp passes, Cloudflare KV automatically evicts the token and a Durable Object alarm purges the configuration from the database, instantly revoking access.

Rethink Custom Integrations

The AI integration layer is evolving faster than traditional API platforms can support. Attempting to build a custom MCP server for Wealthbox means dedicating a senior engineer to monitor API changelogs, update JSON schemas, and refactor pagination logic every time a boundary shifts.

Managed infrastructure solves this. By routing agent requests through Truto, you rely on documentation-driven tool generation. When Wealthbox updates a resource, the Truto schema updates, and your Claude agent instantly gains access to the new parameters without a single code deployment.

Focus on prompting your agents and designing complex workflows. Let the platform handle the integration state.