Connect Help Scout to ChatGPT: Manage Conversations & Threads via MCP

If you need to connect Help Scout to ChatGPT so your AI agents can triage tickets, update customer profiles, and draft replies based on historical context, you need a Model Context Protocol (MCP) server. If your team uses Claude instead, check out our guide on connecting Help Scout to Claude or explore our broader architectural overview on connecting Help Scout to AI Agents.

Giving a Large Language Model (LLM) read and write access to your support helpdesk is an engineering challenge. You must handle OAuth 2.0 token lifecycles, translate vendor-specific API structures into strict JSON schemas, and manage complex pagination. You either spend weeks building, hosting, and maintaining a custom MCP server, or you use a managed infrastructure layer to handle the boilerplate.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Help Scout, connect it natively to ChatGPT, and execute complex support workflows using natural language.

The Engineering Reality of the Help Scout API

A custom MCP server is a self-hosted integration layer that translates an LLM's JSON-RPC tool calls into REST API requests. While the MCP standard provides a predictable way for models to discover tools, implementing it against vendor APIs is painful. If you decide to build a custom MCP server for Help Scout, you own the entire API lifecycle. Here are the specific integration challenges that break standard assumptions when working with Help Scout V2:

The HAL+JSON Pagination Maze

Help Scout relies heavily on Hypertext Application Language (HAL) for its JSON responses. When an LLM requests a list of conversations, the payload does not simply return an array of objects. It returns data nested inside an _embedded object, with pagination links stored in a _links object. An LLM cannot navigate this structure natively. If your custom MCP server does not explicitly normalize this HAL structure into standard JSON schemas and inject next_cursor logic, the LLM will hallucinate the pagination state and fail to traverse the inbox.

Thread vs. Conversation Hierarchies

In Help Scout, a "Conversation" is merely the container. The actual messages, notes, and state changes are "Threads." If an LLM calls a "Get Conversation" endpoint, it only receives a preview of the latest message. To read the full history, the agent must make a secondary call to the Threads endpoint. Your system must instruct the LLM on this two-step architecture, otherwise, the agent will attempt to reply to tickets without reading the context.

Strict Rate Limits and 429 Handling

The Help Scout Mailbox API strictly enforces a limit of 400 requests per minute per user. If an LLM attempts to bulk-summarize 50 tickets and pulls the threads for each, it will trigger a 429 Too Many Requests error.

A critical architectural note on Truto's handling of rate limits: Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Help Scout API returns HTTP 429, Truto passes that error directly to the caller. However, Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF spec. The caller (your agent orchestrator) is responsible for parsing these headers and implementing retry/backoff logic. Do not assume the integration layer absorbs these errors.

Destructive Customer Deletes

Help Scout enforces cascading deletes. If an agent calls the delete customer endpoint, it hard-deletes the customer and completely destroys every conversation associated with them. Exposing raw delete access to an LLM without strict method filtering is a massive operational risk.

The Managed MCP Approach

Instead of forcing your engineering team to build a bespoke server for Help Scout, Truto dynamically generates an MCP server derived directly from the API's documentation and resource schemas.

Truto derives tools dynamically from the integration's resource definitions. A tool only appears in the MCP server if it has a corresponding documentation entry. This acts as a quality gate, ensuring only curated, well-described endpoints are exposed to the LLM. Each MCP server is backed by cryptographic tokens stored in edge Key-Value infrastructure, making the server URL fully self-contained.

How to Generate a Help Scout MCP Server

You can spin up a dedicated MCP server for a specific Help Scout account in seconds. There are two ways to do this.

Method 1: Via the Truto UI

1. Navigate to the Integrated Accounts page for your connected Help Scout tenant.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., restrict to read methods only, or apply support tags).
5. Copy the generated secure MCP server URL.

Method 2: Via the API For programmatic access, you can generate the server via a POST request. This creates a secure token stored in edge KV infrastructure and returns a ready-to-use endpoint.

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": "Help Scout Triage Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["support"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The response contains the exact URL you will provide to your LLM client.

Connecting the Help Scout MCP Server to ChatGPT

Once you have your Truto MCP Server URL (e.g., https://api.truto.one/mcp/abc123xyz), you can connect it to ChatGPT. The configuration differs slightly based on your usage tier and setup.

Method A: Via the ChatGPT UI

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Enable Developer mode (MCP support requires this flag).
3. Under MCP servers / Custom connectors, click to add a new server.
4. Name: Enter a label like "Help Scout (Truto)".
5. Server URL: Paste the Truto MCP URL.
6. Save the configuration. ChatGPT will immediately connect, perform the JSON-RPC handshake, and list the available Help Scout tools.

Method B: Via Manual Config File (for local orchestrators or desktop apps) If you are running a local agent, Claude Desktop, or a custom orchestrator, you can connect using a standard JSON configuration file utilizing the SSE transport layer.

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

Help Scout Hero Tools for ChatGPT

By leveraging Truto's dynamic tool generation, your ChatGPT instance automatically gains access to formatted, schema-validated Help Scout endpoints. Here are the highest-leverage tools available for support operations.

list_all_help_scout_conversations

This tool allows the LLM to search the inbox. It accepts query parameters for status, tags, and specific mailboxes. Truto automatically injects standard limit and next_cursor logic into the schema, instructing the LLM to pass cursor values back unchanged to traverse pages.

"Find all conversations in the Support mailbox currently marked as 'active' that have not been updated in the last 48 hours."

get_single_help_scout_conversation_by_id

Retrieves the metadata for a specific ticket. The LLM receives the status, assignee, tags, custom fields, and a preview of the text. Because Help Scout separates metadata from the message history, this is usually step one in an agent workflow.

"Get the details for conversation ID 142857 to see who it is assigned to and what custom fields are applied."

list_all_help_scout_conversation_threads

This is the most critical tool for contextual AI. It returns the actual sequence of customer messages, agent replies, and internal notes for a given conversation ID. Without this tool, the LLM is flying blind.

"Pull all the threads for conversation ID 142857 so I can read the history of what the customer has asked and what our agents have previously suggested."

create_a_help_scout_conversation_thread

Allows the LLM to append new information to a ticket. Depending on the parameters passed, this can act as a direct reply to the customer or an internal note for human agents.

"Add an internal note to conversation ID 142857 summarizing the customer's frustration and suggesting that Tier 2 support investigates the billing discrepancy."

update_a_help_scout_customer_by_id

Enables the agent to enrich user profiles based on context found in the chat. The LLM can execute patch operations to update fields like jobTitle, location, phones, or social profiles without overwriting the entire record.

"The user mentioned they recently became VP of Engineering. Update the customer profile for ID 84729 to reflect this new job title."

help_scout_conversation_attachments_download

When customers send screenshots of errors, the LLM needs to view them. This tool accepts the downloadUrl provided in the thread history and fetches the raw file data, bypassing Help Scout's complex multi-part requirements.

"Download the attachment from the latest thread in conversation ID 142857 so I can analyze the error logs the customer sent."

For the complete inventory of Help Scout endpoints, parameters, and JSON schemas, see the Help Scout integration page.

Workflows in Action

When you combine these tools, ChatGPT stops being a simple chatbot and becomes an active participant in your support operations. Here are two concrete workflows.

Workflow 1: VIP Ticket Triage and Context Aggregation

An enterprise customer submits a vague email saying, "The integration is broken again." An LLM can automatically triage this before a human agent ever sees it.

User Prompt: "Check the Support mailbox for new active tickets from Acme Corp. Read the history, summarize the ongoing issue as an internal note, and assign the ticket to the integration team."

1. list_all_help_scout_conversations: ChatGPT filters for active conversations originating from Acme Corp's domain.
2. list_all_help_scout_conversation_threads: The agent extracts the thread IDs and reads the entire back-and-forth history over the last 30 days.
3. create_a_help_scout_conversation_thread: ChatGPT synthesizes the history and adds an internal note summarizing the technical details for the human agent.
4. update_a_help_scout_conversation_by_id: The agent updates the ticket status and reassigns the owner ID to the Tier 2 integration queue.

Outcome: When the human engineer opens Help Scout, the ticket is routed correctly, and a concise technical summary is waiting in the internal notes.

Workflow 2: Automated Profile Enrichment

Support agents rarely have time to manually update CRM data. An LLM can continuously monitor incoming threads for state changes.

User Prompt: "Review yesterday's closed tickets. If any customer provided a new phone number or updated their company name during the chat, update their Help Scout customer profile to match."

1. list_all_help_scout_conversations: ChatGPT pulls conversations closed in the last 24 hours.
2. list_all_help_scout_conversation_threads: It reads the message bodies looking for explicit mentions of contact info (e.g., "You can reach my new cell at 555-0199").
3. update_a_help_scout_customer_by_id: The agent executes a PATCH request to append the new phone number to the customer's profile arrays.

Outcome: Help Scout customer records remain perfectly synced with reality, entirely via passive AI processing.

Security and Access Control

Giving an LLM access to your Help Scout data requires strict governance. Truto's MCP architecture enforces security at the infrastructure layer, preventing prompt injection attacks from destroying your data.

• Method Filtering: Configure config.methods: ["read"] during server creation. The tool generation engine evaluates this at runtime, ensuring create, update, and delete tools simply do not exist in the LLM's context window. It is physically impossible for the agent to mutate data.
• Tag Filtering: Restrict access to specific functional areas using config.tags: ["support"]. This isolates the agent to Help Scout's ticketing endpoints while blocking access to sensitive organizational settings or webhooks.
• API Token Auth (require_api_token_auth): By default, an MCP URL is self-authenticating. For enterprise environments, setting this flag to true requires the ChatGPT client to pass a valid Truto API token in the Authorization header, adding a required secondary layer of identity verification.
• Automated Expiration (expires_at): Provide temporary access to external AI contractors or specific workflow runs. When the TTL expires, edge schedulers automatically hard-delete the tokens from the KV infrastructure. The server immediately returns a 401 Unauthorized.

Moving Forward

Connecting Help Scout to ChatGPT unlocks a massive tier of automation for support teams, but the underlying API mechanics - HAL pagination, rate limits, and nested threading - make custom implementations fragile.

By leveraging a managed MCP server via Truto, you bypass the boilerplate. You get auto-generated, schema-validated tools that connect natively to ChatGPT, backed by edge-level security controls. Your engineering team can focus on writing better prompts and orchestrating workflows, rather than debugging OAuth refresh tokens and tracking pagination cursors.