---
title: "Connect Acquire to Claude: Sync KB Articles, Support Cases, and Analytics"
slug: connect-acquire-to-claude-sync-kb-articles-support-cases-and-analytics
date: 2026-08-07
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to connect Acquire to Claude using a managed MCP server. Execute support workflows, sync knowledge base articles, and automate chat analytics directly from Claude."
tldr: "Connect Acquire to Claude using Truto's managed MCP server to automate support cases, update knowledge base articles, and pull chat analytics without writing integration code."
canonical: https://truto.one/blog/connect-acquire-to-claude-sync-kb-articles-support-cases-and-analytics/
---

# Connect Acquire to Claude: Sync KB Articles, Support Cases, and Analytics


If your team uses ChatGPT, check out our guide on [connecting Acquire to ChatGPT](https://truto.one/connect-acquire-to-chatgpt-manage-cases-contacts-and-support-bots/) or explore our broader architectural overview on [connecting Acquire to AI Agents](https://truto.one/connect-acquire-to-ai-agents-automate-support-sms-and-bot-workflows/).

Support teams run on context. A customer initiates a chat, and agents immediately need to cross-reference historical cases, check knowledge base (KB) articles, and analyze past interactions to deliver a cohesive response. AI agents are uniquely suited for this triage process, but giving a Large Language Model (LLM) like Claude secure, programmatic access to an omnichannel support platform like Acquire requires complex middleware.

You need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This infrastructure layer acts as a JSON-RPC 2.0 bridge, translating Claude's natural language tool calls into strict REST API requests. You can spend weeks building, hosting, and maintaining a custom MCP server, or you can use a [managed platform like Truto](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) to dynamically generate a secure, fully authenticated MCP server URL in seconds.

This guide details exactly how to use Truto to generate a managed MCP server for Acquire, connect it to Claude, and execute complex support and analytics workflows via natural language.

## The Engineering Reality of the Acquire API

Building a custom MCP server means taking full ownership of the API integration lifecycle. You are not just writing a few HTTP wrappers - you are mapping sprawling JSON schemas to LLM tool definitions, managing authentication states, and handling vendor-specific data structures.

The Acquire API presents several distinct engineering challenges that make building custom connectors painful:

**Hierarchical ID Dependencies**
Acquire's data model heavily nests resources. You cannot simply "send a message" by passing a string. Sending an SMS via `acquire_messages_create_sms` requires a `threadId`, a `timelineId`, and a `contactId`. Sending a standard chat via `create_a_acquire_message` requires a `caseId` and an active `contactId`. To equip an LLM to perform these actions, your MCP server must first guide the model to fetch cases, extract the requisite IDs, and structure the subsequent POST request flawlessly. Truto handles the schema derivation automatically, ensuring Claude receives the exact parameter requirements for every method.

**Beta Endpoints and Feature Flags**
Certain Acquire endpoints, like `acquire_contacts_search` and general custom cards, are actively in beta. Their schemas can drift, and documented features may fail unexpectedly. If you hardcode these definitions into a custom MCP server, your integration will break when the vendor updates the spec. Truto dynamically generates tools based on the live integration configuration and documentation records, meaning your MCP tools evolve alongside the API.

**Complex Relational Fetching**
Acquire relies on conditional query parameters (`relations`, `select`, `where`, `order`) to expand payloads. Endpoints like `list_all_acquire_departments` or `list_all_acquire_roles` require specific URL formatting to include nested user arrays. Translating these query parameters into a flat LLM-friendly schema is tedious. Truto normalizes these parameters into a structured query schema, allowing Claude to intelligently request relation expansions without hallucinating syntax.

## How to Generate an Acquire MCP Server

[Truto derives MCP tools dynamically](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/). When you connect an Acquire account, Truto parses the API documentation and resource configurations to generate a robust set of tools. You can spin up an MCP server via the Truto dashboard or programmatically via the API.

### Method 1: Via the Truto UI

For administrators who need to quickly provision an MCP server without writing code:

1. Navigate to the integrated account page for your active Acquire connection.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Configure the server name, allowed methods (e.g., limit to read-only access), and an optional expiration date.
5. Copy the generated MCP Server URL (e.g., `https://api.truto.one/mcp/abc123def456`).

### Method 2: Via the API

For engineering teams embedding AI capabilities into internal tools, you can dynamically provision servers on the fly. Send an authenticated POST request to the Truto API:

```bash
curl -X POST https://api.truto.one/integrated-account/<acquire_account_id>/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Claude Support Analytics Server",
    "config": {
      "methods": ["read", "list"],
      "tags": ["analytics", "kb"]
    }
  }'
```

The API provisions the underlying cryptographic tokens, stores them in edge KV storage, and returns a fully functional MCP server URL ready for immediate use.

## Connecting the MCP Server to Claude

Once you have your Truto MCP URL, connecting it to Claude requires zero additional code. 

### Method 1: Via the Claude UI (Desktop or Web)

If your organization uses Claude Enterprise or you are testing in the standard Claude interface:

1. Open Claude and navigate to **Settings -> Integrations** (or **Settings -> Connectors** depending on your plan tier).
2. Click **Add MCP Server** (or Add Custom Connector).
3. Paste the Truto MCP URL.
4. Click **Add**.

Claude immediately performs a JSON-RPC `initialize` handshake, discovers the available Acquire tools, and makes them accessible in your chat sessions.

### Method 2: Via Manual Config File (Claude Desktop)

If you prefer to define infrastructure as code, you can route the Truto MCP endpoint through a standard Server-Sent Events (SSE) client bridging process using the Claude Desktop configuration file.

Locate your `claude_desktop_config.json` file (typically in `~/Library/Application Support/Claude/` on macOS or `%APPDATA%\Claude\` on Windows) and add the following:

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

Restart Claude Desktop. The application will boot the bridge and expose your Acquire tools to the model.

## Security and Access Control

Giving an LLM direct access to an enterprise support platform carries inherent risk. You do not want a rogue agent deleting knowledge base categories or aggressively modifying user roles. Truto MCP servers include native governance controls:

*   **Method Filtering:** Restrict a server to safe operations. Setting `methods: ["read"]` ensures the LLM can only execute `get` and `list` operations, protecting your Acquire data from mutations.
*   **Tag Filtering:** Limit the server's scope to specific domains. Using `tags: ["analytics"]` ensures the model can view chat handle times and metrics without accessing PII in contact lists.
*   **Extra Authentication (`require_api_token_auth`):** By default, the cryptographically signed MCP URL acts as the authentication token. Enabling this flag forces the client to also pass a valid Truto API token in the Authorization header, preventing leaked URLs from being abused.
*   **Ephemeral Servers (`expires_at`):** Automate risk reduction by assigning a strict time-to-live to the server. Truto automatically destroys the token and edge KV entries when the expiration timestamp hits.

## Hero Tools for Acquire Automation

Truto provides comprehensive coverage of the Acquire API, but a few specific tools unlock the highest leverage workflows for AI agents. Here are the hero operations you will use most often.

### list_all_acquire_cases

This is the starting point for almost all support triage. It returns a paginated list of active, pending, or closed cases, alongside metadata like `channel`, `contactId`, and `status`. 

**Usage Note:** The LLM can use condition-based filtering and relation expansion to selectively fetch cases assigned to a specific queue or agent.

> "Fetch the 10 most recent active support cases in Acquire. Extract the case IDs, contact IDs, and current statuses, and list them in a markdown table."

### list_all_acquire_messages

To understand the context of a case, the LLM must read the historical conversation. This tool retrieves the message thread.

**Usage Note:** Acquire requires both `threadId` and `contactId` to list messages. The LLM must successfully extract these from a case or contact lookup before calling this tool.

> "Using the case ID and contact ID from the previous step, fetch the message thread. Summarize the customer's primary complaint and outline the troubleshooting steps the human agent has provided so far."

### create_a_acquire_message

This is the primary write operation for interacting with customers. It sends a chat message directly into an active conversation.

**Usage Note:** You must provide the `contactId`, `caseId`, and a structured message object. The LLM will construct the JSON payload based on Truto's dynamically generated schema.

> "Draft a polite response to the customer apologizing for the delay and confirming their refund has been processed. Send this message to the active case using the create_a_acquire_message tool."

### acquire_analytics_chat_chat_overview

Acquire's analytics suite is powerful, and this tool pulls period-over-period summary metrics and hourly time-series data for chat performance.

**Usage Note:** Excellent for generating automated end-of-week reporting or answering spontaneous operational questions from management.

> "Pull the chat overview analytics for the last 7 days. Compare our average response time to the previous period and tell me if our performance is degrading."

### list_all_acquire_kb_articles

Agents need access to internal documentation. This tool searches and retrieves Knowledge Base articles from Acquire.

**Usage Note:** The LLM can filter by `groupId` or `status`. It is incredibly effective for RAG-style workflows where the model needs to retrieve a policy before answering a customer query.

> "Search our Acquire knowledge base for articles related to 'API Rate Limits'. Read the content of the most relevant article and summarize the restrictions for enterprise customers."

### acquire_bot_qna_push_to_suggestions

Continuous improvement of Acquire's Conversational Bot requires new training data. This tool pushes a newly identified question into the draft suggestions queue.

**Usage Note:** If the LLM notices a recurring customer question that isn't handled by the bot, it can proactively stage the QnA pair for a human manager to approve.

> "I noticed three customers asked about our SOC 2 compliance report today. Push a new QnA pair to the Conversational Bot suggestions queue with the question 'Are you SOC 2 compliant?' and a draft answer linking to our trust center."

> Explore the complete inventory of Acquire tools, including Contacts, Companies, Analytics, and Bot QnA schemas, in our integration directory.
>
> [View All Acquire Tools](https://truto.one/integrations/detail/acquire)

## Workflows in Action

With Truto handling the complex schemas and authentication, Claude can sequence these tools together to execute advanced, multi-step operations.

### Workflow 1: Support Case Triage & Automated Drafting

A Customer Success Manager needs to review a stale support escalation, understand the context, and draft a response without leaving their workspace.

> "Find the active case for the contact ID 'cont_88992'. Read the entire message thread. Identify why the customer is frustrated, check our KB for the return policy on damaged goods, and draft a reply to the customer offering a replacement. Do not send the reply yet - output it here for my review."

**Execution Steps:**
1. Claude calls `list_all_acquire_cases` using the `contactId` filter to locate the active case and extract the `threadId`.
2. Claude calls `list_all_acquire_messages` passing the `threadId` and `contactId` to ingest the conversation history.
3. Claude calls `list_all_acquire_kb_articles` searching for "return policy damaged goods" to fetch the exact internal guidelines.
4. Claude synthesizes the data and outputs a perfectly formatted, policy-compliant response draft in the chat interface.

```mermaid
sequenceDiagram
    participant User
    participant Claude as Claude Desktop
    participant Truto as Truto MCP
    participant AcquireAPI as Acquire API

    User->>Claude: "Find case for cont_88992, read thread, check KB..."
    Claude->>Truto: Call list_all_acquire_cases
    Truto->>AcquireAPI: GET /cases?contactId=cont_88992
    AcquireAPI-->>Truto: Case JSON
    Truto-->>Claude: Mapped case payload (includes threadId)
    Claude->>Truto: Call list_all_acquire_messages
    Truto->>AcquireAPI: GET /messages?threadId=...&contactId=cont_88992
    AcquireAPI-->>Truto: Message array
    Truto-->>Claude: Mapped message data
    Claude->>Truto: Call list_all_acquire_kb_articles (search: returns)
    Truto->>AcquireAPI: GET /kb/articles?search=returns
    AcquireAPI-->>Truto: KB article data
    Truto-->>Claude: Mapped KB content
    Claude-->>User: Outputs policy-compliant draft reply
```

### Workflow 2: Automated Chat Analytics & Bot Optimization

A Support Operations lead wants to identify knowledge gaps based on the most common tags applied to chats over the weekend, and update the bot accordingly.

> "Pull the most common chat tags from our Acquire analytics for the past 48 hours. If 'billing_failure' is among the top 3 tags, check our KB to see if we have an article on updating credit cards. If we do, push a suggestion to the Conversational Bot linking to that article for failed payments."

**Execution Steps:**
1. Claude calls `acquire_analytics_chat_most_common_tags` to retrieve the aggregate tag data.
2. Claude identifies that 'billing_failure' is indeed spiking.
3. Claude calls `list_all_acquire_kb_articles` to verify the existence of the credit card update documentation.
4. Claude calls `acquire_bot_qna_push_to_suggestions`, packaging the question and the KB link into a structured JSON payload, staging the update for the conversational bot.

## Rate Limits and Pagination Realities

Acquire, like all enterprise SaaS platforms, enforces rate limits to protect its infrastructure. A common misconception with [managed MCP servers](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) is that they magically absorb these limits. They do not.

If Claude attempts to loop through 500 cases too rapidly, Acquire will return an `HTTP 429 Too Many Requests` error. **Truto does not retry, throttle, or apply automatic backoff on rate limit errors.** Truto passes the 429 error directly back to Claude.

However, Truto *does* normalize the upstream rate limit information. Regardless of how Acquire formats its specific headers, Truto translates them into standardized IETF headers: `ratelimit-limit`, `ratelimit-remaining`, and `ratelimit-reset`. It is the responsibility of the calling agent (or the framework orchestrating the LLM) to inspect these headers and implement appropriate retry/backoff logic.

Similarly, Truto normalizes Acquire's pagination models. Whether the underlying endpoint uses cursor-based or offset-based iteration, Truto maps it to standard `limit` and `next_cursor` properties in the tool schema, explicitly instructing the LLM to pass the cursor values back unchanged to traverse the dataset.

## Summary

Building custom MCP servers for platforms like Acquire requires a massive upfront investment in schema mapping, authentication handling, and maintenance. By leveraging Truto, you replace that engineering burden with a single API call, instantly equipping Claude with secure, documented, and fully normalized tools.

Stop writing boilerplate integration code. Focus on building the actual AI workflows that reduce resolution times and improve customer satisfaction.

> Ready to give your AI agents secure, managed access to Acquire and 100+ other enterprise APIs? Talk to our engineering team today.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)