Connect Freshservice to Claude: Automate Changes, Projects and Tasks

If you need to connect Freshservice to Claude to automate ITSM changes, track IT projects, or orchestrate employee onboarding, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's natural language tool calls and Freshservice's complex ITIL-based 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 OpenAI, check out our guide on connecting Freshservice to ChatGPT or explore our broader architectural overview on connecting Freshservice to AI Agents.

Giving a Large Language Model (LLM) read and write access to an enterprise service desk like Freshservice is a massive engineering challenge. You are not just integrating a simple ticketing system. You are interfacing with interconnected modules—Changes, Problems, Releases, Assets, and Projects—each with unique required fields, nested custom schemas, and specific routing rules. Every time Freshservice updates an endpoint or deprecates a 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 Freshservice, connect it natively to Claude Desktop, and execute complex ITSM workflows using natural language.

The Engineering Reality of the Freshservice API

A custom MCP server is a self-hosted integration layer that translates an LLM's JSON-RPC 2.0 messages into HTTP requests. While the open MCP standard provides a predictable way for models to discover tools, implementing it against Freshservice's API is notoriously difficult for a few specific reasons.

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

Complex ITIL Data Relationships Freshservice adheres to strict ITIL processes. A Change request isn't a standalone object; it is inextricably linked to Assets (CIs), Impacted Services, Maintenance Windows, and Approval Groups. When an LLM attempts to create a Change via a custom tool, it often hallucinates or misformats these nested arrays. Truto's MCP server parses Freshservice's documentation records to derive explicit, enhanced JSON schemas for query and body parameters. This gives Claude the exact structural map it needs to construct valid payloads.

Flat Input Namespaces vs Nested Bodies When an MCP client calls a tool, all arguments arrive as a single flat object. The Freshservice API, however, frequently requires a mix of URL path parameters, query strings, and deeply nested request bodies. Truto handles this translation natively. By evaluating the generated query and body schemas simultaneously, the MCP router routes parameters exactly where Freshservice expects them to be, without requiring the LLM to understand HTTP semantics.

Multi-Workspace Complexity If you are integrating with Freshservice in Managed Service Provider (MSP) mode or Employee Support Mode, nearly every API call requires context about the workspace_id. If an LLM forgets to pass a workspace_id, or passes workspace_id=1 (the Global workspace, which rejects many create operations), the API will throw generic 400 errors. Truto's dynamically generated tools can be pre-filtered using tags and methods to ensure models only execute actions within permitted workspace scopes.

Aggressive Rate Limiting Freshservice enforces stringent rate limits based on your plan tier (e.g., 100 to 5000 requests per minute). If your AI agent gets stuck in a loop querying hundreds of assets or iterating over paged project tasks, you will hit these walls quickly.

Crucial factual note: Truto does not retry, throttle, or apply backoff on rate limit errors. When the Freshservice API returns an HTTP 429 Too Many Requests, Truto passes that error directly back to the caller. However, Truto normalizes the upstream rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The MCP client or agent framework is entirely responsible for reading these headers and implementing exponential backoff.

Instead of building this complex routing, schema management, and proxy infrastructure from scratch, you can use Truto to expose Freshservice endpoints as ready-to-use MCP tools.

How to Generate a Freshservice MCP Server with Truto

Truto dynamically generates MCP tools based on documentation records acting as quality gates. Only well-documented endpoints are exposed to the LLM, ensuring high-fidelity tool execution. These servers are backed by edge key-value storage and relational databases, ensuring sub-millisecond authentication routing.

You can generate an MCP server URL either through the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

For ad-hoc agent setups or internal IT automation, the UI is the fastest path.

1. Navigate to the integrated account page for your Freshservice connection in the Truto dashboard.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Configure the server (name, allowed methods like read or write, and specific tool tags like projects or changes).
5. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the Truto API

If you are building a multi-tenant AI product and need to provision Freshservice MCP servers dynamically for your customers, use the REST API. This creates the token, stores the salted hash in edge key-value storage, and returns the endpoint.

Endpoint: POST /integrated-account/:id/mcp

const response = await fetch('https://api.truto.one/integrated-account/<freshservice_account_id>/mcp', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <YOUR_TRUTO_API_KEY>',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "Freshservice Change Management Server",
    config: {
      methods: ["read", "write"], // Restrict to CRUD operations
      tags: ["changes", "projects", "assets"] // Only expose these modules
    },
    expires_at: "2026-12-31T23:59:59Z"
  })
});
 
const data = await response.json();
console.log(data.url); // Pass this URL to your MCP client

This URL is fully self-contained. It encodes the tenant context, the authentication state, and the method/tag filters. You do not need to deal with OAuth refresh tokens in your agent code.

How to Connect the MCP Server to Claude

Once you have the Truto MCP URL, connecting it to an AI model takes less than a minute.

Method A: Via the Claude UI (Desktop or Web)

Anthropic natively supports remote MCP servers. (If you are using OpenAI, you can do the exact same thing in ChatGPT by navigating to Settings → Apps → Advanced settings → Enable Developer mode → Add Custom Connector).

1. Open Claude and navigate to Settings → Integrations (or Connectors, depending on the version).
2. Click Add MCP Server.
3. Paste the URL you generated from Truto (https://api.truto.one/mcp/...).
4. Click Add.

Claude will immediately execute an initialize JSON-RPC handshake followed by a tools/list request. Truto will dynamically derive the tool definitions and return them to the model.

Method B: Via Manual Config File

If you are running Claude Desktop and prefer managing your integrations via code, or if you are using an agent framework like Cursor, you can update your MCP configuration file directly. Since Truto provides a remote SSE (Server-Sent Events) endpoint, you use the official MCP SSE transport utility.

Edit your claude_desktop_config.json file:

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

Restart Claude Desktop. The model now has full, filtered access to the Freshservice API.

Hero Tools for Freshservice

Truto maps hundreds of Freshservice endpoints to discrete MCP tools. Below are 6 of the most powerful hero tools for automating ITSM and project workflows.

1. List All Freshservice Changes (list_all_freshservice_changes)

Retrieves a filtered list of IT changes. This is critical for Change Advisory Board (CAB) reviews or incident impact analysis. It returns priority, impact, risk, approval status, and planned start/end dates.

"Find all 'Pending Approval' change requests scheduled for this weekend. Summarize their risk levels and list the impacted services for each."

2. Update a Freshservice Change (update_a_freshservice_change_by_id)

Allows the LLM to transition a change request through its lifecycle. It can update the status, modify the planned_start_date, or adjust the risk profile based on external factors (like a Datadog alert).

"Update Change Request CHG-1042. Set the status to 'Approved' and update the description to note that the CAB reviewed and cleared the database migration plan."

3. Create a Freshservice Project Task (create_a_freshservice_project_task)

Freshservice includes a robust Project Management module. This tool allows the AI to break down complex IT projects into actionable tasks, assign them to agents, and set due dates.

"Create a new project task under Project ID 44. Title it 'Provision new AWS subnets for staging'. Set the priority to High, due date to Friday, and assign it to agent ID 190."

4. List All Freshservice Assets (list_all_freshservice_assets)

Fetches Configuration Items (CIs) and IT assets. It supports deep filtering via asset_tag, mac_addresses, or user_id. This is heavily used during incident triage to identify affected hardware.

"Look up the asset details for the MacBook Pro assigned to john.doe@example.com. Tell me its warranty expiration date and its current IP address."

5. Create a Freshservice Onboarding Request (create_a_freshservice_onboarding_request)

Automates the employee onboarding process by triggering predefined HR/IT service requests. The LLM can pass nested fields containing the new hire's department, reporting manager, and required hardware.

"Create an onboarding request for Sarah Jenkins. She is joining the Engineering department as a Senior Developer on October 1st. Request a standard developer laptop and access to the GitHub enterprise organization."

6. Filter Freshservice Tickets (freshservice_tickets_filter)

Executes advanced URL-encoded queries against the Freshservice ticket database. Instead of pulling all tickets, the LLM can precisely target subsets of data, significantly saving context window tokens.

"Filter tickets to find all unresolved incidents assigned to the 'Network Infrastructure' group created in the last 24 hours. Summarize the common symptoms."

(Note: This is just a fraction of the available capabilities. For the complete inventory of Freshservice tools, including CAB management, Problem Management, and Software License tracking, view the Freshservice integration page.)

Workflows in Action

Here is how AI agents utilize these tools to execute complex, multi-step operations that traditionally require a human to click through dozens of Freshservice UI screens.

Scenario 1: Emergency CAB Preparation and Impact Analysis

An IT Operations Manager needs to prepare an emergency Change Advisory Board (CAB) report for an upcoming database failover.

"Find the emergency change request for the 'Primary Database Failover' scheduled for tonight. Identify all impacted assets linked to that change. Then, search for any open high-priority incidents currently reported against those specific assets. Summarize the risk of proceeding with the change."

Step-by-step execution:

1. Claude calls freshservice_changes_filter (or list_all_freshservice_changes with query params) to locate the specific emergency change record.
2. Claude extracts the impacted_services and assets arrays from the change response.
3. Claude iterates through the assets, calling get_single_freshservice_asset_by_id to gather specific hardware/software context.
4. Claude calls freshservice_tickets_filter using the discovered asset IDs to find unresolved, high-priority incidents linked to the database hardware.
5. The model synthesizes the data and outputs a comprehensive risk summary for the CAB.

Scenario 2: Zero-Touch Employee Project Provisioning

An HR administrator finalizes a new hire and wants the IT project management system to automatically build out the deployment tasks.

"I just hired a new remote designer, Alex. Create a Freshservice Onboarding request for him starting next Monday. Then, go to the 'Q4 Hardware Deployments' project and create three tasks: 1. Ship MacBook Pro to Alex, 2. Provision Adobe Creative Cloud license, 3. Schedule 15-minute IT orientation. Assign all tasks to the IT Support group."

Step-by-step execution:

1. Claude calls create_a_freshservice_onboarding_request, passing Alex's details and start date.
2. Claude calls list_all_freshservice_projects to find the ID for "Q4 Hardware Deployments".
3. Claude executes create_a_freshservice_project_task three separate times, linking each task to the identified project ID, setting descriptions, and assigning the correct group ID.
4. The agent reports back that the onboarding request and all subsequent tracking tasks are live in the system.

Security and Access Control

When exposing an ITSM platform to an autonomous AI agent, security boundaries are non-negotiable. Truto's MCP servers provide granular controls to restrict what the LLM can do.

• Method Filtering: You can enforce read-only access. Setting config.methods: ["read"] ensures the server only exposes list and get operations, completely preventing the model from creating tickets, altering changes, or deleting assets.
• Tag Filtering: You can scope the server to specific modules. Setting config.tags: ["projects"] limits the LLM to project management endpoints, shielding sensitive HR onboarding or CAB data from the agent.
• Require API Token Auth: By default, possessing the MCP URL grants access. By setting require_api_token_auth: true, the MCP client must additionally pass a valid Truto API token in the Authorization header. This prevents unauthorized execution even if the URL leaks in application logs.
• Expiring Servers: For temporary auditing tasks or contractor access, you can set expires_at. The server relies on edge scheduled alarms to aggressively clean up and invalidate the token once the timestamp is passed, leaving no stale credentials.

Rethinking IT Automation

Connecting Freshservice to Claude transforms your service desk from a reactive database into an active participant in your IT operations. Instead of forcing engineers to manually cross-reference change requests with asset inventories and project tasks, you can deploy AI agents to handle the orchestration instantly.

By routing this through a managed MCP server, you offload the massive burden of ITIL schema normalization, rate limit header translation, and authentication state management. You simply provide the LLM with the URL, and it gains the context it needs to resolve issues, manage projects, and orchestrate changes at scale.