ServiceNow Slack Integration Guide

Architecture Overview

Implementation Steps

// Test the credential configuration
var r = new sn_ws.RESTMessageV2();
r.setEndpoint('https://slack.com/api/auth.test');
r.setHttpMethod('POST');
r.setRequestHeader('Authorization', 'Bearer ' + gs.getProperty('slack.bot.token'));
var response = r.execute();
gs.info('Slack auth test response: ' + response.getBody());

// Flow Designer message template for Slack action
"🚨 *Incident Created*\n" +
"*Number:* " + trigger.incident.number +
"\n*Description:* " + trigger.incident.short_description +
"\n*Priority:* " + trigger.incident.priority.getDisplayValue() +
"\n*Assigned to:* " + trigger.incident.assigned_to.getDisplayValue() +
"\n*Link:* " + gs.getProperty('glide.servlet.uri') + 'incident.do?sys_id=' + trigger.incident.sys_id

(function process(request, response) {
    var slackPayload = JSON.parse(request.body.data);
    var commandText = slackPayload.text;
    var incidentGR = new GlideRecord('incident');
    incidentGR.addQuery('number', 'CONTAINS', commandText);
    incidentGR.setLimit(5);
    incidentGR.query();
    
    var responseText = 'Found incidents:\n';
    while (incidentGR.next()) {
        responseText += incidentGR.getDisplayValue('number') + ' - ' + incidentGR.getDisplayValue('short_description') + '\n';
    }
    
    var slackResponse = {
        'response_type': 'in_channel',
        'text': responseText
    };
    
    response.setBody(slackResponse);
})(request, response);

// Interactive button configuration in Flow Designer
{
  "text": "Incident " + trigger.incident.number,
  "attachments": [{
    "text": trigger.incident.short_description,
    "fallback": "Unable to display incident actions",
    "callback_id": "incident_" + trigger.incident.sys_id,
    "actions": [{
      "name": "acknowledge",
      "text": "Acknowledge",
      "type": "button",
      "value": "acknowledge",
      "style": "primary"
    }, {
      "name": "assign",
      "text": "Assign to Me",
      "type": "button",
      "value": "assign"
    }]
  }]
}

// Script Include for Slack webhook validation
validateSlackSignature: function(requestBody, timestamp, slackSignature) {
    var signingSecret = gs.getProperty('slack.signing.secret');
    var baseString = 'v0:' + timestamp + ':' + requestBody;
    var hmac = new GlideCryptoJS.HmacSHA256(baseString, signingSecret);
    var computedSignature = 'v0=' + hmac.toString();
    
    // Check timestamp is within 5 minutes
    var currentTime = Math.floor(Date.now() / 1000);
    if (Math.abs(currentTime - parseInt(timestamp)) > 300) {
        return false;
    }
    
    return computedSignature === slackSignature;
}

// Error handling in Slack REST API
try {
    var incidentGR = new GlideRecord('incident');
    if (incidentGR.get(incidentSysId)) {
        incidentGR.setValue('state', '2'); // In Progress
        incidentGR.setValue('assigned_to', slackUserId);
        incidentGR.update();
        
        return {
            'text': 'Incident ' + incidentGR.getDisplayValue('number') + ' has been assigned to you.'
        };
    }
} catch (ex) {
    gs.error('Slack integration error: ' + ex.getMessage());
    return {
        'text': 'Sorry, there was an error processing your request. Please try again or contact your administrator.',
        'response_type': 'ephemeral'
    };
}

Common Use Cases

Troubleshooting

Pro Tips

• →Configure separate Slack apps for different ServiceNow environments (dev, test, prod) to prevent cross-environment message pollution and ensure proper testing isolation. Use environment-specific channel naming conventions and maintain separate credential sets to avoid accidentally sending test data to production channels.
• →Implement message threading for related updates by storing Slack message timestamps in ServiceNow records and using the thread_ts parameter in subsequent API calls. This keeps conversations organized and prevents channel flooding while maintaining context for ongoing incidents or requests.
• →Use Slack's scheduled message feature through the chat.scheduleMessage API to respect team working hours when sending non-critical notifications. Store user timezone preferences in ServiceNow and calculate appropriate delivery times to improve message relevance and reduce after-hours noise.
• →Create reusable message templates using ServiceNow's UI Macros or custom tables to maintain consistent formatting across different integration points. This approach ensures branding consistency, reduces maintenance overhead, and makes it easier to update message formats globally when requirements change.
• →Leverage Slack's user group mentions (@channel, @here, or custom groups) strategically by mapping ServiceNow assignment groups to Slack user groups in a custom mapping table. This enables dynamic notifications that automatically mention the right people based on ServiceNow assignment logic.
• →Implement comprehensive audit logging by creating custom tables to track all Slack interactions, message deliveries, and user actions for compliance and troubleshooting purposes. Include fields for Slack message IDs, delivery status, user responses, and timestamps to maintain full traceability of integration activities.

Known Limitations

• —Slack API rate limits restrict apps to approximately 1 request per second per workspace, which can cause delays during high-volume incident periods or bulk notification scenarios. The Integration Hub spoke includes retry logic, but complex flows with multiple Slack actions may experience significant delays during peak usage periods.
• —Message formatting is limited to Slack's supported markdown subset and interactive component constraints, preventing rich HTML formatting or complex layouts available in ServiceNow forms. Large data sets or detailed technical information may require alternative presentation methods like file attachments or shortened summaries with links to full ServiceNow records.
• —Bi-directional user mapping between Slack and ServiceNow requires manual configuration and maintenance, as there's no automatic synchronization of user accounts between systems. Organizations must implement custom logic to map Slack user IDs to ServiceNow user records, and this mapping can break when users change email addresses or leave the organization.
• —The integration requires an Integration Hub Professional license for production use, and flow execution limits may restrict the number of concurrent Slack operations during high-activity periods. Organizations with large incident volumes may need to implement queuing mechanisms or prioritize certain notification types to stay within license limits.
• —Webhook delivery reliability depends on network connectivity and ServiceNow instance availability, with no built-in mechanism for handling failed deliveries during maintenance windows. Slack will retry failed webhook deliveries for up to 3 days, but there's no guarantee of message order preservation or delivery confirmation for critical notifications.

Frequently Asked Questions