ServiceNow NetSuite Integration Guide

Architecture Overview

Implementation Steps

var rm = new sn_ws.RESTMessageV2('NetSuite Integration', 'GET Vendor Records');
rm.setEndpoint('https://[account].suitetalk.api.netsuite.com/rest/platform/v1/record/vendor');
rm.setAuthenticationProfile('oauth1', 'netsuite_credentials');
rm.setRequestHeader('Content-Type', 'application/json');
var response = rm.execute();
var responseBody = response.getBody();
gs.log('NetSuite Response: ' + responseBody);

var gr = new GlideRecord('u_netsuite_vendors');
gr.initialize();
gr.netsuite_id = source.netsuite_vendor_id;
gr.vendor_name = source.companyname;
gr.email = source.email;
gr.phone = source.phone;
gr.status = source.entitystatus;
if (gr.insert()) {
  gs.log('Vendor created with sys_id: ' + gr.sys_id);
}

// In a Script step within Integration Hub flow
var restCall = new sn_ws.RESTMessageV2('NetSuite Integration', 'GET Vendor Records');
restCall.setStringParameterNoEscape('lastModified', fd_data.lookup.last_sync_time);
var response = restCall.execute();
if (response.getStatusCode() == 200) {
  var vendors = JSON.parse(response.getBody());
  fd_data.lookup.vendor_count = vendors.items.length;
  fd_data.lookup.vendor_data = response.getBody();
} else {
  fd_data.lookup.error_message = 'NetSuite API call failed: ' + response.getStatusCode();
}

(function process(/*RESTAPIRequest*/ request, /*RESTAPIResponse*/ response) {
  var payload = JSON.parse(request.body.data);
  var incident = new GlideRecord('incident');
  incident.initialize();
  incident.short_description = 'NetSuite Alert: ' + payload.subject;
  incident.description = payload.description + '\nNetSuite Record ID: ' + payload.record_id;
  incident.category = 'Software';
  incident.subcategory = 'ERP';
  incident.priority = payload.priority || '3';
  incident.caller_id = payload.user_id || 'netsuite_integration_user';
  var incidentId = incident.insert();
  response.setStatus(201);
  response.setBody({incident_number: incident.number, sys_id: incidentId});
})(request, response);

// NetSuite SuiteScript 2.0 example for calling ServiceNow
define(['N/https', 'N/log'], function(https, log) {
  function callServiceNow(recordData) {
    var options = {
      url: 'https://yourinstance.service-now.com/api/now/table/incident',
      method: https.Method.POST,
      headers: {
        'Authorization': 'Basic ' + encode.convert({
          string: 'username:password',
          inputEncoding: encode.Encoding.UTF_8,
          outputEncoding: encode.Encoding.BASE_64
        }),
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(recordData)
    };
    var response = https.request(options);
    log.debug('ServiceNow Response', response.body);
  }
  return {callServiceNow: callServiceNow};
});

Common Use Cases

Troubleshooting

Pro Tips

• →Implement field-level change detection in your NetSuite synchronization flows by storing hash values or timestamps of synchronized records to avoid unnecessary API calls and processing overhead. Use ServiceNow's GlideChecksum API to generate hash values of critical fields and compare them during sync operations, significantly reducing NetSuite API consumption while maintaining data accuracy.
• →Configure ServiceNow Business Rules with 'async' execution to handle NetSuite API calls that could timeout or delay user transactions, especially for real-time validations like budget checks. Use Event queues and scheduled jobs for non-critical NetSuite synchronization to maintain ServiceNow performance while ensuring eventual data consistency across both systems.
• →Leverage NetSuite's SuiteQL for complex data queries instead of multiple REST API calls when synchronizing large datasets, as SuiteQL can join multiple record types and filter data server-side. This reduces API call consumption and improves synchronization performance while providing more flexible data retrieval options for ServiceNow integration requirements.
• →Implement comprehensive error handling with exponential backoff retry logic in Integration Hub flows to handle NetSuite's temporary service unavailability or maintenance windows gracefully. Store failed synchronization attempts in custom ServiceNow tables with retry counters and error details to enable manual reprocessing and maintain audit trails of integration failures.
• →Use ServiceNow's Connection Alias feature with multiple NetSuite credentials for load balancing and failover scenarios, especially in high-volume integration environments. Configure round-robin credential selection or primary/secondary patterns to distribute API calls across multiple NetSuite integration applications and avoid hitting single-token rate limits.
• →Create custom ServiceNow reports and dashboards to monitor NetSuite integration health including API response times, success rates, and data synchronization lag times. Use Performance Analytics or custom metrics to track integration KPIs and identify performance trends that could indicate configuration issues or capacity constraints requiring attention.

Known Limitations

• —NetSuite's REST API rate limits are strictly enforced at 1000 requests per hour for RESTlets and 5000 for standard REST APIs, requiring careful throttling and batch processing strategies that may introduce synchronization delays of 15-30 minutes for large datasets. SuiteCloud Plus subscriptions increase these limits but add significant licensing costs that must be factored into integration planning and budget considerations.
• —NetSuite's Token-Based Authentication requires periodic token renewal and careful credential management, as tokens can expire without notice or be revoked by NetSuite administrators, causing integration failures until manual intervention occurs. ServiceNow cannot automatically refresh these tokens, requiring operational processes to monitor and update credentials proactively to maintain integration stability.
• —Complex NetSuite custom fields and record types may not have direct ServiceNow equivalents, requiring extensive custom scripting and transform logic that increases maintenance overhead and upgrade complexity. NetSuite's flexible schema allows unlimited customization that can create data synchronization challenges when business users modify fields without considering ServiceNow integration impacts.
• —Real-time bi-directional synchronization is limited by both platforms' API performance and transaction processing speeds, typically achieving near real-time sync within 5-10 minutes rather than instantaneous updates. Critical business processes requiring immediate data consistency may need workflow design adjustments to accommodate integration latency and potential temporary data inconsistencies.
• —NetSuite's SuiteScript execution limits and governance restrictions can affect complex integration logic, particularly for large-scale data transformations or real-time webhook processing that may timeout or exceed script execution quotas. These limitations require careful script optimization and may necessitate breaking complex integrations into smaller, more manageable components.

Frequently Asked Questions