Connect Freshservice to ChatGPT: Manage Tickets, Assets and Solutions

If you need to connect Freshservice to ChatGPT to automate IT helpdesk operations, manage hardware assets, or orchestrate complex employee onboarding workflows, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and Freshservice's REST APIs. You can either build and maintain this infrastructure entirely in-house, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

If your team uses Claude instead, check out our guide on connecting Freshservice to Claude or explore our broader architectural overview on connecting Freshservice to AI Agents.

Giving a Large Language Model (LLM) read and write access to a sprawling IT Service Management (ITSM) ecosystem like Freshservice is a significant engineering challenge. You have to handle OAuth token lifecycles, map massive JSON schemas for tickets and custom objects, and deal with Freshservice's strict API constraints. Every time Freshservice updates an endpoint or adds a new 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 Freshservice, connect it natively to ChatGPT, and execute complex support workflows using natural language.

The Engineering Reality of the Freshservice 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 Freshservice's specific APIs is painful. You aren't just doing simple CRUD operations - you are dealing with relational ITSM data, strict governance rules, and complex nested objects.

If you decide to build a custom MCP server for Freshservice, you own the entire API lifecycle. Here are the specific integration challenges that break standard REST assumptions when working with Freshservice:

Strict Rate Limiting and the 429 Reality Freshservice enforces aggressive minute-based rate limits. Depending on your customer's pricing tier, this could be as low as 100 requests per minute. If your AI agent gets stuck in a loop trying to summarize hundreds of ticket conversations, Freshservice will reject the requests with an HTTP 429 Too Many Requests error.

It is critical to understand that Truto does not magically absorb, retry, or throttle rate limit errors. When the upstream Freshservice API returns a 429, 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 caller (your LLM or AI agent framework) is entirely responsible for reading these headers and implementing exponential backoff. This is a common hurdle when how to handle long-running SaaS API tasks in AI agent tool-calling workflows where reliability is paramount. If you fail to write backoff logic on the client side, the LLM will assume the tool call succeeded and confidently hallucinate the result.

Custom Objects and Dynamic Schemas IT teams heavily customize Freshservice. A "Ticket" in one organization might have 5 custom fields, while in another it has 50 nested dropdowns tracking specific hardware variants. Hardcoding JSON schemas for the MCP server will fail the moment a customer adds a new mandatory field. Your MCP server must dynamically fetch the Freshservice metadata, parse the custom fields, and inject them into the JSON schemas provided to the LLM. If a required custom field is missing from your schema, the LLM will fail to create the ticket.

Complex Asset Relationships Asset management in Freshservice is not a flat table. Assets have upstream and downstream relationships (e.g., a server runs specific software, and a user is assigned to that server). If an AI agent attempts to retire an asset, it must traverse and potentially reassign these relationships. Providing raw API access to the LLM without properly defining these relationship constraints in the tool descriptions will result in orphaned database records.

The Managed MCP Approach

Instead of forcing your engineering team to build boilerplate routing, schema generation, and token management, Truto acts as the infrastructure layer to bring custom connectors to ChatGPT without manual maintenance.

Truto's MCP servers turn any connected Freshservice account into an MCP-compatible tool server. The key design insight is that tool generation is dynamic and documentation-driven. Rather than hand-coding tool definitions, Truto derives them automatically from the integration's resource definitions and schema documentation.

When a customer connects their Freshservice account, Truto generates a unique, cryptographically secure MCP server URL. This URL is scoped strictly to that single tenant's account. The URL alone contains the routing token required to authenticate and serve tools, meaning no additional configuration is needed on the client side. When the LLM calls a tool, Truto delegates the execution to its proxy API handlers, directly calling the Freshservice API on your behalf.

How to Generate the Freshservice MCP Server

You can generate the MCP server URL either manually through the Truto dashboard or programmatically via the REST API. Both methods result in a secure endpoint that exposes Freshservice tools to your LLM.

Method 1: Via the Truto UI

For internal workflows or one-off testing, the UI is the fastest path.

1. Navigate to the Integrated Accounts page in your Truto dashboard.
2. Select the connected Freshservice account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Configure your constraints (e.g., name, method filters like read, or expiration dates).
6. Click Save and copy the generated MCP server URL.

Method 2: Via the Truto API

For production applications, you will want to generate this URL programmatically so you can inject it directly into the LLM context of your end users.

Make an authenticated POST request to the Truto API. This validates that the integration has tools available, generates a secure token backed by scalable KV storage, and returns a ready-to-use URL.

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Freshservice IT Support Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["tickets", "assets"]
    }
  }'

The response will contain the secure URL you need to pass to ChatGPT:

{
  "id": "mcp_abc123xyz",
  "name": "Freshservice IT Support Agent",
  "config": {
    "methods": ["read", "write"],
    "tags": ["tickets", "assets"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}

How to Connect the MCP Server to ChatGPT

Once you have the Truto MCP server URL, connecting it to ChatGPT takes seconds. You can do this via the ChatGPT application UI or via standard MCP configuration files for custom agent setups.

Method A: Via the ChatGPT / Claude UI

If you are using the ChatGPT desktop application (Pro, Plus, Enterprise, or Education):

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: "Freshservice IT Agent"
5. Server URL: Paste the https://api.truto.one/mcp/... URL generated in the previous step.
6. Click Save.

(Note: If you are using Claude Desktop, navigate to Settings → Integrations → Add MCP Server, paste the URL, and click Add).

ChatGPT will immediately ping the server, complete the JSON-RPC 2.0 handshake, and load all the Freshservice tools into its context window.

Method B: Via Manual Config File (SSE Transport)

If you are building a headless application or running a local agent framework (like LangChain or Cursor) that relies on standard MCP configuration files, you can connect using the Server-Sent Events (SSE) transport wrapper.

Add the following to your mcp_config.json:

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

Restart your agent framework, and the Freshservice tools will be instantly available.

Hero Tools for Freshservice

Truto dynamically generates over a hundred specific tools for Freshservice based on the API schema. Exposing all of them is unnecessary and consumes LLM context. Here are 6 high-leverage "hero tools" you should focus on for IT and asset automation.

list_all_freshservice_tickets

Retrieves a paginated list of tickets in the Freshservice workspace. This tool accepts URL-encoded filter queries, making it ideal for the LLM to search for open tickets, high-priority incidents, or tickets assigned to a specific agent.

"Find all high-priority tickets created in the last 24 hours that are currently unassigned."

get_single_freshservice_ticket_by_id

Fetches the complete payload of a specific ticket, including subject, description, priority, requester details, and custom fields. The LLM uses this to gain full context before attempting to formulate a reply or change the ticket status.

"Get the full details and custom fields for ticket #INC-8492 so I can draft a resolution summary."

update_a_freshservice_ticket_by_id

Modifies an existing ticket. This is the primary write tool for helpdesk agents, allowing the LLM to change the status to "Resolved", reassign the ticket to an L2 agent group, or update custom fields based on diagnostic data.

"Update ticket #INC-8492. Change the status to 'Pending', escalate the priority to 'High', and assign it to the network engineering group."

list_all_freshservice_assets

Searches the hardware and software asset inventory. This tool returns detailed metadata including asset tags, IP addresses, serial numbers, and current assignment states. It is critical for onboarding and device troubleshooting workflows.

"Search the asset database for any available MacBook Pro M3 laptops that are currently unassigned and located in the New York office."

freshservice_solution_article_search

Queries the Freshservice Knowledge Base (KB) for solution articles. When a user submits a routine "how-to" question, the LLM uses this tool to find the official company documentation to use as context for its response.

"Search the knowledge base for articles related to setting up the VPN on an Android device, and summarize the steps for me."

create_a_freshservice_onboarding_request

Triggers the complex employee onboarding flow in Freshservice. This endpoint creates a parent request and can automatically spin up child tickets for hardware provisioning, software access, and HR orientation based on the provided fields.

"Create a new onboarding request for John Doe starting next Monday in the Engineering department. Ensure he is provisioned a laptop and access to AWS."

Note: This is only a curated selection of capabilities. For the complete list of available operations, schemas, and custom methods, refer to the Freshservice integration page.

Workflows in Action

Once the tools are loaded into ChatGPT, the LLM can chain them together to solve multi-step problems autonomously. Here are two real-world examples of what this looks like.

Workflow 1: L1 Helpdesk Triage & KB Suggestion

IT teams waste hours repeatedly answering the same password reset and VPN configuration questions. You can instruct ChatGPT to act as a triage agent that intercepts tickets, searches the KB, and drafts a reply.

User Prompt: "Check the queue for any new open tickets. If you find a ticket asking about VPN setup, search the knowledge base for the solution, draft a reply to the user, and change the ticket status to 'Pending User Response'."

Execution Sequence:

1. ChatGPT calls list_all_freshservice_tickets with a query filter for status=open.
2. It identifies a matching ticket and reads the subject/description.
3. ChatGPT calls freshservice_solution_article_search with the term "VPN setup".
4. It reads the article contents and formats a helpful response.
5. ChatGPT calls update_a_freshservice_ticket_by_id to post the note to the user and change the ticket status.

Outcome: The LLM resolves the user's issue instantly using official company documentation, moving the ticket out of the queue without human intervention.

Workflow 2: Employee Onboarding & Hardware Provisioning

Onboarding requires coordinating across HR, IT, and procurement. ChatGPT can streamline this by instantly executing the required lookups and requests.

User Prompt: "We have a new engineering hire starting on Monday. Check our asset inventory for an available M3 laptop. If one is available, create the onboarding request in Freshservice and assign that specific asset tag to the request."

Execution Sequence:

1. ChatGPT calls list_all_freshservice_assets filtering for name="M3" and usage_type="available".
2. It extracts the asset_tag and id from the response.
3. ChatGPT calls create_a_freshservice_onboarding_request, filling out the required employee fields and injecting the chosen asset_tag into the hardware provisioning section of the payload.

Outcome: The IT team is immediately notified with a fully populated onboarding request, and the specific piece of hardware is already allocated, removing the manual lookup step.

Security and Access Control

Giving an AI agent access to your entire IT infrastructure is risky. Truto provides strict boundary controls at the infrastructure level when generating the MCP server, preventing the LLM from executing destructive actions.

• Method Filtering (methods): Restrict the server to specific operation types. By configuring methods: ["read"], you guarantee the LLM can only execute get and list operations, physically preventing it from creating, updating, or deleting tickets and assets.
• Tag Filtering (tags): Scope the server by functional area. If you only want the AI to manage knowledge base articles, apply a tags: ["solutions"] filter. The server will silently drop all tools related to tickets, users, and problems.
• Mandatory API Authentication (require_api_token_auth): By default, possessing the MCP URL is enough to connect. Enabling this flag adds a second security layer, requiring the client to pass a valid Truto API token in the Authorization header. This prevents unauthorized execution if the URL is leaked in logs.
• Time-To-Live (expires_at): Generate short-lived MCP servers for contractors or temporary AI workflows. Once the ISO datetime is reached, Truto's edge network automatically shreds the token and drops all connections.

Strategic Wrap-up

Automating Freshservice workflows with an LLM transforms IT operations from reactive ticket punching into proactive system management. But building the underlying infrastructure to support this - parsing custom ITSM objects, managing strict rate limits, and securing tool execution - is a massive engineering distraction.

By leveraging Truto to generate a managed MCP server, you eliminate the integration boilerplate. Your engineers can focus on crafting the perfect AI agent prompts and workflow logic, while Truto handles the schema translation, protocol handshakes, and API routing dynamically.