Connect ConnectWise PSA to Claude: Sync Sales and Billing Operations

If you need to connect ConnectWise PSA to Claude to automate your managed service provider (MSP) helpdesk, ticket triage, or billing reconciliation, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and the ConnectWise REST API. 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 connecting ConnectWise PSA to ChatGPT or explore our broader architectural overview on connecting ConnectWise PSA to AI Agents.

Giving a Large Language Model (LLM) read and write access to a sprawling enterprise ecosystem like ConnectWise PSA is an engineering challenge. You have to handle rigid ITIL-based data hierarchies, map massive JSON schemas to MCP tool definitions, and deal with ConnectWise's strict API pagination. Every time ConnectWise updates an endpoint or changes a required field, 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 ConnectWise PSA, connect it natively to Claude, and execute complex MSP workflows using natural language.

The Engineering Reality of the ConnectWise PSA API

A custom MCP server is a self-hosted integration layer that translates an LLM's tool calls into REST API requests. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against the ConnectWise PSA API is painful.

ConnectWise is built for complex IT service management. It does not behave like a simple SaaS CRUD app. If you decide to build a custom MCP server for ConnectWise PSA, you own the entire API lifecycle. Here are the specific challenges you will face:

The Board, Type, SubType, and Item Hierarchy ConnectWise enforces a strict taxonomy for tickets. You cannot just create a ticket with a generic string. You must map it to a specific board, assign a type, define a subType, and optionally an item. If you expose the raw ConnectWise REST endpoints to Claude, the LLM will frequently hallucinate these taxonomy IDs, resulting in API rejection. A managed MCP layer needs to expose these hierarchies clearly so the model can query available boards and types before attempting a write operation.

Massive Object Graphs and Field Counts The ConnectWise PSA API returns massive, deeply nested JSON objects. A single ticket or opportunity record can contain over 100 fields, including nested references to companies, contacts, SLAs, and billing terms. Pushing these raw, unfiltered payloads into Claude's context window will rapidly consume tokens and degrade reasoning. You need an architecture that normalizes query schemas and strips out redundant null values before handing the payload back to the LLM.

Rate Limits and 429 Handling ConnectWise enforces strict API request limits based on your deployment tier and partner configuration. When an upstream API like ConnectWise returns an HTTP 429 Too Many Requests, Truto does not retry, throttle, or apply backoff on rate limit errors. Instead, Truto passes that error directly to the caller (your AI agent). However, Truto normalizes the upstream rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The caller is responsible for implementing its own retry and exponential backoff logic based on these headers.

How to Generate a ConnectWise PSA MCP Server

Truto dynamically generates MCP tools based on the existing ConnectWise PSA integration documentation and API schema. This means your MCP server is always up-to-date with the latest ConnectWise API specifications. A tool only appears in the MCP server if it has a corresponding schema definition, which acts as a quality gate ensuring Claude only accesses well-documented endpoints.

You can generate your ConnectWise PSA MCP server in two ways: through the Truto dashboard or programmatically via the API.

Method 1: Via the Truto UI

If you prefer a visual setup, generating an MCP server takes less than a minute:

1. Log into your Truto environment and navigate to the Integrated Accounts page.
2. Select your connected ConnectWise PSA instance.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Configure your server settings. You can restrict the server to specific methods (e.g., read only) or filter tools by tags (e.g., tickets, billing).
6. Click Save and copy the generated MCP server URL.

Method 2: Via the Truto API

For platform engineers building multi-tenant AI products, you can generate MCP servers programmatically. When you make a POST request to /integrated-account/:id/mcp, Truto validates the configuration, generates a secure cryptographically hashed token, stores it in edge storage, and returns a ready-to-use URL.

// Example: Generating a ConnectWise PSA MCP Server via API
const response = await fetch('https://api.truto.one/integrated-account/cw_psa_123abc/mcp', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_TRUTO_API_TOKEN',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "Claude PSA Operations",
    config: {
      methods: ["read", "write"] // Allow both reading and writing
    },
    expires_at: null // Permanent server
  })
});
 
const mcpServer = await response.json();
console.log(mcpServer.url); 
// Output: https://api.truto.one/mcp/a1b2c3d4e5f6...

Connecting the MCP Server to Claude

Once you have your Truto MCP Server URL, connecting it to Claude requires no extra middleware. Truto's endpoint natively handles the JSON-RPC 2.0 protocol.

Method 1: Via the Claude UI

If you are using the Claude desktop or web application, connecting a custom MCP server is straightforward:

1. Open Claude and navigate to Settings.
2. Click on Integrations (or Connectors depending on your plan tier).
3. Select Add MCP Server or Add custom connector.
4. Paste the Truto MCP URL generated in the previous step.
5. Click Add. Claude will immediately perform a handshake with the Truto server, retrieve the list of available ConnectWise tools, and make them available in your chat interface.

Method 2: Via Manual Configuration File

If you are running Claude Desktop locally and prefer file-based configuration, you can add the server using your claude_desktop_config.json file. Since Truto provides a managed SSE (Server-Sent Events) endpoint, you use the standard @modelcontextprotocol/server-sse proxy to connect.

Open your configuration file (typically located at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS or %APPDATA%\Claude\claude_desktop_config.json on Windows) and add:

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

Restart Claude Desktop. The application will initialize the MCP handshake and load the ConnectWise toolset.

Hero Tools for ConnectWise Operations

When your MCP server initializes, Truto transforms the ConnectWise API into distinct, descriptive tools. Truto handles the complex flat-namespace mapping, meaning Claude passes a single object of arguments, and Truto intelligently splits them into the correct query parameters and body payloads required by ConnectWise.

Here are some of the highest-leverage tools available for your agent:

list_all_connect_wise_psa_tickets

This tool allows Claude to retrieve, filter, and paginate through service tickets. Because Truto normalizes pagination into standard limit and next_cursor parameters, Claude can seamlessly iterate through hundreds of open tickets without hallucinating offset integers or skip tokens.

"Claude, pull a list of all open tickets on the 'Network Infrastructure' board. Show me their current status and who they are assigned to."

create_a_connect_wise_psa_ticket

This tool translates natural language into a structured ConnectWise ticket. It requires specific references to company IDs, boards, and SLA priorities.

"Claude, create a new high-priority ticket for the client 'Acme Corp'. The summary should be 'Primary firewall down in London office' and place it on the 'Emergency Escalations' board."

list_all_connect_wise_psa_ticket_notes

Notes in ConnectWise are distinct entities attached to tickets. This tool allows Claude to read the historical context of a ticket, distinguishing between internal analysis, resolution text, and customer-facing communication.

"Claude, fetch all the internal notes for ticket #40592. Summarize the troubleshooting steps the L1 tech took before they escalated it."

create_a_connect_wise_psa_ticket_note

Allows Claude to update ticket records. This is vital for AI triage agents that need to log their findings or draft customer responses directly into the PSA system.

"Claude, add an internal note to ticket #40592 stating that you have reviewed the firewall logs and found no unauthorized access attempts. Flag it as an internal analysis note."

list_all_connect_wise_psa_sales_opportunities

ConnectWise PSA isn't just for ticketing; it handles CRM and sales operations. This tool gives Claude visibility into the sales pipeline, allowing it to aggregate expected revenue or check deal stages.

"Claude, list all active sales opportunities assigned to John Doe that are in the 'Proposal Sent' stage. What is the total projected revenue?"

create_a_connect_wise_psa_time_entry

Automating time entries is the holy grail of MSP operations. This tool allows Claude to parse natural language summaries of work done and translate them into structured, billable time entries tied to specific tickets, agreements, or charge codes.

"Claude, create a time entry for myself on ticket #40592. I worked from 2 PM to 3:30 PM today performing firewall diagnostics. Mark it as billable time."

To view the complete schema definitions and the full list of available endpoints, visit the ConnectWise PSA integration page.

Workflows in Action

Connecting ConnectWise to Claude unlocks agentic automation. Instead of executing isolated API calls, Claude can string multiple tools together to resolve complex, multi-step MSP operations.

Workflow 1: L1 Triage and Intelligent Escalation

When a vague alert or user email generates a ticket, an AI agent can perform initial triage, gather context, and route the ticket accurately before a human engineer even looks at it.

The Prompt:

"Claude, check the 'Triage' board for any new tickets created in the last hour. If you find a ticket related to server performance, look up the client's past tickets to see if this is a recurring issue. Then, move the ticket to the 'Server Team' board, assign it a priority based on the client's history, and add an internal note summarizing your findings."

The Execution Flow:

sequenceDiagram
    participant User as User / Prompt
    participant Agent as Claude
    participant Truto as Truto MCP Server
    participant Upstream as "Upstream API (ConnectWise PSA)"

    User->>Agent: Triage new server tickets
    Agent->>Truto: Call tool: list_all_connect_wise_psa_tickets (board="Triage")
    Truto->>Upstream: GET /service/tickets?conditions=board/name="Triage"
    Upstream-->>Truto: Return Ticket #5012 "Server running slow"
    Truto-->>Agent: Ticket #5012 data
    
    Agent->>Truto: Call tool: list_all_connect_wise_psa_tickets (companyId=123, summary contains "server")
    Truto->>Upstream: GET /service/tickets?conditions=company/id=123 AND summary like "server"
    Upstream-->>Truto: Return past server tickets
    Truto-->>Agent: Historical ticket data

    Agent->>Truto: Call tool: update_a_connect_wise_psa_ticket_by_id (id=5012, board="Server Team", priority="High")
    Truto->>Upstream: PATCH /service/tickets/5012
    Upstream-->>Truto: 200 OK
    Truto-->>Agent: Success

    Agent->>Truto: Call tool: create_a_connect_wise_psa_ticket_note (ticketId=5012, text="Found 3 similar incidents...")
    Truto->>Upstream: POST /service/tickets/5012/notes
    Upstream-->>Truto: 201 Created
    Truto-->>Agent: Success
    Agent-->>User: Ticket routed to Server Team with context note.

What happens:

1. Claude calls list_all_connect_wise_psa_tickets to find new tickets on the specified board.
2. Claude identifies a performance ticket and calls the list tool again, filtering by the company ID to establish historical context.
3. Claude uses update_a_connect_wise_psa_ticket_by_id to route the ticket to the correct board and elevate the priority.
4. Claude calls create_a_connect_wise_psa_ticket_note to append an internal analysis note detailing the historical pattern.

Workflow 2: Time Audit and Incomplete Billing Report

MSP profitability relies on accurate time tracking. Claude can be used by Service Managers to audit incomplete time entries and summarize discrepancies before generating invoices.

The Prompt:

"Claude, pull all time entries logged by the engineering team yesterday. Find any entries that are marked as 'Billable' but have less than 50 characters in their notes field. Generate a summary of these incomplete entries so I can follow up with the techs."

The Execution Flow:

1. Claude calls list_all_connect_wise_psa_time_entries passing a date filter for yesterday.
2. Claude receives the payload and locally analyzes the text length of the notes field for every returned time entry.
3. Claude filters down the array to only those entries marked as billableOption: "Billable" with insufficiently detailed notes.
4. Claude outputs a structured summary to the user detailing the technician name, ticket number, and recorded time for each offending entry.

Security and Access Control

When giving AI agents access to your core business systems, strict governance is non-negotiable. Truto provides four distinct security layers for managed MCP servers:

• Method Filtering: Limit an MCP server to strictly non-destructive operations by configuring it to methods: ["read"]. This restricts the AI agent to get and list operations, preventing it from accidentally deleting or modifying ConnectWise records.
• Tag Filtering: Limit the blast radius of your AI agent by scoping the server to specific functional domains. Setting tags: ["support"] ensures the agent only has access to ticket and service board tools, keeping it locked out of finance, billing, or sales opportunity endpoints.
• Expiration (TTL): Issue short-lived MCP servers by setting an expires_at timestamp. This triggers an event-driven cleanup that completely wipes the server credentials and edge storage records when the time expires—perfect for contractor access or temporary AI audit tasks.
• Secondary Authentication: By enabling require_api_token_auth: true, possession of the MCP URL alone is insufficient. The calling client must pass a valid Truto API token, providing a second layer of identity verification.

Next Steps

Connecting ConnectWise PSA to Claude via a managed MCP server removes the massive overhead of integrating with legacy ITIL APIs. Instead of spending weeks wrestling with massive object schemas, erratic pagination, and OAuth state management, you can deploy AI agents into your MSP environment in minutes.

By offloading the infrastructure boilerplate to Truto, your engineering team can focus on what actually matters: designing intelligent AI workflows that automate your ticket resolution, optimize your billing, and scale your MSP operations.