Connect CallHub to Claude: Manage Teams, Agents, and Script Templates

If your team uses ChatGPT, check out our guide on /connect-callhub-to-chatgpt-manage-contacts-and-campaign-workflows/ or explore our broader architectural overview on /connect-callhub-to-ai-agents-automate-phonebooks-and-rent-numbers/.

If you need to connect CallHub to Claude to automate agent provisioning, manage script templates, enforce Do-Not-Call (DNC) compliance, or monitor credit usage across campaigns, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's natural language tool calls and CallHub's underlying REST APIs. You can either construct and maintain this integration middleware yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

Giving a Large Language Model (LLM) read and write access to a telephony and campaign platform like CallHub presents immediate engineering challenges. You have to handle API token lifecycles, map CallHub's specific JSON schemas to MCP tool definitions, and handle strict campaign state machines. Every time an endpoint changes, you own the redeployment.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for CallHub, connect it natively to Claude Desktop, and execute complex telephony ops workflows using natural language.

The Engineering Reality of the CallHub API

A custom MCP server is essentially a self-hosted integration layer. While the open MCP standard provides a predictable JSON-RPC interface for models to discover tools, implementing it against B2B APIs is difficult. CallHub's API reflects its domain complexity: managing voice broadcasts, peer-to-peer texting, and distributed contact centers.

If you decide to build a custom CallHub MCP server, here are the specific integration challenges you will face:

Campaign State Machine Constraints CallHub enforces strict state machine rules on campaign objects. For example, when updating a P2P campaign, the status accepts integer flags (1 = START, 2 = PAUSE, 4 = END). More importantly, you cannot update a campaign's name while it is in the START state unless your PATCH request simultaneously transitions it out of that state. An LLM operating on raw endpoints will frequently fail these state transitions. A managed MCP server provides explicit schema definitions that guide the LLM to format valid state changes.

Date Formatting and UTC Enforcements When querying credit usage, CallHub requires date formats in exactly mm/dd/yyyy. If an LLM attempts to pass a standard ISO-8601 timestamp, the request will fail. Furthermore, usage queries without an end date default to a single day, rigidly bound to UTC 00:00 - 23:59. Your MCP server must either handle date coercion or provide highly specific system prompts in the tool schema to prevent the LLM from hallucinating standard date formats.

Handling API Rate Limits CallHub enforces rate limits across its endpoints. It is critical to understand that Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream CallHub API returns an HTTP 429 (Too Many Requests), Truto passes that error directly to the caller. Truto normalizes upstream rate limit info into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The caller (your MCP client or agent framework) is entirely responsible for evaluating these headers and implementing its own retry or backoff logic. Do not expect the integration layer to absorb 429s for you.

Generating the CallHub MCP Server

Instead of building JSON-RPC handlers and OAuth token refreshes from scratch, you can use Truto to generate a CallHub MCP server dynamically. Truto translates CallHub's API endpoints into MCP-compliant tools, handling authentication and schema mapping automatically.

You can create this server via the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

1. Navigate to the integrated account page for your CallHub connection in the Truto dashboard.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., filter by specific methods or tags to restrict access).
5. Copy the generated MCP server URL. You will use this to connect Claude.

Method 2: Via the Truto API

For teams automating infrastructure, you can generate the MCP server programmatically. Truto will validate the requested tool configuration, generate a secure token, and return a ready-to-use URL.

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

curl -X POST https://api.truto.one/integrated-account/<callhub_account_id>/mcp \
  -H "Authorization: Bearer <YOUR_TRUTO_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "CallHub Ops Agent",
    "config": {
      "methods": ["read", "write"]
    }
  }'

Response:

{
  "id": "mcp_srv_778899",
  "name": "CallHub Ops Agent",
  "config": { "methods": ["read", "write"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/c9d8e7f6g5h4..."
}

Keep this URL secure. It contains a cryptographic token that authenticates requests directly against the CallHub account.

Connecting the MCP Server to Claude

Once you have your Truto MCP server URL, connecting it to Claude takes seconds. You can do this through the Claude application UI or by modifying Claude's desktop configuration file.

Method 1: Via the Claude UI

1. Open Claude.
2. Navigate to Settings -> Integrations -> Add MCP Server.
3. Paste your Truto MCP URL into the connection field.
4. Click Add. Claude will instantly execute an initialization handshake and pull down the available CallHub tools.

Method 2: Via the Manual Configuration File

For advanced users, you can configure Claude Desktop to run a Server-Sent Events (SSE) transport using the official Model Context Protocol CLI.

Locate your claude_desktop_config.json file:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Add the following configuration, replacing the URL with your generated Truto MCP URL:

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

Restart Claude Desktop. The CallHub tools are now available for natural language invocation.

Hero Tools for CallHub Workflows

Truto exposes CallHub's API capabilities as specific, strongly-typed tools. Instead of exposing raw CRUD endpoints, the MCP server derives these tools dynamically from API schemas, injecting necessary context (like required parameters and pagination instructions) so the LLM knows exactly how to use them.

Here are the highest-leverage tools available for CallHub automation.

Check Credit Usage

list_all_call_hub_credits_usage

This tool retrieves CallHub credits usage details for a specified date range. It returns a usage report including total usage records (SMS amount, voice amount, voice calls, credits remaining) and per-campaign-type breakdowns.

Context note: The start_date is strictly required and must be in mm/dd/yyyy format. If end_date is omitted, the usage covers a single day (UTC 00:00-23:59).

"Get the total credit usage and remaining balance for our CallHub account for 10/25/2026."

Manage Do-Not-Call (DNC) Lists

create_a_call_hub_dnc_contact

Creates a new DNC contact, adding a phone number to the Do-Not-Call list. This is critical for maintaining compliance during active campaigns.

Context note: Requires the dnc (phone number) parameter. You can optionally pass a category: 1 for opted out of calling only, 2 for opted out of texting only, or 3 for both. Defaults to 3.

"Add +15550198372 to the global CallHub DNC list for both voice and texting."

Bulk Add Contacts to Phonebooks

call_hub_phonebook_contacts_bulk_add

Adds existing CallHub contacts to a phonebook in bulk. This is much faster than assigning contacts individually when provisioning lists for new campaigns.

Context note: Requires phonebook_id and an array of contact_ids. Returns the updated phonebook object including contact counts.

"Take contacts 99381, 99382, and 99383 and add them in bulk to phonebook ID 1045."

Update P2P Campaign State

update_a_call_hub_p_2_p_campaign_by_id

Updates a CallHub P2P campaign's status or renames it.

Context note: Uses PATCH semantics. You must provide the campaign id. Status codes are 1 (START), 2 (PAUSE), and 4 (END). You cannot change the name while the campaign is running (status 1) unless the same request transitions it out of the START state.

"Pause the P2P campaign with ID 88472 by setting its status to 2."

Create Script Templates

create_a_call_hub_template

Creates a CallHub script template with a label and a list of survey or text questions, standardizing the messaging for agents.

Context note: Requires a label and an array of questions. Each question object requires a type (12 for text/survey, 1 for standard) and the question text.

"Create a new script template labeled 'Q3 Follow-Up'. Add a text question asking 'Are you still interested in renewing your contract this quarter?'"

Assign Agents to Teams

call_hub_team_agents_bulk_update

Assigns existing agents to a CallHub team. This is the primary way to route campaign access to specific groups of workers.

Context note: Requires the team_id and an array of agent_ids.

"Assign agent IDs 402, 405, and 410 to the 'Outbound Sales' team (ID 22)."

These hero tools cover the most critical campaign operations. For the complete inventory of available CallHub tools, including detailed schemas for bulk imports, tagging, and rented numbers, visit the CallHub integration page.

Workflows in Action

When Claude is connected to CallHub via MCP, it can execute multi-step logic by chaining these tools together. Here are two real-world examples of how domain-specific personas use this integration.

Scenario 1: The Campaign Ops Manager (Provisioning)

Before a new voter outreach campaign begins, the operations manager needs to set up the script, assign the right agents, and start the campaign.

"Create a new script template labeled 'Voter Outreach 2026' with a single text question: 'Can we count on your support next Tuesday?'. Next, assign agents 551 and 552 to team ID 80. Finally, start the P2P campaign ID 9921 by setting its status to 1."

How the agent executes this:

1. Calls create_a_call_hub_template with the requested label and question array.
2. Calls call_hub_team_agents_bulk_update passing team_id: 80 and agent_ids: [551, 552].
3. Calls update_a_call_hub_p_2_p_campaign_by_id passing id: 9921 and status: 1.

What the user gets back: Claude confirms the template was created (providing the new template ID), confirms the agents were added to the team, and verifies that the campaign has been transitioned to the active START state.

sequenceDiagram
  participant User as User
  participant Claude as "Claude Desktop"
  participant MCP as "Truto MCP Server"
  participant CallHub as "CallHub API"

  User->>Claude: "Create template, assign agents, start campaign..."
  Claude->>MCP: call_hub_template (create)
  MCP->>CallHub: POST /v1/templates/
  CallHub-->>MCP: Template ID 443
  MCP-->>Claude: Success

  Claude->>MCP: call_hub_team_agents_bulk (update)
  MCP->>CallHub: POST /v1/teams/80/agents/
  CallHub-->>MCP: 204 No Content
  MCP-->>Claude: Success

  Claude->>MCP: update_call_hub_p_2_p_campaign (PATCH)
  MCP->>CallHub: PATCH /v1/p2p_campaigns/9921/
  CallHub-->>MCP: 200 OK (Status 1)
  MCP-->>Claude: Success
  Claude-->>User: "All tasks completed successfully. Campaign is live."

Scenario 2: The Compliance & Budget Officer

Mid-campaign, an admin needs to check spend velocity and immediately scrub a complaining contact from future outreach.

"Check our credits usage for 10/25/2026. Then, add +15551234567 to our DNC list for both voice and texting."

How the agent executes this:

1. Calls list_all_call_hub_credits_usage passing start_date: "10/25/2026".
2. Calls create_a_call_hub_dnc_contact passing dnc: "+15551234567" and category: 3.

What the user gets back: Claude parses the usage response and returns a summary of the SMS and voice spend for that specific day. It then confirms that the phone number has been successfully appended to the DNC list with category 3 restrictions.

Security and Access Control

Exposing an integrated telephony platform to an autonomous LLM requires strict access governance. Truto provides several mechanisms to lock down your CallHub MCP servers:

• Method Filtering: You can restrict a server to read-only operations by setting methods: ["read"]. This allows the LLM to query credit usage and view teams, but prevents it from creating campaigns, modifying DNC lists, or spending credits.
• Tag Filtering: Limit the available tools to specific functional areas (e.g., tags: ["compliance"] to only expose DNC tools) by utilizing the underlying integration's tag groups.
• Require API Token Auth: By setting require_api_token_auth: true, possession of the MCP URL is no longer sufficient. The connecting client must also supply a valid Truto API token in the Authorization header, preventing lateral movement if the URL leaks.
• Time-to-Live (TTL): Set an expires_at timestamp when generating the server. Backed by distributed key-value storage and automated cleanup mechanisms, Truto enforces TTL natively, automatically deleting the server and credentials when the time expires - perfect for temporary contractor access.

Build Faster with Managed MCP

Connecting Claude to CallHub opens up massive operational efficiencies for teams managing outbound campaigns, distributed agents, and compliance lists. But building the underlying infrastructure to handle JSON-RPC translation, strictly enforced state machines, and API authentication is a distraction from your core product.

Truto's managed MCP servers solve this. By dynamically deriving tools from CallHub's API documentation and handling the connection layer, you can give your AI agents secure, scoped access to CallHub in minutes, not months.