---
title: "Connect Tidio to Claude: Resolve tickets and monitor user activity"
slug: connect-tidio-to-claude-resolve-tickets-and-monitor-user-activity
date: 2026-08-04
author: Nachi Raman
categories: ["AI & Agents"]
excerpt: "Learn how to connect Tidio to Claude using a managed MCP server. Automate ticket resolution, Lyro AI training, and support triage with Truto."
tldr: "Connect Tidio to Claude via a managed MCP server to automate live chat workflows, resolve support tickets, and trigger Lyro AI responses. Includes working tool definitions and agent workflows."
canonical: https://truto.one/blog/connect-tidio-to-claude-resolve-tickets-and-monitor-user-activity/
---

# Connect Tidio to Claude: Resolve tickets and monitor user activity


If you need to connect Tidio to Claude to automate customer support triage, resolve live chat tickets, or analyze visitor activity, you need a [Model Context Protocol (MCP)](https://truto.one/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms/) server. This server acts as the critical translation layer between Claude's function calls and Tidio's REST API endpoints. You can spend weeks [building, hosting, and maintaining this infrastructure](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/) yourself, or use a [managed integration platform like Truto](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) to dynamically generate a secure, authenticated MCP server URL. If your team uses ChatGPT, check out our guide on [connecting Tidio to ChatGPT](https://truto.one/connect-tidio-to-chatgpt-sync-customer-data-and-manage-tickets/) and explore our broader architectural overview on [connecting Tidio to AI Agents](https://truto.one/connect-tidio-to-ai-agents-train-lyro-ai-and-sync-knowledge-bases/).

Giving a Large Language Model (LLM) read and write access to a live customer service environment 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 vendor-specific rate limits. Every time Tidio updates an endpoint or changes a payload requirement, 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 Tidio, connect it natively to Claude, and execute complex support workflows using natural language.

## The Engineering Reality of the Tidio 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 Tidio's APIs is painful. You are not just integrating a simple database - you are orchestrating asynchronous [AI agents](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/) (Lyro), managing complex ticket states, and handling high-velocity user session data.

If you decide to build a custom MCP server for Tidio, you own the entire API lifecycle. Here are the specific technical challenges you will face:

**Asynchronous Lyro AI Processing**
Tidio's `Lyro AI` ticket answering endpoints do not return immediate results. When you ask Lyro to generate an answer for a ticket, the response can take up to 40 seconds to process. If you directly expose this endpoint to Claude without proper context, the LLM will timeout or assume the tool call failed. Your MCP server needs to clearly document this latency in the tool descriptions, ensuring the LLM knows to wait for the response or handle the asynchronous delay appropriately.

**Strict All-or-Nothing Bulk Operations**
Tidio supports bulk operations for contacts (creating or updating up to 100 contacts per request). However, these batch operations follow a strict all-or-nothing strategy. If 99 contacts are formatted perfectly but one has a malformed `distinct_id`, the entire batch request fails. When LLMs generate arrays of objects, they frequently make minor schema errors. Your MCP server must either validate and sanitize the array before passing it to Tidio, or rely on highly explicit JSON Schema descriptions to prevent the model from hallucinating invalid properties.

**Transparent Rate Limit Passing**
Tidio enforces rate limits to protect its infrastructure. A common mistake when building MCP servers is attempting to absorb these limits inside the middleware layer via silent retries. Truto takes a different approach: Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Tidio API returns an HTTP 429 Too Many Requests error, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. The caller (the Claude client or your agentic framework) is strictly responsible for interpreting these headers and executing its own retry and backoff logic.

## How to Generate a Tidio MCP Server with Truto

Truto dynamically generates MCP tools based on Tidio's resource definitions and API documentation. A tool only appears in the MCP server if it has a corresponding documentation entry - this acts as a quality gate to ensure Claude only accesses well-defined endpoints. 

You can generate your self-contained MCP server URL using either the Truto UI or the API.

### Method 1: Via the Truto UI

The fastest way to generate an MCP server is directly through the Truto dashboard.

1. Navigate to the **Integrated Accounts** page and select your connected Tidio account.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration. You can name the server, filter by specific methods (like `read` or `write`), filter by specific tool tags (like `tickets` or `contacts`), and set an expiration date.
5. Copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4e5f6...`).

### Method 2: Via the Truto API

For platform engineers building multi-tenant AI products, you can dynamically provision Tidio MCP servers for your users via the Truto API. 

Make a POST request to `/integrated-account/:id/mcp` with your desired configuration:

```bash
curl -X POST https://api.truto.one/integrated-account/<tidio_account_id>/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Tidio Support Agent",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["tickets", "contacts"]
    }
  }'
```

The API will validate the configuration, generate a cryptographically secure token, and return a ready-to-use JSON-RPC 2.0 endpoint.

## How to Connect the MCP Server to Claude

Once you have your Truto MCP URL, you need to register it with your Claude environment. Because the URL contains a cryptographic token that securely identifies the Tidio instance, no additional headers are required unless you specifically configured the server to demand them.

### Method A: Via the Claude UI

If you are using Claude's web interface or enterprise workspace settings:

1. In Claude, navigate to **Settings - Integrations - Add MCP Server**.
2. Paste your Truto MCP URL into the Server URL field.
3. Give the connection a descriptive name (e.g., "Tidio Customer Support").
4. Click **Add**. Claude will immediately execute an `initialize` handshake and pull down the available Tidio tools.

*(Note: If your team uses ChatGPT, the process is similar: Settings - Connectors - Add custom connector - paste the URL).* 

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

If you are running Claude Desktop locally or orchestrating headless agents, you will update your configuration file. Because Truto MCP servers operate over standard HTTP, you use the Server-Sent Events (SSE) transport adapter.

Edit your `claude_desktop_config.json` file:

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

Restart Claude Desktop. The model will now have secure, authenticated access to your Tidio instance.

## Tidio Hero Tools for Claude

Truto exposes Tidio's endpoints as semantically named, fully documented tools. Claude uses these tools by passing flat JSON arguments, which Truto's proxy router automatically maps into the correct query parameters and request bodies. Here are the highest-leverage tools available for Tidio.

### List all Tidio tickets

Retrieves a paginated list of all Tidio tickets. This tool pulls ticket metadata (status, subject, priority, assignee) without downloading the heavy message payload. Use this to audit queues or find open issues for specific contacts.

*Usage notes:* The LLM should extract the `id` from the results to use in subsequent calls to fetch the full conversation.

> "Claude, check Tidio and list all tickets currently assigned to the support department with a 'high' priority status. Give me a summary of their subjects."

### Get single Tidio ticket by id

Fetches the complete context of a specific ticket, including all historical messages between the customer, operators, and bots. 

*Usage notes:* This tool requires the ticket `id`. The resulting payload contains a `messages` array, which is critical for the LLM to read before attempting to draft a reply.

> "Fetch the full message history for Tidio ticket ID 987654. Summarize the customer's main complaint and tell me what the last operator said."

### Tidio tickets reply

Appends a new message to an existing ticket conversation. The LLM can draft and send a reply directly into the Tidio interface.

*Usage notes:* Requires `ticket_id`, `author_type`, and `content`. Ensure the model sets the `author_type` correctly (usually as an operator or system bot) so the reply routes correctly in the Tidio UI.

> "Draft a polite response to ticket 987654 apologizing for the billing delay, and post it to the thread as an operator reply."

### Update a Tidio contact by id

Modifies a visitor or customer's CRM profile inside Tidio. This allows the AI to enrich contact records with data gathered during a conversation or pulled from another system.

*Usage notes:* Requires the contact `id`. The LLM can update standard fields (email, phone, name) or push data into custom `properties`.

> "Update the Tidio contact ID 12345 to include their new phone number (+15551234567) and set their newsletter consent to true."

### List all Tidio contact viewed pages

Retrieves the web browsing history of a specific contact over the past 30 days. This is an incredibly powerful tool for understanding user intent before responding to a ticket.

*Usage notes:* Requires `contact_id`. Returns an array of URLs and timestamps indicating exactly what the user looked at on your website.

> "Before we reply to John Doe's ticket about pricing, pull his viewed pages in Tidio to see which specific pricing tiers he was looking at today."

### Tidio Lyro answer ticket

Leverages Tidio's native Lyro AI agent to generate an answer for a specific ticket based on your uploaded knowledge base.

*Usage notes:* Requires `ticket_id`, `subject`, `contact_email`, and the existing `messages` array. As noted in the Engineering Reality section, this operation can take up to 40 seconds to return the `message_content`. 

> "Pass ticket 554321 to the Lyro AI agent. Let me know what response Lyro generates based on our knowledge base."

To view the complete schema details, required properties, and the rest of the available operations, visit the [Tidio integration page](https://truto.one/integrations/detail/tidio).

## Workflows in Action

When you connect Tidio to Claude via MCP, you graduate from simple chat completion to autonomous support operations. Here is how Claude orchestrates multiple Tidio tools to solve real-world problems.

### Scenario 1: Context-Driven Ticket Resolution

Customer support agents waste hours manually looking up what a user did before submitting a ticket. Claude can automate the entire discovery and drafting process.

> "A new ticket just came in from sarah@example.com complaining about a checkout error. Find her ticket, look at what pages she viewed before submitting it, and draft a reply explaining how to clear her cache."

1. **`list_all_tidio_tickets`**: Claude searches the queue filtering by the contact email to find Sarah's open ticket and extracts the `id`.
2. **`get_single_tidio_ticket_by_id`**: Claude reads the ticket details to extract her specific `contact_id`.
3. **`list_all_tidio_contact_viewed_pages`**: Claude queries her page history using the `contact_id`, discovering she was specifically stuck on `/checkout/payment-method`.
4. **`tidio_tickets_reply`**: Claude formats a highly contextual response referencing the specific payment page and posts the reply to the ticket.

```mermaid
sequenceDiagram
    participant User as User Prompt
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Server
    participant Tidio as Tidio API

    User->>Claude: "Resolve Sarah's checkout ticket" 
    Claude->>MCP: Call list_all_tidio_tickets(email: sarah...)
    MCP->>Tidio: GET /tickets?email=sarah...
    Tidio-->>MCP: Return ticket metadata
    MCP-->>Claude: Ticket ID: 9988
    Claude->>MCP: Call get_single_tidio_ticket_by_id(id: 9988)
    MCP->>Tidio: GET /tickets/9988
    Tidio-->>MCP: Return ticket details & contact_id: 5544
    MCP-->>Claude: Contact ID: 5544
    Claude->>MCP: Call list_all_tidio_contact_viewed_pages(5544)
    MCP->>Tidio: GET /contacts/5544/viewed_pages
    Tidio-->>MCP: Return [/checkout/payment-method]
    MCP-->>Claude: Page history
    Claude->>MCP: Call tidio_tickets_reply(ticket_id: 9988, content: ...)
    MCP->>Tidio: POST /tickets/9988/reply
    Tidio-->>MCP: Success
    MCP-->>Claude: Reply posted
```

### Scenario 2: Data Enrichment and CRM Syncing

During a live chat or email exchange, customers often drop valuable data (phone numbers, titles, feature requests) into unstructured text. Claude can parse this data and structure it automatically.

> "Review the latest messages in ticket ID 112233. If the user provided a phone number or mentioned their company size, update their contact profile in Tidio to reflect that data."

1. **`get_single_tidio_ticket_by_id`**: Claude fetches the ticket and reads the `messages` array.
2. Claude internally processes the natural language, identifying a string like "You can reach me at 555-0199, we have 40 employees."
3. **`update_a_tidio_contact_by_id`**: Claude constructs a JSON payload updating the contact's `phone` field and pushing the employee count into the custom `properties` object.

The user gets a fully enriched CRM record without manual data entry.

### Scenario 3: Training the Lyro AI Agent

Knowledge base managers need to constantly update the data sources that feed Tidio's Lyro AI. Claude can automate this pipeline.

> "We just published a new refund policy at https://example.com/refunds. Submit this URL to be scraped as a data source for Lyro so the bot knows how to handle returns."

1. **`tidio_lyro_data_sources_scrape_website`**: Claude passes the provided URL to the endpoint.
2. **`list_all_tidio_lyro_data_sources`**: Claude queries the data sources list to verify the URL was successfully added and checks its `sync_status`.

The user is informed that the Lyro bot is now training on the new documentation.

## Security and Access Control

Exposing your support infrastructure to an LLM requires strict boundary management. Truto MCP servers provide four layers of configuration to limit what the model can do:

*   **Method Filtering (`methods`)**: Restrict the MCP server to specific HTTP verbs. You can set the server to `read` only (allowing `list` and `get`), ensuring the LLM can analyze tickets but cannot accidentally delete contacts or send replies.
*   **Tag Filtering (`tags`)**: Restrict access to specific functional areas based on Tidio resource tags. You can configure the server to only expose tools tagged with `tickets`, entirely hiding the `operators` and `departments` admin resources from the model.
*   **API Token Authentication (`require_api_token_auth`)**: By default, the MCP URL contains the authentication token. If you enable this flag, the client must also pass a valid Truto API token in the Authorization header. This adds a secondary layer of security if your MCP URL is exposed in log files or shared configurations.
*   **Automatic Expiration (`expires_at`)**: Set an ISO datetime for the server to automatically self-destruct. Truto uses Cloudflare KV and Durable Objects to strictly enforce this TTL, instantly revoking the LLM's access to Tidio after the deadline passes - perfect for temporary auditing tasks.

## Stop Building Boilerplate

Connecting Tidio to Claude shouldn't require weeks of reading API documentation, writing custom pagination logic, and maintaining massive JSON schemas. The focus of your engineering team should be building intelligent agent workflows, not wrestling with HTTP 429 errors and asynchronous AI polling states.

By using Truto to generate a [managed MCP server](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/), you instantly translate Tidio's entire API surface into structured tools that Claude understands natively. 

> Stop maintaining custom connector code. Let Truto handle the integration layer so you can focus on building intelligent AI agents.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)