Connect Clio Grow to Claude: Track client contacts and campaigns

If your team needs to connect Clio Grow to Claude to automate legal intake, track marketing campaigns, or manage client communications, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and Clio Grow's REST APIs. 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 /connect-clio-grow-to-chatgpt-manage-legal-intake-and-matter-notes/ or explore our broader architectural overview on /connect-clio-grow-to-ai-agents-automate-lead-and-case-workflows/.

Giving a Large Language Model (LLM) read and write access to a specialized legal CRM like Clio Grow is a significant engineering challenge. You have to handle OAuth 2.0 token lifecycles, map massive JSON schemas to MCP tool definitions, and deal with strict data isolation rules required by legal professionals (read more on MCP security for legal data). Every time an endpoint is updated, 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 Clio Grow, connect it natively to Claude Desktop, and execute complex legal intake workflows using natural language.

The Engineering Reality of the Clio Grow 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. Clio Grow is built to manage law firm intake, which means its data model behaves very differently than a standard B2B sales CRM (compare this to connecting Clio Manage to Claude for practice management).

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

The Staging Ground: Inbox Leads vs. Contacts Legal CRMs cannot simply dump raw form submissions into a generic "Contact" table. Law firms require strict conflict-of-interest checks before a person is officially recognized as a client or a matter is opened. Because of this, Clio Grow utilizes an Inbox Leads resource. This acts as a staging ground. An LLM cannot just call a generic create_contact endpoint for new web inquiries; it must specifically interact with the Inbox Leads endpoints, check the state of those leads, and allow human operators or specific business logic to promote them to full Contacts and Matters. Your MCP tool schemas must explicitly define these boundaries to prevent the AI from hallucinating direct contact creation for unvetted leads.

Complex Array Filtering on High-Volume Endpoints Clio Grow handles pagination and filtering with strict parameter requirements. When querying lists of contacts, matters, or leads, Clio Grow pages through results up to 200 records at a time. More critically, if you want to filter by specific record IDs, the API requires a specific array syntax in the query string: ids []=1&ids []=2. If a naive LLM attempts to pass a comma-separated string like ids=1,2, the request will fail. An MCP server must intercept the LLM's arguments and serialize them into the exact URL-encoded array format the upstream API expects.

Implicit Permissions on Sources Tracking where a lead came from is critical for law firms. However, Clio Grow documents no specific OAuth scopes for the Sources endpoints. Access is dictated entirely by the underlying application's permission model. Building a custom MCP server means you have to write custom error handling to catch unexpected 403 Forbidden errors when an LLM tries to query lead sources on an account that lacks the implicit permissions.

How Truto Handles Rate Limits and Pagination

When exposing APIs to AI agents, handling rate limits and pagination is critical to prevent broken agent loops.

Rate Limits: Truto does not retry, throttle, or apply backoff on rate limit errors. When Clio Grow returns an HTTP 429 Too Many Requests, Truto passes that error directly to the caller (Claude). However, Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The caller - your agent framework or Claude Desktop - is strictly responsible for reading these headers and executing the appropriate retry or backoff logic.

Pagination: Truto's dynamic tool generation automatically injects limit and next_cursor properties into the query schema for all list operations. The tool description explicitly instructs the LLM to pass cursor values back unchanged. This allows Claude to safely page through massive lists of Clio Grow contacts without blowing up its context window or requiring custom pagination logic in your integration code.

Creating the Clio Grow MCP Server

Truto dynamically generates MCP tools from Clio Grow's API documentation and endpoint configurations. You can generate a secure MCP server URL in seconds using either the Truto UI or the REST API.

Method 1: Via the Truto UI

If you prefer a visual interface, you can generate the MCP server directly from your Truto dashboard:

1. Navigate to the Integrated Accounts page and select your connected Clio Grow instance.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration. You can optionally filter by specific HTTP methods (e.g., read-only) or specific resource tags.
5. Click Create and copy the generated MCP server URL.

This URL contains a hashed cryptographic token that routes requests securely to this specific integrated account.

Method 2: Via the Truto API

For teams automating their infrastructure, you can generate the MCP server programmatically by making a POST request to the Truto API.

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

Success Response:

{
  "id": "mcp_srv_9x8y7z6w",
  "name": "Clio Grow Intake Agent",
  "config": { "methods": ["read", "write"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Keep this URL secure. It acts as the full authentication required to interface with the Clio Grow account via the Model Context Protocol.

Connecting the MCP Server to Claude

Once you have your Truto MCP URL, connecting it to Claude takes less than a minute. You can do this via the Claude Desktop UI or by editing the local configuration file.

Method A: Via the Claude UI

If you are using the Claude desktop app or web interface with custom connector support:

1. Open Claude and navigate to Settings.
2. Select Integrations (or Connectors depending on your plan tier).
3. Click Add MCP Server or Add custom connector.
4. Paste the Truto MCP URL (https://api.truto.one/mcp/...) into the URL field.
5. Click Add.

Claude will immediately perform an MCP handshake, call the tools/list protocol method, and discover all available Clio Grow tools.

Method B: Via Manual Configuration File

For developer environments, you can configure Claude Desktop manually by editing the claude_desktop_config.json file. This utilizes the official Server-Sent Events (SSE) transport adapter provided by the MCP specification.

1. Open your Claude Desktop configuration file:

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

2. Add the Truto MCP server using the @modelcontextprotocol/server-sse package:

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

3. Restart Claude Desktop. The prompt bar will now display a plug icon indicating that the Clio Grow tools are loaded and ready for use.

Hero Tools for Clio Grow

Truto automatically maps Clio Grow's REST endpoints into descriptive, snake_case tool names that LLMs can easily understand. Here are the highest-leverage tools available for automating legal workflows.

list_all_clio_grow_inbox_leads

This tool retrieves a paginated list of inbox leads. Inbox leads represent potential clients who have submitted inquiries but have not yet passed conflict checks or been converted to active contacts. The state parameter is required to filter leads by their current status.

"Claude, list all the new inbox leads in Clio Grow that need to be reviewed for conflict checks today."

create_a_clio_grow_inbox_lead

Creates a new inbox lead in the staging area. This is the primary entry point for chat agents, web forms, and automated intake systems to push data into Clio Grow safely.

"A potential client named Sarah Jenkins just asked about a family law issue via our website chat. Please create a new inbox lead for her with the data provided."

list_all_clio_grow_contacts

Returns a paginated list of official contacts (people or businesses). Truto automatically pages through results (which Clio limits to 200 per page) and formats the ids [] array syntax if the LLM requests specific records.

"Fetch the contact records for our top 5 corporate clients so I can review their recent activity."

get_single_clio_grow_matter_by_id

Retrieves a single matter (a specific case or legal issue) by its unique ID. This is critical for pulling context before generating documents or writing emails to clients.

"Get the details for matter ID 84729 so I can summarize the current case status for the managing partner."

create_a_clio_grow_matter_note

Appends a new note to a specific matter. This tool requires the matter_id and the note data. It is highly useful for automating meeting summaries or logging phone calls against a case file.

"I just finished a consultation with the client for matter 84729. Take this raw transcript, summarize the key legal issues, and create a new matter note with the summary."

list_all_clio_grow_marketing_campaigns

Retrieves the account's active marketing campaigns. This allows agents to attribute incoming inbox leads to the correct marketing spend, enabling automated ROI reporting.

"List all active marketing campaigns in Clio Grow so we can tag the new batch of inbox leads to the correct Q3 advertising source."

create_a_clio_grow_custom_action

Creates a custom action within Clio Grow. Custom actions are used to trigger specific workflow steps or internal notifications, acting as the connective tissue between the CRM and the firm's operational processes.

"Create a custom action to remind the paralegal team to request court documents for the newly opened matter 84729."

To view the complete inventory of available endpoints, request schemas, and data models, view the Clio Grow integration page.

Workflows in Action

Connecting Claude to Clio Grow via MCP enables complex, multi-step agentic workflows that would normally require manual data entry by legal assistants.

Scenario 1: Legal Intake Processing

When a new web inquiry arrives, an intake agent needs to safely stage the prospect, attribute the marketing source, and prepare the record for a human conflict check.

"We received a new inquiry from John Doe regarding a real estate dispute. He clicked our 'Fall Property' ad. Please find the corresponding marketing campaign, create a new inbox lead for him, and tie it to that campaign so the intake team can review it."

Execution Steps:

1. Claude calls list_all_clio_grow_marketing_campaigns to search the firm's active campaigns and find the ID for the "Fall Property" ad.
2. Claude calls create_a_clio_grow_inbox_lead passing John Doe's information and associating the retrieved campaign ID with the lead data.
3. Claude returns a natural language summary confirming the lead is safely staged in the inbox and awaiting human review.

sequenceDiagram
    participant User as User / Webhook
    participant Claude as Claude
    participant Truto as Truto MCP Server
    participant Clio as Clio Grow API

    User->>Claude: Process new inquiry for John Doe
    Claude->>Truto: Call list_all_clio_grow_marketing_campaigns
    Truto->>Clio: GET /v1/marketing_campaigns
    Clio-->>Truto: Return campaign IDs
    Truto-->>Claude: JSON array of campaigns
    Claude->>Truto: Call create_a_clio_grow_inbox_lead(data, campaign_id)
    Truto->>Clio: POST /v1/inbox_leads
    Clio-->>Truto: 201 Created (Lead ID)
    Truto-->>Claude: Tool result success
    Claude-->>User: "Lead created and attributed to Fall Property ad."

Scenario 2: Pre-Consultation Briefing

Before a lawyer steps into a consultation, they need to quickly catch up on the matter's history without clicking through dozens of CRM tabs.

"I have a meeting with the client for matter ID 59302 in five minutes. Pull the matter details, grab all the recent notes attached to it, and write a brief executive summary of where the case stands. Then, create a new note indicating I am entering the Q2 consultation."

Execution Steps:

1. Claude calls get_single_clio_grow_matter_by_id (passing ID 59302) to understand the core case parameters (status, value, assigned attorneys).
2. Claude calls list_all_clio_grow_matter_notes (passing matter_id: 59302) to retrieve historical context.
3. Claude synthesizes the data internally, presents a quick bulleted summary to the user.
4. Claude calls create_a_clio_grow_matter_note to log an audit trail note stating the Q2 consultation has commenced.

Security and Access Control

Law firms have strict data privacy requirements. Truto provides several mechanisms to lock down your MCP server and ensure Claude only has access to exactly what it needs:

• Method Filtering (config.methods): Restrict the MCP server to specific HTTP verbs. For example, passing ["read"] ensures Claude can only list and get records, completely eliminating the risk of the AI accidentally deleting a matter or modifying a contact.
• Tag Filtering (config.tags): Group tools by functional area. You can restrict an MCP server to only expose tools tagged with intake, preventing the LLM from accessing billing or administrative resources.
• Extra Authentication (require_api_token_auth): By default, possessing the MCP URL grants access. Enabling this flag forces the MCP client to also pass a valid Truto API token in the Authorization header, adding a strict secondary layer of identity verification.
• Time-to-Live (expires_at): Generate short-lived MCP servers for contractors or temporary AI workflows. Once the ISO datetime is reached, Truto automatically destroys the token and schedules a Durable Object alarm to sweep the KV storage, ensuring no stale access remains.

Architecting for Legal Automation

Integrating AI with legal software requires more than just firing JSON payloads at an endpoint. You have to respect the domain boundaries of the platform - like the strict separation between Inbox Leads and Matters - while handling the technical realities of rate limits and array serialization.

By leveraging Truto's dynamic MCP server generation, you offload the entire infrastructure burden. You get standardized tools, seamless pagination handling, and strict security controls out of the box, allowing your engineering team to focus on building intelligent legal workflows instead of maintaining API connectors.