ServiceNow Twilio SMS Integration Guide

Architecture Overview

Implementation Steps

// REST Message HTTP Method content (in HTTP Request tab)
To=${to_number}&From=${from_number}&Body=${message_body}

// Variable substitutions needed:
// ${account_sid} - Your Twilio Account SID
// ${to_number} - Destination phone number
// ${from_number} - Your Twilio phone number
// ${message_body} - SMS message text

(function executeRule(current, previous) {
    try {
        var restMessage = new sn_ws.RESTMessageV2('Twilio SMS API', 'sendSMS');
        restMessage.setStringParameterNoEscape('account_sid', gs.getProperty('twilio.account_sid'));
        restMessage.setStringParameterNoEscape('to_number', current.caller_id.mobile_phone);
        restMessage.setStringParameterNoEscape('from_number', gs.getProperty('twilio.from_number'));
        restMessage.setStringParameterNoEscape('message_body', 'Incident ' + current.number + ' assigned to you. Priority: ' + current.priority.getDisplayValue());
        
        var response = restMessage.execute();
        if (response.getStatusCode() != 201) {
            gs.error('Twilio SMS failed: ' + response.getBody());
        } else {
            gs.info('SMS sent successfully for incident ' + current.number);
        }
    } catch (ex) {
        gs.error('Error sending SMS: ' + ex.getMessage());
    }
})(current, previous);

(function process(request, response) {
    try {
        var requestBody = request.body.data;
        var fromNumber = requestBody.From;
        var messageBody = requestBody.Body;
        var messageSid = requestBody.MessageSid;
        
        // Parse message for incident number pattern
        var incidentMatch = messageBody.match(/INC\d{7}/);
        if (incidentMatch) {
            var incidentGR = new GlideRecord('incident');
            if (incidentGR.get('number', incidentMatch[0])) {
                // Add work note with SMS reply
                incidentGR.work_notes = 'SMS Reply from ' + fromNumber + ': ' + messageBody;
                incidentGR.update();
                
                response.setStatus(200);
                response.setBody('SMS processed successfully');
            }
        }
    } catch (ex) {
        gs.error('Inbound SMS processing error: ' + ex.getMessage());
        response.setStatus(500);
    }
})(request, response);

Common Use Cases

Troubleshooting

Pro Tips

• →Implement SMS message templating using ServiceNow's Template Management (sys_template) records to maintain consistent message formatting and enable non-technical users to modify SMS content without code changes. Store message templates with variable placeholders and use GlideTemplate API in your business rules to populate dynamic content, improving maintainability and compliance with messaging standards.
• →Create a custom SMS tracking table to log all outbound and inbound SMS activity with fields for message content, delivery status, costs, and response tracking. This provides audit trails, enables SMS analytics reporting, and helps optimize messaging costs by identifying high-volume scenarios that might benefit from alternative communication channels or message consolidation strategies.
• →Use ServiceNow's Notification framework combined with custom notification devices to leverage existing notification conditions and user preferences while routing messages through Twilio. This approach allows users to set SMS preferences, quiet hours, and escalation rules while maintaining centralized notification management and reducing custom code maintenance overhead.
• →Implement SMS rate limiting and cost controls by creating custom application properties for daily/monthly SMS limits per user or globally, and add validation logic in your SMS sending code to prevent runaway messaging costs. Consider implementing approval workflows for bulk SMS operations and monitoring Integration Hub transaction usage to optimize licensing costs.
• →Set up bidirectional SMS conversation threading by storing SMS conversation state in custom tables and implementing keyword-based command processing for common actions like incident status updates, approval responses, or information requests. This creates more sophisticated SMS interfaces that reduce the need for users to access ServiceNow directly while maintaining proper audit trails and security validation.
• →Configure Twilio webhooks to include delivery status callbacks and implement ServiceNow webhook handlers to track message delivery, read receipts, and delivery failures. Store this status information in your SMS tracking system to enable retry logic for failed messages, generate delivery reports, and optimize messaging strategies based on actual delivery success rates.

Known Limitations

• —Twilio SMS API has rate limits of approximately 1 message per second per phone number, which may require message queuing or delay mechanisms for high-volume SMS scenarios like mass notifications during major incidents. ServiceNow Integration Hub licensing also imposes transaction limits that count against your subscription when using the official Twilio spoke for SMS operations.
• —SMS message length is limited to 160 characters for standard GSM encoding or 70 characters for Unicode content, requiring message truncation or splitting logic for longer notifications. MMS support is available but requires additional Twilio configuration and higher per-message costs, and not all mobile carriers guarantee MMS delivery reliability.
• —Inbound SMS processing requires exposing ServiceNow endpoints to Twilio webhooks, which may require firewall rule changes and careful security consideration for authentication and input validation. Webhook delivery failures can result in lost inbound messages, as Twilio has limited retry mechanisms compared to email-based inbound processing systems.
• —SMS delivery is dependent on mobile carrier networks and international SMS routing, which can introduce delivery delays, higher costs for international numbers, and potential message filtering by carriers for suspected spam content. Delivery confirmations are not guaranteed and require additional webhook configuration to track message delivery status accurately.
• —Integration costs include both Twilio per-message charges (typically $0.0075-$0.04 per SMS depending on destination) and ServiceNow Integration Hub transaction consumption, making SMS integration more expensive than email notifications for high-volume scenarios. Budget planning should account for both platform costs and potential message volume growth over time.

Frequently Asked Questions