GlideRecord & GlideAjax in ServiceNow: Client-Side vs Server-Side

AL-Khalid — Tue, 28 Jul 2026 03:43:03 GMT

When you start building real-world ServiceNow solutions, one of the most important distinctions to understand is the difference between client-side and server-side execution. A lot of confusion in ServiceNow development comes from using the right API in the wrong place, or from making synchronous calls that slow the user experience.

In this article, we will walk through:

how client-side GlideRecord works,
why callback functions matter,
how GlideAjax connects the client to the server,
how to build client-callable Script Includes,
how to return multiple values,
how to work with reference fields safely,
how to use encoded queries on the client,
and when JSON is the better way to return structured data.

1) Understanding Client-Side GlideRecord

GlideRecord is a ServiceNow API object used to interact with the database. On the client side, it allows a script running in the browser to query records from the server. That sounds convenient, but it comes with a performance cost.

Client scripts run in the user’s browser when a page loads, a field changes, or a form is submitted. If a client script makes the browser wait for the server, the user experience becomes slower and less responsive. This is why synchronous calls from the client are usually discouraged, especially on page load or on field change.

A useful rule of thumb is this:

use client-side scripts for lightweight browser logic,
use server-side logic for database work,
and use asynchronous calls whenever possible.

2) Why Callback Functions Matter

A callback function allows a query to be executed asynchronously. Instead of freezing the browser while waiting for a response, the script submits the request to the server and continues running. When the response returns, the callback function is executed.

That difference is important.

Without a callback

Submit the query to the database.
The server processes the query.
The server builds the response.
The response returns to the browser.
Additional client-side work happens.
The user can finally interact with the page.

With a callback

Submit the query to the database.
Community Central forumThe user can keep interacting with the browser.
The server processes the query.
The server builds the response.
The response returns to the browser.
The callback function runs.
Additional client-side work happens inside the callback.

That second flow is usually much better for performance.

Example: asynchronous GlideRecord query

var gr = new GlideRecord('a_table');
gr.addQuery('some', 'conditions');
gr.query(myCallBack);

// define the callback function
function myCallBack(gr) {
    while (gr.next()) {
        // do some client-side work
    }
}

The same idea applies to g_form.getReference():

g_form.getReference('assigned_to', cbFunc);

function cbFunc(gr) {
    var assignedToName = gr.getValue('name');
    alert('This ticket is assigned to: ' + assignedToName + '.');
}

In both cases, the browser stays responsive while the server does the heavier work.

3) GlideAjax: The Server-Side Bridge for Client Scripts

GlideAjax is one of the most useful but least understood APIs in ServiceNow because it has both a client-side part and a server-side part.

It is not simply a replacement for GlideRecord. Instead, it is a way to send a request from the browser to the server, run a Script Include there, and send data back to the client.

That makes GlideAjax especially useful when you need to:

query data from the database,
return a value to the client,
avoid synchronous client-side database access,
or return structured data back to the browser.

The response from GlideAjax is XML, and that means it can hold more than one value.

4) GlideAjax From the Client

A basic GlideAjax call starts in the client script.

Example: client-side GlideAjax

var ga = new GlideAjax('AjaxScriptInclude'); // exact Script Include name
ga.addParam('sysparm_name', 'greetingFunction'); // function to run
ga.addParam('sysparm_my_name', 'Tim'); // optional parameter
ga.getXML(myCallBack); // callback for the response

function myCallBack(response) {
    var greeting = response.responseXML.documentElement.getAttribute('answer');
    alert(greeting);
}

What each line does

new GlideAjax('AjaxScriptInclude') tells ServiceNow which Script Include to call.
sysparm_name identifies the function inside the Script Include.
Additional parameters, such as sysparm_my_name, can be passed into the server-side function.
getXML(myCallBack) sends the request and handles the result asynchronously.

The response variable contains XML, and the returned value is usually available through the answer attribute:

var greeting = response.responseXML.documentElement.getAttribute('answer');

That is the standard pattern when the Script Include returns a single value.

5) Building the GlideAjax Script Include

To make GlideAjax work, the server-side Script Include must be client callable and must extend AbstractAjaxProcessor.

Example: server-side Script Include

var AjaxScriptInclude = Class.create();
AjaxScriptInclude.prototype = Object.extendsObject(AbstractAjaxProcessor, {
    greetingFunction: function() {
        var userName = this.getParameter('sysparm_my_name');
        return 'Hiya, ' + userName + '.';
    }
});

Important points

The Script Include name must match the client-side name.
sysparm_name tells ServiceNow which function to run.
this.getParameter('sysparm_my_name') retrieves the parameter passed from the client.
The function runs on the server, so you can use server-side APIs and database access there.

6) Private Functions in GlideAjax Script Includes

Not every function in a Script Include should be callable from the client. Sometimes you want helper logic that stays internal.

If the Script Include extends AbstractAjaxProcessor, a function name starting with an underscore is treated as private.

Example

var AjaxScriptInclude = Class.create();
AjaxScriptInclude.prototype = Object.extendsObject(AbstractAjaxProcessor, {
    greetingFunction: function() {
        var userName = this.getParameter('sysparm_my_name');
        var msg = this._getMsg(userName);
        return msg;
    },

    _getMsg: function(userName) {
        return 'Hey there, ' + userName + '.';
    }
});

Here:

greetingFunction() is the public function called by GlideAjax.
_getMsg() is a private helper used only inside the Script Include.

This is a clean way to separate callable logic from internal utility logic.

7) Returning Multiple Values from GlideAjax

Since GlideAjax returns XML, one approach is to create additional XML nodes and attach attributes to them. This lets you return more than one value from the server.

The notes show an example returning greetings in English, French, and Spanish.

Server-side example

var AjaxScriptInclude = Class.create();
AjaxScriptInclude.prototype = Object.extendsObject(AbstractAjaxProcessor, {

    greetingFunction: function() {
        var userName = this.getParameter('sysparm_my_name');
        this._getEnglishMsg(userName);
        this._getFrenchMsg(userName);
        this._getSpanishMsg(userName);
    },

    _getEnglishMsg: function(userName) {
        var greeting = 'Howdy, ' + userName + '. How are you?';
        var msg = this.newItem('greeting');
        msg.setAttribute('lang', 'English');
        msg.setAttribute('value', greeting);
    },

    _getFrenchMsg: function(userName) {
        var greeting = 'Bonjour, ' + userName + '. Ça va?';
        var msg = this.newItem('greeting');
        msg.setAttribute('lang', 'French');
        msg.setAttribute('value', greeting);
    },

    _getSpanishMsg: function(userName) {
        var greeting = 'Hola, ' + userName + '. Cómo estás?';
        var msg = this.newItem('greeting');
        msg.setAttribute('lang', 'Spanish');
        msg.setAttribute('value', greeting);
    }
});

Client-side example

var ga = new GlideAjax('AjaxScriptInclude');
ga.addParam('sysparm_name', 'greetingFunction');
ga.addParam('sysparm_my_name', 'Tim');
ga.getXML(myCallBack);

function myCallBack(response) {
    var language;
    var grtng;
    var greetings = response.responseXML.getElementsByTagName('greeting');

    for (var i = 0; i < greetings.length; i++) {
        language = greetings[i].getAttribute('lang');
        grtng = greetings[i].getAttribute('value');
        console.log(language + ': ' + grtng);
    }
}

This works, but it is often more complex than needed. A simpler modern pattern is to return an object as JSON and parse it on the client.

😎 Why JSON Is Often the Better Option

If you need to return multiple values, JSON is often easier to maintain than raw XML node handling. It gives you a structured payload that is more readable for developers and easier to expand later.

The basic pattern is:

build an object or array on the server,
encode it as a JSON string,
return it through GlideAjax,
parse it on the client,
use the values in the UI.

The notes also mention that in scoped applications, JSON.stringify() and JSON.parse() should be used instead of older global-scope methods.

9) Return a Simple Object Using JSON

Server-side code

var AjaxUtils = Class.create();
AjaxUtils.prototype = Object.extendsObject(AbstractAjaxProcessor, {

    returnSimpleObject: function() {
        var obj = {};
        var sysId = this.getParameter('sysparm_sys_id');

        var almAssetGr = new GlideRecord("alm_asset");
        almAssetGr.addQuery('sys_id', sysId);
        almAssetGr.query();

        if (almAssetGr.next()) {
            obj.model = almAssetGr.getDisplayValue('model');
            obj.model_category = almAssetGr.getDisplayValue('model_category');

            var json = new JSON();
            var data = json.encode(obj);
        }

        return data;
    },

    type: 'AjaxUtils'
});

Client-side code

function onLoad() {
    var ga = new GlideAjax('AjaxUtils');
    ga.addParam('sysparm_name', 'returnSimpleObject');
    ga.addParam('sysparm_sys_id', g_form.getValue('sys_id'));
    ga.getXML(showMessage);
}

function showMessage(response) {
    var answer = response.responseXML.documentElement.getAttribute("answer");
    g_form.addInfoMessage('JSON String: ' + answer);

    answer = JSON.parse(answer);
    g_form.addInfoMessage('Asset Model: ' + answer.model);
    g_form.addInfoMessage('Asset Category: ' + answer.model_category);
}

This is a neat pattern when you want to send a small set of related fields back to the client.

10) Return a Simple Array Using JSON

Server-side code

var AjaxUtils = Class.create();
AjaxUtils.prototype = Object.extendsObject(AbstractAjaxProcessor, {

    returnSimpleArray: function() {
        var obj = [];
        var sysId = this.getParameter('sysparm_sys_id');

        var almAssetGr = new GlideRecord("alm_asset");
        almAssetGr.addQuery('sys_id', sysId);
        almAssetGr.query();

        if (almAssetGr.next()) {
            obj[0] = almAssetGr.getDisplayValue('model');
            obj[1] = almAssetGr.getDisplayValue('model_category');

            var json = new JSON();
            var data = json.encode(obj);
        }

        return data;
    },

    type: 'AjaxUtils'
});

Client-side code

function onLoad() {
    var ga = new GlideAjax('AjaxUtils');
    ga.addParam('sysparm_name', 'returnSimpleArray');
    ga.addParam('sysparm_sys_id', g_form.getValue('sys_id'));
    ga.getXML(showMessage);
}

function showMessage(response) {
    var answer = response.responseXML.documentElement.getAttribute("answer");
    g_form.addInfoMessage('JSON String: ' + answer);

    answer = JSON.parse(answer);

    for (var i = 0; i < answer.length; i++) {
        g_form.addInfoMessage(answer[i]);
    }
}

This is useful when the returned data is ordered rather than named.

11) Return an Array of Objects Using JSON

This is one of the most useful patterns when you need to send a list of structured rows to the client.

Server-side code

var AjaxUtils = Class.create();
AjaxUtils.prototype = Object.extendsObject(AbstractAjaxProcessor, {

    returnSimpleJSONObject: function() {
        var obj = [];
        var sysIds = '1bc1fa8837f3100044e0bfc8bcbe5d48,1fc1fa8837f3100044e0bfc8bcbe5d50,ffa96c0d3790200044e0bfc8bcbe5d87';

        var almAssetGr = new GlideRecord("alm_asset");
        almAssetGr.addEncodedQuery('sys_idIN' + sysIds);
        almAssetGr.query();

        while (almAssetGr.next()) {
            var payload = {};
            payload.model = almAssetGr.getDisplayValue('model');
            payload.model_category = almAssetGr.getDisplayValue('model_category');

            obj.push(payload);
        }

        var json = new JSON();
        var data = json.encode(obj);

        return data;
    },

    type: 'AjaxUtils'
});

Client-side code

function onLoad() {
    var ga = new GlideAjax('AjaxUtils');
    ga.addParam('sysparm_name', 'returnSimpleJSONObject');
    ga.getXML(showMessage);
}

function showMessage(response) {
    var answer = response.responseXML.documentElement.getAttribute("answer");
    g_form.addInfoMessage('JSON String: ' + answer);

    answer = JSON.parse(answer);

    for (var i = 0; i < answer.length; i++) {
        g_form.addInfoMessage(answer[i].model + " - " + answer[i].model_category);
    }
}

This is a practical pattern for returning row-style data such as assets, users, incidents, tasks, or catalog-related metadata.

12) Reference Fields and Display Values

A common problem in client scripts is setting a reference field value. A reference field query often triggers a synchronous server call, which can lock the browser briefly.

The notes point out a useful workaround: when setting a reference field, provide both the sys_id and the display value.

g_form.setValue('some_ref_field', varContainingSysID, 'The Display Value');

This helps the form avoid extra unnecessary work and gives the field a proper display label immediately.

13) Client-Side Encoded Queries

Another useful trick is that client-side GlideRecord does not support addEncodedQuery() the same way server-side GlideRecord does. However, if you call addQuery() with a single argument, that argument is treated as an encoded query.

Example

var gr = new GlideRecord('table_name');
gr.addQuery('active=true^approval=approved^assigned_to=62826bf03710200044e0bfc8bcbe5df1');
gr.query();

while (gr.next()) {
    // do some work
}

This can be very helpful when you need to keep a client-side query compact, especially when the logic is too complex for separate chained conditions.

14) GlideRecord and JavaScript Operators

The addQuery() method can accept different styles of input:

one argument: encoded query,
two arguments: field and value,
three arguments: field, operator, value.

Example

gr.addQuery('number', 'STARTSWITH', 'INC');

Some commonly used operators include:

=
>
<
>=
<=
!=
STARTSWITH
ENDSWITH
CONTAINS
DOES NOT CONTAIN
IN
INSTANCEOF

Examples:

gr.addQuery('short_description', 'CONTAINS', 'Help');
gr.addQuery('sys_class_name', 'INSTANCEOF', 'task');

These operators make your queries much more expressive and precise.

15) Best Practice Summary

Here is the core guidance from this article in one place:

Avoid synchronous client-side database work when possible.
Use callback functions for asynchronous client-side queries.
Use GlideAjax when a client script needs server-side data.
Keep server-side logic inside client-callable Script Includes.
Use private helper methods inside Script Includes when logic should not be exposed.
Prefer JSON when returning structured or multiple values.
Use display values when setting reference fields.
Use encoded queries carefully on the client.
Choose the right query operator for readable and efficient conditions.

16) Final Thoughts

GlideRecord, GlideAjax, and callback functions are not just separate APIs. They are pieces of a larger performance strategy.

If you think in terms of browser responsiveness, server responsibility, and data shape, the whole design becomes much cleaner:

let the browser stay light,
let the server do the heavy lifting,
and return only the data the client truly needs.

That approach will make your ServiceNow solutions faster, easier to maintain, and much more professional in real-world use.

If you are building client-side functionality in ServiceNow, GlideAjax is usually the safest and cleanest bridge between the browser and the server. And when you need richer data, JSON is often the most maintainable way to return it.

Feel Free To Follow Me on LinkedIn : https://www.linkedin.com/in/shaah/

question GlideRecord & GlideAjax in ServiceNow: Client-Side vs Server-Side in Community Central forum

GlideRecord & GlideAjax in ServiceNow: Client-Side vs Server-Side

1) Understanding Client-Side GlideRecord

2) Why Callback Functions Matter

Without a callback

With a callback

Example: asynchronous GlideRecord query

3) GlideAjax: The Server-Side Bridge for Client Scripts

4) GlideAjax From the Client

Example: client-side GlideAjax

What each line does

5) Building the GlideAjax Script Include

Example: server-side Script Include

Important points

6) Private Functions in GlideAjax Script Includes

Example

7) Returning Multiple Values from GlideAjax

Server-side example

Client-side example

😎 Why JSON Is Often the Better Option

9) Return a Simple Object Using JSON

Server-side code

Client-side code

10) Return a Simple Array Using JSON

Server-side code

Client-side code

11) Return an Array of Objects Using JSON

Server-side code

Client-side code

12) Reference Fields and Display Values

13) Client-Side Encoded Queries

Example

14) GlideRecord and JavaScript Operators

Example

15) Best Practice Summary

16) Final Thoughts