Freshdesk Automation MCP Server

Create a powerful Model Context Protocol (MCP) server for Freshdesk Automation in minutes with our AI Gateway. This guide walks you through setting up comprehensive helpdesk automation with workflow rules, triggers, and instant API authentication.

About Freshdesk Automation API

Freshdesk Automation API enables programmatic management of automation rules, triggers, and workflows. This API allows you to create intelligent automation that streamlines support operations, enforces SLAs, and ensures consistent ticket handling.

Key Capabilities

• Automation Rules: Event-based actions, conditions, time-based triggers
• Dispatcher Rules: Ticket routing, assignment logic, load balancing
• Observer Rules: Monitoring, notifications, escalations
• Time Triggers: Scheduled actions, SLA enforcement, reminders
• Scenario Automation: Multi-condition workflows, complex logic
• Business Hours: Time-based rules, holiday handling
• Round Robin: Automatic assignment, fair distribution
• Skills-based Routing: Match agent expertise to tickets

API Features

• RESTful API: Standard REST endpoints
• API Key Auth: Simple authentication
• Bulk Operations: Mass rule updates
• Rule Templates: Reusable patterns
• Testing Mode: Validate before activation
• Audit Trail: Track rule changes
• Performance Metrics: Rule effectiveness
• Rate Limiting: 1000 requests/hour

What You Can Do with Freshdesk Automation MCP Server

The MCP server transforms Freshdesk Automation API into a natural language interface, enabling AI agents to:

Automation Rules

• Rule Creation

  • "Create rule to assign VIP tickets to senior agents"
  • "Auto-escalate tickets after 2 hours"
  • "Set priority based on customer tier"
  • "Auto-respond to common questions"

• Rule Management

  • "List all active automation rules"
  • "Disable rules during holidays"
  • "Clone successful rule templates"
  • "Update rule conditions"

• Rule Conditions

  • "When ticket contains 'urgent'"
  • "If customer is enterprise tier"
  • "When agent is out of office"
  • "If ticket idle for 24 hours"

Dispatcher Rules

• Ticket Routing

  • "Route billing tickets to finance team"
  • "Assign by product expertise"
  • "Geographic-based assignment"
  • "Language-based routing"

• Load Balancing

  • "Distribute tickets evenly"
  • "Consider agent workload"
  • "Respect agent availability"
  • "Account for skill levels"

• Priority Assignment

  • "VIP customers to senior agents"
  • "Urgent issues to available agents"
  • "Technical queries to specialists"
  • "New customers to onboarding team"

Observer Rules

• Monitoring

  • "Watch for SLA breaches"
  • "Monitor response times"
  • "Track resolution rates"
  • "Detect escalation patterns"

• Notifications

  • "Alert manager on escalations"
  • "Notify on VIP tickets"
  • "Reminder for pending responses"
  • "Update on ticket status changes"

• Escalations

  • "Escalate unresolved tickets"
  • "Manager approval requests"
  • "Critical issue alerts"
  • "SLA violation warnings"

Time-based Automation

• Scheduled Actions

  • "Send follow-up after 3 days"
  • "Auto-close resolved tickets"
  • "Weekend escalation rules"
  • "Business hours routing"

• SLA Management

  • "First response reminders"
  • "Resolution deadline alerts"
  • "Breach prevention actions"
  • "SLA pause during holidays"

• Recurring Tasks

  • "Weekly report generation"
  • "Monthly satisfaction surveys"
  • "Periodic ticket reviews"
  • "Scheduled maintenance notices"

Workflow Automation

• Multi-step Workflows

  • "Approval chain for refunds"
  • "Escalation procedures"
  • "Onboarding sequences"
  • "Issue resolution flows"

• Conditional Logic

  • "If-then-else scenarios"
  • "Multiple condition matching"
  • "Exception handling"
  • "Fallback actions"

• Integration Actions

  • "Update CRM on ticket close"
  • "Create Jira issue for bugs"
  • "Slack notifications"
  • "Webhook triggers"

Agent Automation

• Assignment Rules

  • "Round-robin distribution"
  • "Skills-based matching"
  • "Availability checking"
  • "Workload balancing"

• Agent Assistance

  • "Suggest canned responses"
  • "Auto-tag tickets"
  • "Set default properties"
  • "Apply templates"

• Performance Rules

  • "Track response times"
  • "Monitor quality scores"
  • "Productivity alerts"
  • "Training recommendations"

Prerequisites

• Access to Cequence AI Gateway
• Freshdesk account (Pro or Enterprise for advanced features)
• Admin API access
• API key from Freshdesk

Step 1: Configure Freshdesk Automation API Access

1.1 Get API Key

1. Log in to Freshdesk Admin
2. Click on your profile icon Profile Settings
3. Find Your API Key on the right
4. Copy the API key

1.2 Note Your Domain

Your Freshdesk domain format:

• https://yourcompany.freshdesk.com

1.3 Check Plan Features

Automation features by plan:

• Blossom: Basic automation (limited)
• Garden: Automation rules, time triggers
• Estate: Advanced automation, round-robin
• Forest: Full automation suite, skills-based routing

1.4 Configure Permissions

Ensure your API key has access to:

• Automation rules
• Dispatcher configuration
• Observer settings
• Admin operations

Step 2-4: Standard Setup

Follow standard steps to access AI Gateway, find Freshdesk Automation API, and create MCP server.

Step 5: Configure API Endpoints

1. Base URL: https://yourcompany.freshdesk.com/api/v2
2. Automation Endpoints: Enable automation modules
3. API Version: v2
4. Click Next

Step 6: MCP Server Configuration

1. Name: "Freshdesk Automation"
2. Description: "Helpdesk workflow automation"
3. Timeout: 30 seconds
4. Click Next

Step 7: Configure Authentication

1. Authentication Type: API Key
2. API Key: Your Freshdesk API key
3. Header Format: Basic Auth (auto-configured)
4. Test authentication

Available Freshdesk Automation API Operations

Automation Rules APIs

• Rule Management

  • List automation rules
  • Create rule
  • Update rule
  • Delete rule
  • Activate/deactivate

• Rule Execution

  • Test rule
  • View rule history
  • Rule statistics
  • Performance metrics

Dispatcher APIs

• Dispatcher Rules
  • Create dispatcher
  • Update conditions
  • Set priorities
  • Manage assignments

Observer APIs

• Observer Rules
  • Create observer
  • Set notifications
  • Configure escalations
  • Monitor events

Time Trigger APIs

• Scheduled Actions
  • Create time trigger
  • Update schedule
  • Pause/resume
  • View executions

Workflow APIs

• Complex Workflows
  • Multi-step automation
  • Conditional branches
  • Integration actions
  • Error handling

Step 8-10: Complete Setup

Configure security settings, choose deployment options, and deploy your server.

Using Your Freshdesk Automation MCP Server

With Claude Desktop

{
  "servers": {
    "freshdesk-automation": {
      "url": "your-mcp-server-url",
      "auth": {
        "type": "api_key",
        "api_key": "your-api-key"
      }
    }
  }
}

Natural Language Commands

• "Create rule to auto-assign billing tickets to finance team"
• "Set up escalation for tickets idle over 24 hours"
• "Route Spanish tickets to Spanish-speaking agents"
• "Alert manager when VIP customer creates ticket"
• "Auto-close resolved tickets after 7 days"

API Integration Example

// Initialize MCP client
const mcpClient = new MCPClient({
  serverUrl: 'your-mcp-server-url',
  auth: {
    type: 'api_key',
    apiKey: 'your-freshdesk-api-key'
  }
});

// Create automation rule for VIP handling
const vipRule = await mcpClient.freshdesk.createAutomationRule({
  name: 'VIP Customer Priority Handling',
  description: 'Automatically prioritize and assign VIP customer tickets',
  active: true,
  position: 1,
  conditions: {
    all: [
      {
        field: 'contact.customer_tier',
        operator: 'is',
        value: 'VIP'
      },
      {
        field: 'ticket.status',
        operator: 'is',
        value: 'New'
      }
    ]
  },
  actions: [
    {
      field: 'ticket.priority',
      value: 'Urgent'
    },
    {
      field: 'ticket.group_id',
      value: 'senior_support_team_id'
    },
    {
      field: 'ticket.tags',
      value: ['vip', 'priority-handling']
    },
    {
      field: 'ticket.send_email',
      value: {
        to: 'support-manager@company.com',
        subject: 'VIP Ticket Created - Immediate Attention Required',
        body: 'A VIP customer has created a new ticket requiring immediate attention.'
      }
    }
  ]
});

// Create dispatcher rule for skills-based routing
const skillsRouter = await mcpClient.freshdesk.createDispatcherRule({
  name: 'Technical Issue Routing',
  description: 'Route technical issues to specialized agents',
  active: true,
  conditions: {
    any: [
      {
        field: 'ticket.subject',
        operator: 'contains',
        value: 'API'
      },
      {
        field: 'ticket.tags',
        operator: 'includes',
        value: 'technical'
      },
      {
        field: 'ticket.type',
        operator: 'is',
        value: 'Technical Issue'
      }
    ]
  },
  actions: [
    {
      field: 'ticket.assign_to_agent_with_skill',
      value: {
        skills: ['api_support', 'technical_expertise'],
        fallback_group: 'general_support'
      }
    }
  ]
});

// Create observer rule for SLA monitoring
const slaObserver = await mcpClient.freshdesk.createObserverRule({
  name: 'SLA Breach Prevention',
  description: 'Monitor and alert on potential SLA breaches',
  active: true,
  events: ['ticket_updated', 'ticket_note_added'],
  conditions: {
    all: [
      {
        field: 'ticket.due_by_time',
        operator: 'less_than_hours_from_now',
        value: 2
      },
      {
        field: 'ticket.status',
        operator: 'is_not',
        value: 'Resolved'
      }
    ]
  },
  actions: [
    {
      field: 'notification.send',
      value: {
        to: ['assigned_agent', 'group_leader'],
        message: 'SLA breach imminent - ticket requires immediate attention'
      }
    },
    {
      field: 'ticket.priority',
      value: 'Urgent'
    },
    {
      field: 'ticket.tags',
      value: ['sla-risk']
    }
  ]
});

// Create time-based trigger for follow-ups
const followUpTrigger = await mcpClient.freshdesk.createTimeTrigger({
  name: 'Customer Follow-up',
  description: 'Send follow-up email 3 days after resolution',
  active: true,
  trigger_type: 'after_ticket_resolved',
  delay: {
    value: 3,
    unit: 'days'
  },
  conditions: {
    all: [
      {
        field: 'ticket.status',
        operator: 'is',
        value: 'Resolved'
      },
      {
        field: 'ticket.satisfaction_survey_sent',
        operator: 'is',
        value: false
      }
    ]
  },
  actions: [
    {
      field: 'email.send_to_requester',
      value: {
        template: 'follow_up_template',
        include_survey: true
      }
    },
    {
      field: 'ticket.update_field',
      value: {
        satisfaction_survey_sent: true
      }
    }
  ]
});

// Create round-robin assignment rule
const roundRobin = await mcpClient.freshdesk.createAssignmentRule({
  name: 'Support Team Round Robin',
  description: 'Evenly distribute tickets among support agents',
  type: 'round_robin',
  active: true,
  agent_groups: ['general_support', 'technical_support'],
  conditions: {
    all: [
      {
        field: 'ticket.group_id',
        operator: 'is',
        value: null
      }
    ]
  },
  settings: {
    skip_offline_agents: true,
    consider_workload: true,
    max_tickets_per_agent: 20,
    reset_counter: 'daily'
  }
});

// Create escalation workflow
const escalationWorkflow = await mcpClient.freshdesk.createWorkflow({
  name: 'Ticket Escalation Process',
  description: 'Multi-level escalation for unresolved tickets',
  stages: [
    {
      name: 'Level 1 - Reminder',
      trigger: {
        after_hours: 4,
        if_status: ['Open', 'Pending']
      },
      actions: [
        {
          type: 'send_email',
          to: 'assigned_agent',
          template: 'escalation_reminder'
        },
        {
          type: 'add_note',
          content: 'First escalation reminder sent'
        }
      ]
    },
    {
      name: 'Level 2 - Supervisor',
      trigger: {
        after_hours: 8,
        if_status: ['Open', 'Pending']
      },
      actions: [
        {
          type: 'assign_to',
          target: 'group_supervisor'
        },
        {
          type: 'update_priority',
          value: 'High'
        },
        {
          type: 'send_notification',
          to: ['supervisor', 'original_agent'],
          message: 'Ticket escalated to supervisor'
        }
      ]
    },
    {
      name: 'Level 3 - Management',
      trigger: {
        after_hours: 24,
        if_status: ['Open', 'Pending']
      },
      actions: [
        {
          type: 'create_task',
          for: 'support_manager',
          title: 'Critical escalation review required'
        },
        {
          type: 'update_tags',
          add: ['critical-escalation', 'management-review']
        }
      ]
    }
  ]
});

// Create business hours configuration
const businessHours = await mcpClient.freshdesk.updateBusinessHours({
  name: 'Support Hours',
  timezone: 'America/New_York',
  schedule: {
    monday: { start: '09:00', end: '18:00' },
    tuesday: { start: '09:00', end: '18:00' },
    wednesday: { start: '09:00', end: '18:00' },
    thursday: { start: '09:00', end: '18:00' },
    friday: { start: '09:00', end: '17:00' },
    saturday: { closed: true },
    sunday: { closed: true }
  },
  holidays: [
    { date: '2025-12-25', name: 'Christmas' },
    { date: '2025-01-01', name: 'New Year' }
  ]
});

// Create smart assignment based on keywords
const smartAssignment = await mcpClient.freshdesk.createSmartRule({
  name: 'Keyword-based Assignment',
  type: 'content_analysis',
  active: true,
  rules: [
    {
      keywords: ['refund', 'payment', 'billing', 'invoice'],
      assign_to: 'billing_team',
      priority: 'High'
    },
    {
      keywords: ['bug', 'error', 'crash', 'not working'],
      assign_to: 'technical_team',
      priority: 'Urgent',
      tags: ['bug-report']
    },
    {
      keywords: ['feature request', 'enhancement', 'suggestion'],
      assign_to: 'product_team',
      priority: 'Low',
      type: 'Feature Request'
    }
  ],
  fallback: {
    assign_to: 'general_support',
    priority: 'Medium'
  }
});

// Monitor rule performance
const ruleMetrics = await mcpClient.freshdesk.getRuleMetrics({
  rule_id: vipRule.id,
  period: 'last_30_days'
});

console.log(`Rule Performance: ${vipRule.name}`);
console.log(`Triggered: ${ruleMetrics.trigger_count} times`);
console.log(`Success Rate: ${ruleMetrics.success_rate}%`);
console.log(`Average Processing Time: ${ruleMetrics.avg_processing_time}ms`);

// Test automation rule before activation
const testResult = await mcpClient.freshdesk.testAutomationRule({
  rule: {
    conditions: {
      all: [
        { field: 'ticket.source', operator: 'is', value: 'Email' }
      ]
    },
    actions: [
      { field: 'ticket.priority', value: 'Medium' }
    ]
  },
  sample_tickets: ['TICKET-123', 'TICKET-456', 'TICKET-789']
});

console.log(`Test Results: ${testResult.matches.length} tickets would be affected`);

// Bulk update rules
const bulkUpdate = await mcpClient.freshdesk.bulkUpdateRules({
  rule_ids: ['rule_1', 'rule_2', 'rule_3'],
  updates: {
    active: false,
    reason: 'Temporary suspension for maintenance'
  }
});

// Create conditional workflow
const conditionalWorkflow = await mcpClient.freshdesk.createConditionalRule({
  name: 'Customer Type Based Routing',
  conditions: [
    {
      if: { field: 'contact.vip_status', operator: 'is', value: true },
      then: {
        assign_to: 'vip_support_team',
        priority: 'Urgent',
        sla: 'vip_sla_policy'
      }
    },
    {
      if: { field: 'contact.company_size', operator: 'greater_than', value: 1000 },
      then: {
        assign_to: 'enterprise_team',
        priority: 'High',
        sla: 'enterprise_sla_policy'
      }
    },
    {
      else: {
        assign_to: 'general_support',
        priority: 'Medium',
        sla: 'standard_sla_policy'
      }
    }
  ]
});

Common Use Cases

Ticket Routing

• Skills-based assignment
• Geographic routing
• Language-based distribution
• Product expertise matching

SLA Management

• Breach prevention
• Escalation procedures
• Priority handling
• Response time enforcement

Customer Experience

• VIP treatment rules
• Follow-up automation
• Satisfaction surveys
• Proactive communication

Team Efficiency

• Workload balancing
• Round-robin assignment
• Out-of-office handling
• Performance tracking

Best Practices

1. Rule Design:

   • Start simple, add complexity gradually
   • Test rules before activation
   • Document rule logic
   • Monitor performance metrics

2. Condition Logic:

   • Use specific conditions
   • Avoid overlapping rules
   • Set clear priorities
   • Handle edge cases

3. Performance:

   • Limit active rules
   • Optimize conditions
   • Regular rule audits
   • Archive unused rules

Troubleshooting

Common Issues

1. Rules Not Triggering

   • Check rule conditions
   • Verify rule is active
   • Review rule priority
   • Check conflicting rules

2. Incorrect Assignment

   • Verify agent availability
   • Check group membership
   • Review skills matching
   • Validate round-robin settings

3. Performance Issues

   • Too many active rules
   • Complex conditions
   • Large action sets
   • API rate limits

Getting Help

• Documentation: AI Gateway Docs
• Support: support@cequence.ai
• Freshdesk API: developers.freshdesk.com

---