📦 Mastering Script Include in ServiceNow: Types, Best Practices, and Real-World Use Cases

Bhavesh Patil · ‎07-20-2025

Hey #ServiceNowCommunity 👋

Have you ever written logic that you needed to reuse across multiple scripts in ServiceNow?

That’s where Script Includes come in—an essential tool for writing modular, reusable, and secure server-side code.

In this post, let’s dive into everything about Script Includes: their types, real-time use cases, best practices, and some pro tips you don't want to miss!

💡What is a Script Include?

A Script Include in ServiceNow is a reusable server-side script that defines a function or class which can be called from other server scripts (Business Rules, Scheduled Jobs, Flow Actions, etc.), or even client-side (if exposed as callable via glideAjax).

It helps you avoid code duplication, improve maintainability, and enable separation of concerns in complex logic.

🧠 Importance of Script Includes

✅Centralizes reusable logic
✅Improves script efficiency & readability
✅Reduces maintenance cost
✅Supports object-oriented scripting in ServiceNow
✅Enables server-client communication (via GlideAjax)

🧩 Types of Script Includes (Explained Deeply with Examples)

Script Includes can be categorized based on how they’re used and accessed.

🔹1. On demand/classless :-

A Script Include that defines a single function is known as on demand script include, It does not contain class hence it is also called as classless Script Include.
This script include is callable from only other server-side scripts.
We cannot use On demand script include in client side even if the Client callable checkbox is check or not.
The Script Include name and function name should be exactly same.

🛠Use Case: Reusable utility methods for date formatting, string manipulation, etc.

var CommonUtils = Class.create();
CommonUtils.prototype = {
    initialize: function () {},

    getFormattedDate: function () {
        return new GlideDateTime().getDisplayValue();
    },

    type: 'CommonUtils'
};

// Call from Business Rule:
var utils = new CommonUtils();
var date = utils.getFormattedDate();

🔹2. Extend an existing class :-

Client Callable Script Include (GlideAjax)

Extend an existing class is basically inherit the other class, means accessing the fields and methods of other classes. & this is the only type which work server to client side.
In this type of script include we can create multiple function as well.
The mostly used extensible class is ‘AbstractAjaxProcessor’ so that client script communicate with server-side script.

🛠Use Case: Fetch user details, approval status, or server-side values on form load.

// Script Include
var SIname = Class.create();
SIname.prototype = Object.extendsObject(AbstractAjaxProcessor, {

    getInfo: function () {
        var sysID = this.getParameter('sysparm_sysID');
        var obj = {};

        var grUser = new GlideRecord('sys_user');
        if (grUser.get(sysID)) {
            obj.DepartmentName = grUser.department.name.toString();
        }

        return JSON.stringify(obj);
    },

    type: 'SIname'
});

// Client Script
var callerSysID = g_form.getValue('u_caller');

var ga = new GlideAjax('SIname');
ga.addParam('sysparm_name', 'getInfo');
ga.addParam('sysparm_sysID', callerSysID);
ga.getXMLAnswer(function(response) {
    var parsedData = JSON.parse(response);
    g_form.setValue('department', parsedData.DepartmentName);
});

🔹3. Define a new class :-

Script Include with Prototype Methods (OOP Style)

When we create a new script include that is actually Define a new class. It is also callable from server side. we cannot call it on client side.
In this type of script include we can create multiple functions & this is the difference between Define a new class & On demand script include.

🛠Use Case: Class with business logic that handles complex operations.

var TaskManager = Class.create();
TaskManager.prototype = {
    initialize: function(taskSysId) {
        this.task = new GlideRecord('task');
        this.task.get(taskSysId);
    },

    isOverdue: function () {
        return this.task.due_date < new GlideDateTime();
    },

    assignToCurrentUser: function () {
        this.task.assigned_to = gs.getUserID();
        this.task.update();
    },

    type: 'TaskManager'
};

⚔️Difference Between Script Include Types

Feature	On Demand	Extend and Existing	Define New class
Accessed From	Server-side only	Client-side (via GlideAjax)	Server-side
Client Callable Box	❌Unchecked	✅Checked	❌Optional
Use Case	Utility logic	Fetch data for client	Business logic as object
Return Type	Any data	String (for getXMLAnswer)	Any

🧠 Best Practices for Script Includes

✅Keep each Script Include focused on a single responsibility
✅Use meaningful names (e.g., IncidentHelper, ApprovalUtil)
✅Use gs.info() for logging and debugging, remove after deployment
✅Avoid hardcoding values—use gs.getProperty() for dynamic config
✅Return only what’s needed; reduce payload for client-callable scripts
✅Mark Script Includes as Client Callable only if absolutely needed
✅Document methods with comments and parameter expectations
✅Use Flow Designer Script Actions instead of custom scripting when possible for simpler logic

💼Real-Time Use Cases of Script Includes

🔁Reusable approval logic shared across multiple flows and BRs
📩Send formatted email notifications based on templates and record types
🔍Check user roles or permissions before executing server-side logic
🔄Call external APIs (via RESTMessageV2) with reusable code blocks
📥Fetch data from parent-child records and return values to the client side

💡Pro Tips

🔹Use Script Includes with Flow Designer Script Actions to bring reusability into no/low-code environments.

🔹Don’t expose sensitive logic in Client Callable scripts. Always validate user permissions on the server-side.

🔹Use JSUtil.nil() instead of == null or == '' to safely check for null/empty values in ServiceNow.

🔹Group related functions under one class rather than creating many tiny Script Includes.

🏁Final Thoughts

Script Includes are one of the most powerful yet often underutilized features in ServiceNow. Whether you're optimizing background logic or enabling dynamic client-side behaviors, a well-structured Script Include makes your code modular, clean, and scalable.

Have a unique use case or challenge with Script Includes? Let’s discuss in the comments below! 💬

**Please mark it as *Helpful* or *Correct* — it really means a lot!**