The Freshworks Model Context Protocol (MCP) server is designed to provide secure, controlled access for AI tools to interact with Freshservice. It acts as a middleware layer that exposes selected capabilities, such as ticket and asset management, through authenticated and permission-scoped API interactions.

The MCP server relies on Freshworks’ existing authentication and authorization mechanisms. It does not introduce a separate identity system and does not grant access beyond what the authenticated user or service account is already permitted to perform.

Info: For an overview of MCP integration, including setup and configuration steps, see the MCP integration article. 

TABLE OF CONTENTS

• Deployment and isolation
• Authentication
• Authorization and permissions
• Tool exposure and controls
• Data handling
• Logging and audit
• Input validation
• Network security
• Usage limits and safeguards
• Security considerations for AI integrations

Deployment and isolation

The Freshworks MCP server is deployed as a tenant-scoped endpoint within each Freshservice account (for example, https://<your-freshservice-domain>/mcp). Each tenant operates within its own logical boundary.

• Requests and tool executions are scoped to the tenant’s Freshservice environment.

• No cross-tenant data access is permitted.

• The MCP server provides a secure interface to Freshservice capabilities through the Model Context Protocol and enables controlled access to Freshservice APIs. It does not persist session or application state independently.

Authentication

Authentication is required for all MCP interactions and is enforced using supported Freshservice authentication methods.

Freshworks MCP supports the following authentication methods in Freshservice:

• OAuth 2.0 authentication
  Each request runs in the context of the signed-in user, inheriting their permissions and access scope.

• API key authentication
  Requests can be authenticated using API keys.

Authentication is validated before any tool execution. Unauthorized requests are rejected.

Authorization and permissions

The MCP server does not implement its own authorization layer. Instead, it enforces permissions through Freshservice’s existing role-based access controls.

• All actions are executed using the permissions of the authenticated identity.

• Only users with administrator or agent roles can access MCP capabilities.

• Tool execution is limited to actions already allowed via Freshservice APIs.

For example:

• A user without ticket edit permissions cannot update tickets via MCP.

• A service account can only perform operations allowed by its API key scope.

Tool exposure and controls

The MCP server exposes a predefined set of tools aligned with Freshservice capabilities, such as:

• Ticket management (create, update, fetch)

• Asset management

• Service catalog requests

• Knowledge base access

Tool usage is governed by:

• Plan-based limits (for example, rate limits and monthly quotas)

• Permission levels (Always allow, Needs approval, Blocked, or Custom)

• Client-side controls in supported AI tools

Data handling

The MCP server processes data in real time through Freshservice APIs.

• No independent data storage or caching is performed by the MCP server.

• Data returned is limited to what the authenticated identity is authorized to access.

• Sensitive operations (such as ticket updates) are executed directly against Freshservice instances.

The MCP server is designed to minimize data exposure by:

• Restricting responses to required fields

• Using authenticated API calls

• Avoiding unnecessary data persistence

Logging and audit

MCP interactions are traceable through Freshservice’s existing logging and audit systems.

• Actions performed via MCP are recorded similarly to API or UI actions.

• Changes (for example, ticket updates) appear in entity activity history.

• Authentication and request failures are logged for troubleshooting.

Sensitive information is handled according to Freshservice logging policies.

Input validation

All MCP tool inputs are validated before execution.

• Invalid or malformed requests are rejected.

• Structured error responses are returned to the client.

• Requests must conform to Freshservice API requirements.

This prevents unintended operations and ensures consistent system behavior.

Network security

All communication with the Freshservice MCP server is secured using HTTPS.

• Data is encrypted in transit using TLS.

• Requests are routed through Freshservice’s secure infrastructure.

• Authentication headers (OAuth tokens or API keys) are required for access.

Usage limits and safeguards

During the Early Access Program (EAP), MCP usage is governed by defined limits:

• Rate limits (tool calls per minute)

• Monthly usage quotas

• Plan restrictions (Enterprise only)

These limits help ensure system stability and prevent abuse.

Security considerations for AI integrations

When integrating AI tools with the Freshservice MCP server:

• Prefer OAuth 2.0 over API keys for improved security.

• Monitor usage and audit logs regularly.

• Ensure API keys are stored securely and rotated periodically.