ServiceNow Freshdesk Integration Guide

Architecture Overview

Implementation Steps

var rm = new sn_ws.RESTMessageV2('Freshdesk Integration', 'get_tickets');
rm.setStringParameterNoEscape('ticket_id', current.correlation_id);
rm.setRequestHeader('Authorization', 'Basic ' + gs.base64Encode(gs.getProperty('freshdesk.api.key') + ':X'));
var response = rm.execute();
var responseBody = response.getBody();
var httpStatus = response.getStatusCode();

(function process(/*RESTAPIRequest*/ request, /*RESTAPIResponse*/ response) {
    var payload = request.body.dataString;
    var ticketData = JSON.parse(payload);
    
    var gr = new GlideRecord('incident');
    gr.addQuery('correlation_id', ticketData.id);
    gr.query();
    
    if (!gr.next()) {
        gr.initialize();
        gr.correlation_id = ticketData.id;
        gr.short_description = ticketData.subject;
        gr.description = ticketData.description_text;
        gr.priority = mapFreshdeskPriority(ticketData.priority);
        gr.state = mapFreshdeskStatus(ticketData.status);
        gr.insert();
    }
    
    response.setStatus(200);
    response.setBody(JSON.stringify({status: 'success'}));
})(request, response);

var gr = new GlideRecord('incident');
gr.addQuery('correlation_id', '!=', '');
gr.addQuery('sys_updated_on', '>', new GlideDateTime().subtract(15 * 60 * 1000));
gr.query();

while (gr.next()) {
    var rm = new sn_ws.RESTMessageV2('Freshdesk Integration', 'update_ticket');
    rm.setStringParameterNoEscape('ticket_id', gr.correlation_id);
    
    var payload = {
        status: mapServiceNowStatus(gr.state),
        priority: mapServiceNowPriority(gr.priority),
        notes: gr.work_notes.toString()
    };
    
    rm.setRequestBody(JSON.stringify(payload));
    var response = rm.execute();
    
    if (response.getStatusCode() != 200) {
        gs.error('Failed to sync incident ' + gr.number + ' to Freshdesk: ' + response.getErrorMessage());
    }
}

// Transform map script for priority mapping
function mapFreshdeskPriority(freshdeskPriority) {
    var priorityMap = {
        '1': '1', // Low -> Planning
        '2': '2', // Medium -> Low
        '3': '3', // High -> Moderate
        '4': '1'  // Urgent -> High
    };
    return priorityMap[freshdeskPriority.toString()] || '3';
}

// Usage in transform map field
answer = mapFreshdeskPriority(source.priority);

try {
    var rm = new sn_ws.RESTMessageV2('Freshdesk Integration', 'get_tickets');
    rm.setRequestHeader('Authorization', 'Basic ' + gs.base64Encode(api_key + ':X'));
    var response = rm.execute();
    
    if (response.getStatusCode() == 401) {
        gs.error('Freshdesk API authentication failed - check credentials');
        return false;
    }
    
    if (response.getStatusCode() >= 400) {
        gs.error('Freshdesk API error: ' + response.getStatusCode() + ' - ' + response.getBody());
        return false;
    }
    
    return JSON.parse(response.getBody());
} catch (ex) {
    gs.error('Freshdesk integration exception: ' + ex.getMessage());
    return null;
}

Common Use Cases

Troubleshooting

Pro Tips

• →Implement field-level change tracking in your synchronization logic to avoid unnecessary API calls when only system fields (like sys_updated_on) change. Create custom update sets to track which fields actually contain business-relevant changes and only synchronize those modifications to Freshdesk, significantly reducing API quota consumption and improving integration performance.
• →Configure separate ServiceNow business rules with conditions to handle different Freshdesk webhook event types (ticket_created, ticket_updated, note_added) rather than processing everything in a single script. This approach provides better error isolation, easier debugging, and more granular control over integration behavior for different scenarios.
• →Set up monitoring dashboards using ServiceNow Performance Analytics to track integration health metrics including API response times, error rates, and synchronization delays. Create automated alerts when error thresholds exceed acceptable limits and implement health checks that proactively test API connectivity during maintenance windows.
• →Use ServiceNow's Integration Hub Flow Designer to create visual workflows for complex multi-step integrations rather than relying solely on scripted solutions. This approach provides better maintainability, easier troubleshooting through execution logs, and enables non-technical administrators to modify integration logic without custom scripting.
• →Implement comprehensive logging strategies using custom log tables to track all integration transactions with correlation IDs, timestamps, and payload data. This enables rapid troubleshooting of synchronization issues and provides audit trails for compliance requirements while keeping sensitive data separate from standard ServiceNow system logs.
• →Create custom ServiceNow notifications that alert administrators when Freshdesk tickets remain unsynced for extended periods, indicating potential integration failures or API quota exhaustion. Include automatic retry mechanisms with exponential backoff for transient failures while escalating persistent issues to support teams.

Known Limitations

• —Freshdesk's API rate limiting restricts Estate plans to 1000 requests per hour, which may be insufficient for organizations with high ticket volumes or frequent status updates. This limitation requires careful implementation of request batching, caching strategies, and priority-based synchronization to ensure critical updates are processed within quota constraints. Consider upgrading to higher-tier Freshdesk plans for increased API limits if integration requirements exceed these thresholds.
• —Real-time bi-directional synchronization can create infinite loops if both systems trigger updates simultaneously, requiring careful implementation of sync flags and timestamp comparisons to prevent circular updates. ServiceNow's webhook processing must include logic to detect and break sync cycles, potentially introducing slight delays in data consistency between platforms. This limitation necessitates thorough testing of all update scenarios during implementation.
• —Custom fields and complex data relationships in either platform may not have direct equivalents, requiring manual mapping decisions and potential data loss during synchronization. Freshdesk's limited custom field types compared to ServiceNow's extensive data model can constrain the richness of synchronized information. Organizations must carefully evaluate which data elements are essential for integration versus those that remain platform-specific.
• —ServiceNow's Integration Hub licensing requirements add cost considerations for organizations not already using Integration Hub features, as the professional license tier is typically required for production integrations. Alternative implementations using basic REST messages and scheduled jobs may have reduced functionality but lower licensing costs. Budget planning must account for both ServiceNow and Freshdesk licensing tiers that support necessary API features.
• —Large-scale historical data migration between platforms is not supported through standard API endpoints due to rate limiting and timeout constraints. Initial synchronization of existing tickets requires careful planning with incremental data loads and extended migration timeframes. Organizations implementing this integration should plan for parallel operation periods while historical data alignment is completed through batch processes.

Frequently Asked Questions