---
title: "Connect Planhat to ChatGPT: Manage Accounts, Projects, and Churn"
slug: connect-planhat-to-chatgpt-manage-accounts-projects-and-churn
date: 2026-06-09
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to connect Planhat to ChatGPT using an MCP server. Automate customer success workflows, query MRR, manage onboarding projects, and triage churn risks."
tldr: "This guide details how to generate a managed MCP server for Planhat and connect it to ChatGPT. Enable your AI agents to query customer health, manage projects, update licenses, and execute complex Customer Success workflows using natural language."
canonical: https://truto.one/blog/connect-planhat-to-chatgpt-manage-accounts-projects-and-churn/
---

# Connect Planhat to ChatGPT: Manage Accounts, Projects, and Churn


If you want to connect Planhat to ChatGPT so your Customer Success teams and AI agents can query account health, update onboarding projects, and flag churn risks automatically, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). If your team uses Claude instead, check out our guide on [connecting Planhat to Claude](https://truto.one/connect-planhat-to-claude-sync-sales-licenses-and-invoices/), or review our architectural breakdown on [connecting Planhat to AI Agents](https://truto.one/connect-planhat-to-ai-agents-automate-tasks-tickets-and-nps/).

Planhat serves as the single source of truth for your Customer Success organization. It houses complex relational data spanning MRR, license utilization, onboarding phases, and Net Promoter Scores. Giving a Large Language Model (LLM) agentic access to this data requires translating natural language intent into strict REST API calls. You can either spend engineering cycles [building, securing, and maintaining a custom Python or TypeScript translation layer](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), or you can use a managed platform to [dynamically generate an MCP server](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/).

This guide breaks down the engineering realities of the Planhat API, how to generate a secure MCP server using Truto, how to connect it to ChatGPT, and how to execute multi-step account management workflows via natural language.

## The Engineering Reality of the Planhat API

A custom MCP server acts as middleware. It tells the LLM what tools are available, standardizes the input parameters via JSON Schema, executes the underlying API requests, and formats the response. Building this for Planhat specifically is difficult due to several domain-specific API characteristics.

**The Relational Hierarchy and Mandatory IDs**
Unlike a simple flat CRM, Planhat relies heavily on a strict relational hierarchy anchored by the `companyId`. If an AI agent wants to create a new `Project`, log a `Churn` event, or generate an `Opportunity`, it cannot simply pass a text string for the company name. The LLM must first call the companies endpoint, search for the target company, extract the underlying `_id` (the 24-character hex string representing the `companyId`), and inject that exact string into the payload of the subsequent request. If your MCP server schemas do not explicitly guide the LLM to execute this lookup sequence, the agent will hallucinate a fake ID and the API will reject the payload.

**Complex Financial State and Phase Tracking**
Planhat records are highly sensitive to phase transitions and currency codes. When updating an existing company record or dealing with licenses, fields like `mrrTotal`, `nrrTotal`, and custom metrics require strict type validation. Modifying a phase (e.g., moving a customer from 'Onboarding' to 'Adoption') often triggers internal Planhat automations. Your custom MCP server must ensure the LLM strictly adheres to your specific tenant's accepted values, requiring continuous schema maintenance as your CS ops team updates internal tracking rules.

**Handling Rate Limits and 429 Errors**
Planhat enforces strict API rate limits to protect infrastructure stability. This is critical for agentic workflows where an LLM might attempt to recursively list thousands of endusers or pull massive arrays of conversation history. 

Truto does not absorb these rate limits for you. We do not automatically retry, throttle, or apply exponential backoff on your behalf. When the Planhat API returns an HTTP 429 Too Many Requests, Truto passes that error directly through the proxy layer back to the LLM. However, we normalize the upstream rate limit information into standardized IETF headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`). This predictable header format means your calling application or agent framework can reliably read the remaining quota and implement its own backoff logic before allowing the LLM to retry the tool call.

## Generating the Planhat MCP Server

Instead of hand-coding JSON schemas and OAuth token refresh flows, you can use Truto to [dynamically generate a Planhat MCP server](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/). Truto analyzes the underlying integration resources and automatically derives the necessary MCP tools based on active documentation records. 

Each MCP server is scoped strictly to a single integrated Planhat account, meaning the URL contains a cryptographic token that securely authenticates requests without requiring the LLM client to manage complex headers.

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

### Method 1: Creating via the Truto UI

For administrators and non-developers, the UI provides the fastest path to generating a server URL.

1. Navigate to your Truto dashboard and locate the **Integrated Accounts** section.
2. Select your active Planhat connection.
3. Click on the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. In the configuration modal, provide a descriptive name (e.g., 'Planhat CS Bot Ops').
6. Optional: Select method filters (e.g., restrict to 'read' operations) or apply tag filters to limit the scope of exposed tools.
7. Click **Create** and copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/a1b2c3d4e5...`).

### Method 2: Creating via the REST API

For engineering teams orchestrating multi-tenant environments, you can provision Planhat MCP servers programmatically. This is ideal when spinning up dedicated AI agent workspaces for individual team members.

Make a standard HTTP POST request to the Truto API:

```bash
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": "Planhat Account Manager Bot",
    "config": {
      "methods": ["read", "write"],
      "tags": ["crm", "success"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'
```

The Truto API verifies that the underlying integration is AI-ready, generates a secure, hashed token stored in our key-value infrastructure, and returns the endpoint payload:

```json
{
  "id": "mcp_8f7d6e5c",
  "name": "Planhat Account Manager Bot",
  "config": {
    "methods": ["read", "write"],
    "tags": ["crm", "success"]
  },
  "expires_at": "2026-12-31T23:59:59.000Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}
```

## Connecting the MCP Server to ChatGPT

Once you have the Truto MCP URL, connecting it to an AI client is a matter of configuration. The MCP server handles protocol initialization, capability handshakes, and JSON-RPC tool calling automatically.

### Method A: Connecting via the ChatGPT UI

If you are using ChatGPT Enterprise, Team, or Pro with Developer Mode enabled, you can connect the server directly in the interface.

1. Open ChatGPT and navigate to **Settings -> Apps -> Advanced settings**.
2. Toggle **Developer mode** to the active position.
3. Under the **MCP servers / Custom connectors** section, click to add a new server.
4. **Name:** Enter a recognizable label like "Planhat (Truto)".
5. **Server URL:** Paste the URL generated in the previous step.
6. Save the configuration. 

ChatGPT will immediately ping the endpoint, execute the initialization handshake, and pull the complete list of available Planhat tools.

### Method B: Connecting via Configuration File (For CLI / Claude / Custom Agents)

If you are building custom agents in LangChain, LangGraph, or using desktop environments like Claude Desktop or Cursor, you connect via a configuration file using standard Server-Sent Events (SSE) transport mechanisms.

Create or update your configuration file (e.g., `claude_desktop_config.json`) with the following block:

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

Restart your agent framework or application. The client uses the SSE adapter to route local JSON-RPC messages out to the remote Truto MCP URL over HTTP POST.

## Hero Tools for Planhat Automation

Truto dynamically translates Planhat's vast API surface into distinct, strongly-typed tools. Instead of managing endpoints, the LLM receives structured schemas dictating exact query and body parameters. 

Here are 6 high-leverage hero tools your ChatGPT agent can now access.

### list_all_planhat_companies
This tool retrieves the core account records in your Planhat instance. It returns vital fields including the `_id`, status, phase, health metrics, and MRR. The LLM must use this tool frequently to resolve human-readable company names into the 24-character `_id` required for subsequent operations.

> "Pull a list of all active Planhat companies that are currently in the 'Onboarding' phase. Give me their names, current health scores, and total MRR."

### get_single_planhat_project_by_id
Projects govern onboarding flows, implementation tasks, and major account transitions. This tool requires a specific project ID and returns the start date, timeline, associated company data, and custom attributes. It allows the agent to audit the progress of critical deliverables.

> "Fetch the project details for project ID 'proj_998877'. Has the start date passed, and what custom activity counts are currently logged?"

### list_all_planhat_churn
Churn tracking is the most critical function of a CS team. This tool lists churn records, detailing the exact `churnDate`, financial `value` lost, affected `products`, and the `reasons` tagged by the account manager. It is highly effective for aggregate analysis and pattern recognition.

> "List all Planhat churn records from the last quarter. Summarize the total MRR lost and list the top three most frequent reasons provided for cancellation."

### create_a_planhat_opportunity
Empowers your AI agent to act as a proactive pipeline generator. When support agents identify expansion potential, the LLM can immediately log a new upsell opportunity. This tool requires the `companyId` and accepts fields for `salesStage`, `mrr`, and `closeDate`.

> "Create a new Planhat opportunity for the company ID 'comp_112233'. Title it 'Q3 Enterprise Expansion', set the MRR to 1500 USD, and mark the sales stage as 'Discovery'."

### create_a_planhat_issue
Issues represent bugs, feature blocks, or technical escalations that are holding up account success. Creating an issue via this tool requires a `title` and optionally links to specific `companyIds` or `enduserIds` to track who is impacted by the defect.

> "Log a new issue in Planhat titled 'SSO Integration Failing on Safari'. Set the status to Open and associate it with company ID 'comp_445566'. Include a description of the error logs."

### get_single_planhat_enduser_by_id
While companies represent the account, endusers represent the human beings logging into the software. This tool pulls the specific details for a user, including their `lastActive` timestamp, email, engagement `relevance`, and role. Useful for health-checking specific champions.

> "Get the details for enduser ID 'usr_556677'. When was the last time this user was active, and what is their current experience metric?"

For the complete tool inventory, detailed JSON schemas, and parameter requirements, visit the [Planhat integration page](https://truto.one/integrations/detail/planhat).

## Workflows in Action

Exposing these tools allows ChatGPT to act as a fully autonomous Customer Success operations assistant. Here are two real-world workflows demonstrating how the LLM chains tools together to execute complex logic.

### Workflow 1: Proactive Churn Risk Triage
When CS leaders need to identify at-risk revenue, an AI agent can cross-reference recent churn data with active projects to highlight systemic implementation failures.

> "Analyze our recent churn data. Find the last 5 companies that churned. For each of those companies, check if they had an active onboarding project at the time of cancellation, and summarize the financial value lost."

**Tool Execution Sequence:**
1. **`list_all_planhat_churn`**: The agent pulls recent churn records, extracting the `companyId`, `value`, and `churnDate`.
2. **`list_all_planhat_projects`**: The agent queries projects, filtering by the extracted `companyId`s to see if any projects were open or recently abandoned.
3. **Result**: ChatGPT synthesizes the data, outputting a tactical summary: *"Three of the last five churned accounts (representing $4,500 MRR) canceled while still stuck in the 'Initial Implementation' project phase. I recommend reviewing the onboarding SLA for these specific cohorts."*

### Workflow 2: NPS Promoter Upsell Pipeline
Promoters provide the highest conversion rate for expansion revenue. If a user leaves a perfect Net Promoter Score, the agent can automatically flag the account for an upsell opportunity.

> "Check the latest NPS responses. If you find any scores of 9 or 10 from the past week, create a new 'Advocacy Upsell' opportunity for the associated company, with a target MRR of $500, assigned to the Discovery stage."

**Tool Execution Sequence:**
1. **`list_all_planhat_nps`**: The agent fetches recent NPS survey data and filters the payload locally for scores >= 9.
2. **`list_all_planhat_companies`**: The agent uses the `cId` (company ID) from the NPS record to fetch the company name and verify current MRR health.
3. **`create_a_planhat_opportunity`**: The agent constructs the payload and creates the pipeline record in Planhat, injecting the required `companyId`, the $500 `mrr` target, and the `salesStage`.
4. **Result**: The agent confirms: *"I found two Promoters (scores of 10). I have successfully created 'Advocacy Upsell' opportunities for both Acme Corp and Globex Inc in the Discovery stage."*

## Security and Access Control

Granting an LLM write-access to your source-of-truth CS platform requires strict governance. Truto's MCP architecture provides native security controls configured at the token level:

*   **Method Filtering**: You can strictly limit the MCP server to specific HTTP verbs. Setting `methods: ["read"]` ensures the LLM can only execute `get` and `list` operations, preventing it from accidentally deleting or updating company records.
*   **Tag Filtering**: If your Planhat integration uses `tool_tags`, you can restrict the server to specific operational domains. Passing `tags: ["support"]` ensures the LLM only sees tools related to Tickets and Issues, hiding sensitive financial endpoints like Churn or Invoices.
*   **Require API Token Auth**: By default, the cryptographically secure MCP URL acts as the sole authentication vector. By enabling `require_api_token_auth: true`, you force the client to also pass a valid Truto API token in the HTTP Authorization header, enabling secondary identity verification.
*   **Automated Expiration**: You can configure an `expires_at` timestamp. Truto's underlying durable alarm schedules will automatically invalidate the token and wipe the server configuration from our key-value stores at the exact second requested, ensuring temporary contractors or test agents cannot maintain persistent access.

## Stop Building Boilerplate

Connecting Planhat to ChatGPT transforms how your Customer Success organization operates. It turns static dashboards into conversational agents capable of resolving data discrepancies, managing complex onboarding projects, and tracking MRR fluctuations in real time.

Building a custom server requires constant schema maintenance, complex pagination handling, and continuous OAuth debugging. Using Truto's managed infrastructure allows your engineering team to generate secure, strictly governed MCP servers dynamically, entirely bypassing the integration maintenance cycle.

> Stop writing boilerplate integration code. Start generating secure MCP servers for Planhat and 100+ other SaaS APIs in seconds.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)