sys_script_include Table

Table Reference/sys_script_include

The sys_script_include table stores reusable server-side JavaScript libraries that can be called from Business Rules, other Script Includes, REST APIs, and Flow Designer. It's owned by the Development module. The critical gotcha: the api field must be true for the Script Include to be callable from other server-side scripts.

What This Table Is

The sys_script_include table stores reusable server-side JavaScript libraries that promote code reusability and maintainability across the ServiceNow platform. These Script Includes contain functions and classes that can be invoked from Business Rules, Scheduled Scripts, REST APIs, Flow Designer custom actions, and other Script Includes. They serve as the platform's primary mechanism for creating shared server-side code libraries.

This table is owned by the Development module and supports the entire application development lifecycle. Script Includes are fundamental to ServiceNow architecture because they allow developers to centralize business logic, utility functions, and integrations that would otherwise be duplicated across multiple Business Rules or other server-side scripts.

Script Includes don't extend any parent table and no standard tables extend them. They are standalone configuration records that contain JavaScript code. The table has a direct relationship with sys_scope for application scoping and sys_package for update set management.

Large enterprises typically have 500-2000 Script Includes, with performance depending heavily on the access field value. Global Script Includes are loaded into memory on instance startup and cached, while private Script Includes are loaded on-demand. The table performs well for reads but developers should avoid querying it frequently in loops since each Script Include evaluation can trigger additional script compilation.

When You'll Script Against This Table

You'll primarily query this table in Business Rules that need to dynamically load or validate Script Includes, in Scheduled Scripts that manage code deployment, and in REST APIs that provide development tools functionality. Background scripts commonly query this table when performing bulk operations on Script Includes or analyzing code dependencies. Discovery and ServiceMapping also query this table when building application dependency maps.

Access is controlled by the admin role for full CRUD operations, while the script_admin role provides read access. Application scope affects visibility - Script Includes in private scope are only accessible within their application. The access field further restricts availability at runtime.

Common scripting patterns:

Query by name to validate Script Include exists before dynamic instantiation
Find all Script Includes in a specific scope for application auditing
Search script content for deprecated API usage or security patterns
Count Script Includes by access level for governance reporting
Update multiple Script Includes during deployment automation
Clone Script Includes across scopes while maintaining dependencies
Generate documentation by parsing description and script content

Table Gotchas

⚠️

The api field must be true for the Script Include to be callable from other server-side scripts. Setting it to false makes the Script Include only available for on-demand loading via GlideScriptedProcessor.

⚠️

Script Includes with access='public' are loaded into global memory and cached. Changing the script content requires an instance restart or cache flush to take effect in some contexts.

The script field is a longtext field that can hit size limits with very large JavaScript files - ServiceNow recommends keeping Script Includes under 64KB
Querying by script field content using CONTAINS can be extremely slow - use indexed fields like name or sys_scope when possible

⚠️

Script Includes in private scope cannot call Script Includes in different private scopes, even if both are active. Only global scope Script Includes are universally accessible.

The client_callable field only affects Ajax calls from client scripts - it doesn't impact server-side accessibility at all
Inactive Script Includes (active=false) can still be instantiated and called if cached from when they were active - deactivation isn't always immediate

Free Newsletter

Enjoying this? Get one deep-dive per week.

Join 1,000+ ServiceNow pros — scripts, GlideRecord patterns, Flow Designer techniques, and career moves. Free.

Script Includes don't extend any parent table, making them unique among ServiceNow configuration objects. They are self-contained JavaScript libraries that stand alone in the platform architecture. However, they have critical relationships with scoping and package management tables that affect their visibility and deployment.

The most important relationship is with sys_scope, which determines Script Include visibility across applications. The sys_package table tracks Script Includes in update sets for deployment. Developers frequently join with sys_metadata when building dependency maps or performing impact analysis on Script Include changes.

When troubleshooting Script Include issues, developers commonly query syslog_transaction and syslog tables alongside Script Includes to trace execution errors. The sys_script (Business Rules) and sys_ws_operation (Web Services) tables are frequently queried together when analyzing which scripts call specific Script Includes.

Chrome Extension

Sourdough: ServiceNow Monitoring and Analytics

A Chrome extension for ServiceNow Admins and Developers with essential tools, analytics, graphs and monitoring features.

Instance HealthGraphs & ChartsAPI HealthDeveloper ToolsQuick SearchInstance Switcher

Add to Chrome

Free to install. Pro $5/month after a 14-day no-card trial.
Pro requires the ServiceNow admin role. Upgrade inside the extension.

Overview

Tasks

CMDB

API

Metrics

Monitor

Internals

Instance:sourdoughdev·Version:Yokohama

Instance StateONLINE

System StatusFully Operational

Session Timeout90 minutes

Logged-In Sessions2 (20 active)

Build Nameyokohama-12-18-2024_p1

IP Address10.159.128.43

Instance HealthHealth Score: 90%

🔥 5dSourdough (Chrome Plugin)Dark Mode

Key Fields

Column	Type	Label	Notes
name	string	Name	The unique identifier for the Script Include used in JavaScript instantiation. Must follow JavaScript naming conventions and be unique within scope.
script	script	Script	The JavaScript code content. Limited to 64KB and must define the constructor function matching the name field for proper instantiation.
api	choice	Accessible from	Controls server-side accessibility. Must be 'server' (true) for the Script Include to be callable from Business Rules and other server scripts.
access	choice	Access	Defines availability scope: 'public' loads at startup and caches globally, 'package_private' restricts to application scope, 'private' loads on-demand.
active	boolean	Active	Controls whether the Script Include is available for use. Cached instances may persist briefly after deactivation until cache refresh.
client_callable	boolean	Client callable	Allows Ajax calls from client-side scripts. Only affects GlideAjax accessibility, not server-side Script Include usage.
description	string	Description	Functional description of the Script Include purpose. Commonly searched for documentation generation and code analysis tools.
sys_scope	reference	Application	References sys_scope table determining application boundary. Private scope Script Includes cannot call Script Includes from other private scopes.
sys_package	reference	Package	References sys_package for update set tracking. Critical for deployment management and determining which update set contains the Script Include.
protection_policy	reference	Protection policy	References protection policy for upgrade-safe customization. Controls whether upgrades overwrite local changes to out-of-box Script Includes.
sys_policy	string	Domain	Domain separation value inherited from sys_scope. Affects visibility in multi-domain instances where Script Includes respect domain boundaries.

Common Queries

Get all active Script Includes

// Most basic query - finds all Script Includes available for use
var gr = new GlideRecord('sys_script_include');
gr.addQuery('active', true);
gr.query();

while (gr.next()) {
    gs.info('Active Script Include: ' + gr.getValue('name'));
}

// Returns both public and private Script Includes
// Commonly used for auditing or documentation generation

Find active global scope Script Includes with server API access

// Production-ready Script Includes available across all applications
var gr = new GlideRecord('sys_script_include');
gr.addQuery('active', true);
gr.addQuery('api', true); // Server-side callable
gr.addQuery('sys_scope.scope', 'global'); // Global application scope
gr.orderBy('name');
gr.query();

while (gr.next()) {
    gs.info('Global Script Include: ' + gr.getValue('name') + 
            ' | Access: ' + gr.getDisplayValue('access'));
}

Find Script Includes containing deprecated API calls in custom scope

// Real-world scenario: audit custom code for deprecated functions
var gr = new GlideRecord('sys_script_include');
gr.addQuery('sys_scope.scope', '!=', 'global'); // Custom applications only
gr.addQuery('script', 'CONTAINS', 'GlideSystem'); // Deprecated direct access
gr.addQuery('active', true);
gr.query();

var count = 0;
while (gr.next()) {
    count++;
    gs.warn('Script Include needs review: ' + gr.getValue('name') + 
            ' in scope: ' + gr.getDisplayValue('sys_scope'));
}
gs.info('Found ' + count + ' Script Includes using deprecated APIs');

Count Script Includes by access level for governance reporting

// Aggregate query for architecture governance dashboard
var ga = new GlideAggregate('sys_script_include');
ga.addQuery('active', true);
ga.addAggregate('COUNT', 'sys_id');
ga.groupBy('access');
ga.query();

var totals = {};
while (ga.next()) {
    var accessLevel = ga.getValue('access');
    var count = ga.getAggregate('COUNT', 'sys_id');
    totals[accessLevel] = count;
    gs.info('Access level ' + accessLevel + ': ' + count + ' Script Includes');
}

Wrong way vs right way to check if Script Include exists before calling

// WRONG: Querying every time before instantiation is inefficient
/*
var gr = new GlideRecord('sys_script_include');
gr.addQuery('name', 'MyUtilClass');
if (gr.query() && gr.next()) {
    var util = new MyUtilClass();
}
*/

// RIGHT: Use try/catch for existence check - much faster
try {
    var util = new MyUtilClass();
    var result = util.someMethod();
} catch (e) {
    gs.warn('MyUtilClass not available: ' + e.getMessage());
}
// Exception handling is faster than querying sys_script_include table

Related Tables

sys_script syslog

Test Your Knowledge

Quick 3-question quiz — see how your ServiceNow skills stack up.

Question 1 of 3Performance

A list view on a table with millions of records is slow. Best fix?

Select an answer to continue