---
sourceDocument: Australia API Reference
sourceDocumentLink: https://servicenow-prod.fluidtopics.net/r/api-reference

 Release :

    - australia

ft:locale :

    - en-US

ft:publication_title :

    - Australia API Reference

ft:clusterId :

    - crapiref

bundleId :

    - crapiref

workflow :

    - Creator


---

# Using extension points to extend application functionality

# Using extension points to extend application functionality {#ariaid-title1}

Release version: Australia  
Updated March 12, 2026  
![](https://www.servicenow.com/docs/portal-asset/ico-clock) 6 minutes to read
Summarize  
![AI sparkle icon](https://servicenow.com/docs/portal-asset/ai-sparkle-icon) Summarized using AI  
This content was generated using new OpenAI-powered functionality. Results are provided on an as is basis and are not guaranteed to be accurate or complete.  

## Summary of Using extension points to extend application functionality

Extension points in ServiceNow enable you to extend and customize application functionality without modifying the original application code.
This approach helps maintain upgrade compatibility by keeping customizations separate from the core code.
Extension points act as integration hooks where data passes to and from custom code that conforms to defined interfaces.
Show full answer Show less  
You can use built-in extension points available in selected ServiceNow AI Platform applications like Customer Service Management and Field Service Management, or create your own extension points when developing custom applications in your instance. This structured customization method supports maintainability and reduces upgrade risks.

## Types of Extension Points

* **Scripted Extension Points:** Used in server-side script includes to store JavaScript functions and object classes.
* **UI Extension Points:** Embedded in server-side UI macros (e.g., HTML extensions) to add custom content to UI pages without altering the base UI.
* **Client Extension Points:** Used in client-side UI scripting, such as UI scripts, to modify forms or client-side behavior without direct code changes.

## Creating and Using Extension Points

When building custom applications, you can define extension points to allow future customizations with minimal impact on base code. Key steps include:

* Identify strategic locations in your application code for extension points to handle custom script includes, UI macros, or UI scripts.
* Define the structure and interface of the extension point, specifying how customizations interact with the application and what data they return.
* Create artifacts (script includes, UI macros, UI scripts) that register with the extension points using the GlideScriptedExtensionPoint - Scoped method.
* Control scope access by restricting extension points to a specific application or allowing them globally across scopes.

## Registering and Processing Custom Artifacts

Custom artifacts are registered against extension points to link the base application's extension interface with your custom code. When the application runs, it detects registered artifacts, sends them required data, collects their output, and integrates the results back into the application workflow.

## Debugging and Logging

Enabling debugging and logging on extension points is critical for diagnosing issues with custom artifacts. It allows you to:

* Set breakpoints and troubleshoot script includes, UI macros, or UI scripts.
* Track when extension points find and execute custom instances, including success and failure metrics.

## Benefits for ServiceNow Customers

* Extend and customize applications safely without modifying core code, ensuring smoother upgrades and maintenance.
* Use well-defined integration points to manage custom logic and UI changes modularly.
* Leverage pre-built extension points in standard ServiceNow AI Platform applications or create your own for custom apps.
* Maintain clear separation of customizations with robust debugging and logging support for easier troubleshooting.  
Use extension points to extend the functionality of an application without altering the
original application code. You can use pre-existing extension points available in selected ServiceNow AI Platform applications, or you can add
extension points when you develop custom applications in your own instance.

## Using extension points {#extension-points__section_blc_wft_pdb}

By using extension points, you can integrate customizations without actually altering the
core components in the application code. Extension points can prevent your custom code
interactions from breaking, which often occurs after an upgrade if you directly embed the
custom code into the application code.

Extension points that are embedded in the application code act as out-points, where data
passes to the custom code, and as in-points that handle the returned results. When creating
an application, the returned data or objects must conform to the requirements that you
define for the extension point.  
Note:  
Some out-of-box configured CSM Query Rules cannot be changed or disabled because they are also used in constants within a business rule.

## Types of extension points {#extension-points__section_zm3_dvf_kgb}

You can create extension points to process the custom code that uses the following types of artifacts:

Scripted extension points
:   Extension points in server-side script includes that store JavaScript functions and
    object classes. To learn about scripts includes and how to implement scripted
    extension points in the application and custom code, see:  
    * [Script includes](https://servicenow-prod.fluidtopics.net/Hoik~X~X9CHwHnAu~RFj4w#c_ScriptIncludes "Script includes are used to store JavaScript that runs on the server.")
    * [Creating and adding a scripted extension point](https://servicenow-prod.fluidtopics.net/2dsdKiBtvHgMe~b5vwPWaQ "When developing an application, create scripted extension points and add them to the script includes in the application code. Use a scripted extension point to designate the specific location where data or objects can be sent to a registered custom script include and where returned results are processed.")
    * [Using extension points to extend application functionality](https://servicenow-prod.fluidtopics.net/~vULb6Dfi1GVuu_EHscENQ "Use extension points to extend the functionality of an application without altering the original application code. You can use pre-existing extension points available in selected ServiceNow AI Platform applications, or you can add extension points when you develop custom applications in your own instance.")
    {#extension-points__ul_vr2_kyc_cgb}

UI extension points

:   Extension points that are used in server-side UI macros such as HTML extensions. UI macros are discrete scripted components that you can add to the user interface. You use them to add custom content to a UI page, without having to directly modify the page. For example, you can use UI macros to add headers and footers to the standard Knowledge Base View (kb_view) UI page in which KB articles appear.

    To learn about UI macros and how to implement UI extension points in the application and custom code, see:

    * [UI macros](https://servicenow-prod.fluidtopics.net/IYo_4UimOlN4l86_Ehyzhw#c_UIMacros "UI macros are discrete scripted components administrators can add to the user interface.")
    * [Creating and adding a UI extension point](https://servicenow-prod.fluidtopics.net/WddqBdMZNkuyZpJ5V05tXg#impl-ui-ext-pts-base-code "When developing an application, create UI extension points and add them to the server-side UI macros, such as HTML extensions, or the UI pages in the base application code.")
    * [Using extension points to extend application functionality](https://servicenow-prod.fluidtopics.net/~vULb6Dfi1GVuu_EHscENQ "Use extension points to extend the functionality of an application without altering the original application code. You can use pre-existing extension points available in selected ServiceNow AI Platform applications, or you can add extension points when you develop custom applications in your own instance.")
    {#extension-points__ul_csp_ncd_cgb}

Client extension points

:   Extension points that are used in client-side UI scripting, typically for modifying forms. UI scripts enable you to package client-side JavaScript into a reusable form, which is similar to how script includes store server-side JavaScript. You can create UI scripts and run them from client scripts, from other client-side script objects, and from HTML code.

    To learn about UI scripts and how to implement client extension points in application and custom code, see:

    * [UI scripts](https://servicenow-prod.fluidtopics.net/Fagkb5yuEGMtJ8xpRAmFeQ#c_UIScripts "UI scripts provide a way to package client-side JavaScript into a reusable form, similar to how script includes store server-side JavaScript. Administrators can create UI scripts and run them from client scripts and other client-side script objects and from HTML code.")
    * [Creating and adding a client extension point](https://servicenow-prod.fluidtopics.net/tRcOZmGqlORV6bWpQl~xng "Create client extension points and add them to the client-side UI scripts in the base application code.")
    * [Using extension points to extend application functionality](https://servicenow-prod.fluidtopics.net/~vULb6Dfi1GVuu_EHscENQ "Use extension points to extend the functionality of an application without altering the original application code. You can use pre-existing extension points available in selected ServiceNow AI Platform applications, or you can add extension points when you develop custom applications in your own instance.")
    {#extension-points__ul_yvg_rcd_cgb}

When you use extension points to process customizations, you create a defined structure for
integrating custom data or functionality into an application. Custom server-side script
includes, UI macros such as HTML extensions, and client-side UI scripts are all external to
the application code and only interact with it at specified extension points.

## Application code {#extension-points__section_a2j_wgy_xgb}

The term application code refers to:

Standard application code
:   Standard, or base, application code that comprises the ServiceNow AI Platform.  
    Pre-defined extension points are already embedded in certain applications, such as Customer Service Management and Field Service Management. To learn more about the ServiceNow AI Platform applications that contain pre-defined extension points, see the following:{#extension-points__table_qqv_xzh_zgb__entry__2}

    | Application | Extension point topic |
    |-|-|
    | Coaching | [Resolve Coaching issues](https://www.servicenow.com/docs/access?context=cf-coaching-troubleshooting&version=australia&pubname=australia-it-service-management&ft:locale=en-US) |
    | Continual Improvement Management | [Improvement with other applications](https://www.servicenow.com/docs/access?context=cim-integration&version=australia&pubname=australia-it-service-management&ft:locale=en-US) |
    | Customer Service Management | [Extension points in Customer Service Management](https://www.servicenow.com/docs/access?context=extension-points-customer-service&version=australia&pubname=australia-customer-service-management&ft:locale=en-US) |
    | Customer Service Management | [Creating custom user roles](https://www.servicenow.com/docs/access?context=creating-custom-csm-user-roles&version=australia&pubname=australia-customer-service-management&ft:locale=en-US) |
    | Customer Service Management | [CSM integration with Change Management](https://www.servicenow.com/docs/access?context=csm-integration-sm-change&version=australia&pubname=australia-customer-service-management&ft:locale=en-US) |
    | Customer Service Management | [CSM integration with Incident Management](https://www.servicenow.com/docs/access?context=csm-integration-sm-incident&version=australia&pubname=australia-customer-service-management&ft:locale=en-US) |
    | Customer Service Management | [CSM integration with Problem Management](https://www.servicenow.com/docs/access?context=csm-integration-sm-problem&version=australia&pubname=australia-customer-service-management&ft:locale=en-US) |
    | Customer Service Management | [CSM integration with Request Management](https://www.servicenow.com/docs/access?context=csm-integration-sm-request&version=australia&pubname=australia-customer-service-management&ft:locale=en-US) |
    | Field Service Management | [Extension points in Field Service Management](https://www.servicenow.com/docs/access?context=extension-points-field-service&version=australia&pubname=australia-field-service-management&ft:locale=en-US) |
    | Knowledge Management | [Use extension points for Knowledge Management](https://www.servicenow.com/docs/access?context=extension-points-km-plugins&version=australia&pubname=australia-servicenow-platform&ft:locale=en-US) |
    | Orchestration | [Client software distribution extension network](https://www.servicenow.com/docs/access?context=c_CSDExtensionFramework&version=australia&pubname=australia-servicenow-platform&ft:locale=en-US) [Installed with client software distribution](https://www.servicenow.com/docs/access?context=r_IWClientSWDist&version=australia&pubname=australia-servicenow-platform&ft:locale=en-US) |
    | Password Reset | [Password Reset script includes](https://www.servicenow.com/docs/access?context=c_InstalledPasswordResetScripts&version=australia&pubname=australia-servicenow-platform&ft:locale=en-US) |
    [ ]

    {#extension-points__table_qqv_xzh_zgb}

Internally developed custom applications for your enterprise
:   You can add extension points to handle the registration of custom artifacts that are
    used to modify or extend the functionality of an application. When developers create
    custom code, they register, or pair, specific custom artifacts with specific extension
    points. Adding extension points enables integration of future customizations without
    having to change your base code.

## Creating an extension point in the application code {#extension-points__section_mf1_3pg_sdb}

You want to ensure that the internally developed applications that you create for your
enterprise can be properly customized, combined, and upgraded as needed. Extension points
enable you to modify the functionality and user interface for an application without editing
its core components. Use of extension points also creates a highly defined structure for
functionality extensions.  
When you create an extension point, you can restrict its use to the application scope in which it is defined or specify that the extension point can run in all scopes globally. If the application scope is restricted, customizations that are registered against the extension point can only run in the designated application scope. Before designing and building an application that includes extension points, you should:

* Identify where to place extension points in the application code to accommodate custom script includes, UI macros, or UI scripts.
* Determine the content and structure for an extension point. This definition should describe how a customization should be structured, how it interacts with the application code, and how the data that is returned by a customization at the extension point is processed.
{#extension-points__ul_mz5_1hj_vdb}  
To create extension points and embed them in the application code, perform the following tasks:

1. Create an extension point and define its custom interface. This is an example of a scripted extension point.

2. Designate specific places in the application code where data or objects can be sent to a customization, and where data is returned.
3. Create an artifact, such as a script include, UI macro, or UI script, that calls the [GlideScriptedExtensionPoint - Scoped](https://servicenow-prod.fluidtopics.net/QsEDT9I_Um55prxU2nE2RQ#GlideScriptedExtPtScopedAPI "The GlideScriptedExtensionPoint API provides a method that returns the extension instances associated with a specified extension point.") method. This method identifies the extension point at which registered custom artifacts execute in the application code.
{#extension-points__ol_ffm_c2g_pfb}

## Enabling debugging and logging {#extension-points__section_h5t_gty_xgb}

When you create a extension point, you should also enable debugging and logging. Debugging
and logging help you to identify and fix issues that are related to the use of custom
artifacts with an extension point. When you enable the debugger, you can set break points in
script includes, UI macros, or UI scripts. You can check the logs to see the following
details:

* When an extension point finds active extension instances, including the total number of extension instances found and the time each extension instance was found.
* When an extension point executes extension instances, including the total number of custom artifacts executed and the time of each executed. It also includes the total number that failed to execute and the time at which each extension instance failed.

{#extension-points__ul_wj3_vmr_rdb}  
Note:  
To learn more about how to enable debugging and how it works, see:

* [Script Debugger and Session Log](https://servicenow-prod.fluidtopics.net/Qk3QA~3g2w9rozVs7GAelw "The Script Debugger enables users with the script_debugger role to debug server-side JavaScript. Users with the log_debugger role can use the Session Log to view and download required logs.")
* [Debugging applications](https://servicenow-prod.fluidtopics.net/zWRejxL3I04qzCYLasNIuQ#c_DebuggingApplications "Application developers can display debug messages about configuration records to help them troubleshoot issues. The Debug Scopes module provides information about the system switching between custom applications to run server-side scripts.")
* [Writing to the debug log](https://servicenow-prod.fluidtopics.net/upVCYhFfSEZAXuqu3pnl5Q#c_WritingToTheDebugLog "To write to the debug log in your client-side JavaScript, or UI policies, make a call to the global function jslog().")
{#extension-points__ul_rzj_psy_xgb}

## Registering a custom artifact against an extension point {#extension-points__section_up3_thj_vdb}

When you are customizing an application, you extend the base functionality by using custom
artifacts, such as server-side script includes, UI macros, or client-side UI scripts. To
design and build custom artifacts, perform the following tasks:  
1. Review the listing of available extension points that are appropriate to the specific type of custom artifact that you are creating.
   * These listings include extension points that you created and any pre-defined extension points that are embedded in the ServiceNow AI Platform functions.
   * Each listing includes information about an extension point in the application code that calls a custom artifact and what data or objects should be returned to it.
   {#extension-points__ul_wsn_hxf_kgb}
2. Select an extension point.
3. Determine how to structure the custom artifact. The structure should be based on the extension point descriptions. The descriptions include the requirements for using the artifact with the custom code and where the artifact will located in the base application code.
4. Create the custom artifact and code when you register it against the selected extension point. Through registration, you create an extension instance record that links the extension point definition to its implementation in the custom artifact.
{#extension-points__ol_xxk_nfg_pfb}

## How registered custom artifacts are processed {#extension-points__section_gnb_nqy_rdb}

When the application code executes and finds an embedded API call containing an extension point, it:

1. Uses the extension point in the API call to determine which custom artifacts are registered against it.
2. Sends the appropriate data or objects to the registered custom artifacts.
3. Collects the returned output from each custom artifact.
4. Processes and incorporates the returned results into the base application.
{#extension-points__ol_i1m_5vl_rdb}
* **[Using scripted extension points in server-side scripts](https://servicenow-prod.fluidtopics.net/fylTEXcEvZMCKZPpOG7daA)**   
  Use the scripted extension points in the server-side script includes that store JavaScript functions and object classes. By using extension points, you can integrate customizations without actually altering the core components in the application code.
* **[Using UI extension points in server-side UI macros](https://servicenow-prod.fluidtopics.net/JzVI_5V87N_TDIk~RMklyA)**   
  Use UI extension points in the server-side UI macros, such as HTML extensions, to add custom content to a UI page without having to directly modify the page. By using UI extension points, you can integrate customizations without actually altering the core components in the application code.
* **[Using client extension points in client-side UI scripting](https://servicenow-prod.fluidtopics.net/lNkbg~JZenGuj8T3tL6dsw)**   
  Use client extension points in client-side UI scripting to modify forms, so that you do not have to directly modify the form. By using client extension points, you can integrate customizations without actually altering the core components in the application code.