Scriptable and Non-scriptable Records

NetSuite is a cloud-based business management software platform that provides a comprehensive suite of applications for various industry tasks like financials, customer relationship management (CRM), e-commerce, inventory management, and more. The purpose of NetSuite is to help businesses streamline their operations, improve efficiency, and to gain real-time visibility into their financial and operational data.

NetSuite allows users to customize its features using SuiteScripts, which basically are JavaScript-based scripts. With SuiteScripts, businesses can tailor NetSuite’s functionality, automate various processes, and create custom workflows, ensuring that system aligns perfectly with their unique business needs.

However, it is important to note that not all the features of NetSuite are customizable, some of them are listed down below.

Scriptable Records:

Some common examples of scriptable records include: 

• Custom Records: Records that you create to store custom data specific to your business needs. 
• Transactions: Records such as Sales Orders, Purchase Orders, Invoices, etc. 
• Customers, Vendors, Employees: Records representing entities your business interacts with.
• Items: Records for products, services, or other items you deal with in your business.
• Custom Record Types: Records derived from standard record types but with added customizations.

Non-Scriptable Records: 

Non-scriptable records, on the other hand, are those types of records in NetSuite that cannot be directly customized or manipulated using SuiteScripts. SuiteScript APIs are not available for these records, and they are typically part of the core functionalities of NetSuite.

Some examples of non-scriptable records include:

• Currency: Records representing different currencies used in transactions. 
• Accounting Periods: Records defining fiscal periods for financial reporting. 
• Roles and Permissions: Records governing user roles and permissions.
• Reports: Custom reports based on the data lies within NetSuite.

Key Differences Between Scriptable and Non-scriptable Records

In NetSuite, the ability to automate or customize a record depends on whether it supports scripting. Scriptable records allow developers and administrators to interact with them through SuiteScript, while non-scriptable records are controlled by the system and cannot be modified through scripts. Understanding the differences helps teams determine where automation is feasible and where standard configuration is required.

Scriptable records provide flexibility for automation and custom logic. Non-scriptable records, on the other hand, are typically restricted because they manage internal system behavior or sensitive configurations.

Main Differences between Scriptable and Non-scriptable Records

Script support

• Scriptable records can be accessed and manipulated using SuiteScript APIs.
  
  
• Non-scriptable records do not support SuiteScript interaction and cannot be modified through scripts.
  

Customization capability

• Scriptable records allow developers to apply custom logic, automate workflows, and enforce validation rules.
  
  
• Non-scriptable records are limited to standard NetSuite configuration options without custom scripting.
  

Use cases

• Scriptable records are commonly used for transaction processing, automation, and data validation.
  
  
• Non-scriptable records are usually related to internal system operations or configuration settings that NetSuite manages.
  

Access through SuiteScript

• Scriptable records can be created, loaded, updated, or deleted through SuiteScript methods.
  
  
• Non-scriptable records cannot be accessed programmatically through SuiteScript.
  

Comparison Table

Feature	Scriptable Records	Non-scriptable Records
Script Support	Fully accessible through SuiteScript APIs	Not accessible through SuiteScript
Customization Capability	Allows custom workflows, validations, and automation	Limited to standard NetSuite configuration
Typical Use Cases	Transactions, customer records, inventory items	System configurations and internal records
Access Through SuiteScript	Can be created, updated, searched, and deleted using scripts	Cannot be accessed or modified programmatically

How to Identify Whether a Record Is Scriptable

Before working with automation or custom scripts in NetSuite, it is important to confirm whether a record supports scripting. NetSuite provides several ways for developers and administrators to check if a record can be accessed or manipulated using SuiteScript. Verifying this early helps avoid errors and ensures that scripting efforts are focused on records that support customization.

Using NetSuite Documentation

One of the most reliable ways to identify scriptable records is by reviewing NetSuite’s official documentation. NetSuite provides detailed information about record types and whether they support scripting through SuiteScript APIs.

Key things to look for include:

• Documentation that lists the record type and its script ID
• Supported SuiteScript operations such as create, load, update, or delete
• Details about available fields and sublists that can be accessed through scripts

This documentation helps developers understand how a record behaves and whether it can be customized through scripting.

Know more about SuiteScript Essentials in our guide. 

Checking the SuiteScript Record Browser

The SuiteScript Record Browser is another useful resource for identifying scriptable records. It provides a structured view of NetSuite record types and the fields associated with them.

When using the record browser, you can:

• Search for a specific record type or script ID
• Review the fields and sublists available for scripting
• Identify the internal IDs required for SuiteScript development

If a record appears in the SuiteScript Record Browser, it generally indicates that the record supports scripting.

Testing Through SuiteScript

Another practical approach is testing the record directly using SuiteScript. Developers can attempt to load or create a record using standard SuiteScript methods to confirm whether it supports scripting.

Typical testing steps include:

• Attempting to load the record using the record.load() method
• Trying to create or update a record through SuiteScript
• Checking for errors or restrictions that indicate the record is not scriptable

This testing approach helps verify scriptability in real scenarios and ensures the record behaves as expected during development.

Best Practices When Working With Scriptable Records

Scriptable records provide powerful customization capabilities in NetSuite, but they should be used carefully. Poorly written or excessive scripts can slow down system performance and create maintenance challenges. Following best practices helps ensure scripts remain efficient, reliable, and easy to manage.

Avoid Unnecessary Scripts

Not every business requirement needs a script. In many cases, standard NetSuite features such as workflows, saved searches, or configuration settings can solve the problem without adding custom code.

When deciding whether to create a script:

• Check if the requirement can be handled through standard configuration or workflows
  
  
• Avoid adding scripts for simple validations that built-in features can handle
  
  
• Keep scripts focused on specific automation or complex business logic

Reducing unnecessary scripts keeps the system easier to maintain and improves overall performance.

Follow NetSuite Governance Limits

NetSuite applies governance limits to control how scripts use system resources. These limits help prevent scripts from consuming too much processing power and slowing down the system.

To stay within governance limits:

• Optimize scripts to reduce excessive record loads and searches
  
  
• Avoid running large processes within a single script execution
  
  
• Use scheduled or map/reduce scripts for handling large data volumes

Managing governance limits properly helps maintain system stability and performance.

Test Scripts Before Deployment

Thorough testing ensures that scripts function correctly and do not interfere with existing workflows. Testing also helps identify errors, performance issues, or unexpected system behavior before the script goes live.

Important testing practices include:

• Running scripts in a sandbox environment before production deployment
  
  
• Testing scripts with different user roles and real business scenarios
  
  
• Reviewing system logs to identify errors or performance issues

Proper testing reduces implementation risks and ensures smoother system operations.

Conclusion

Understanding the difference between scriptable and non-scriptable records is important for anyone working with NetSuite customization. Scriptable records allow developers to automate processes, apply custom logic, and improve system efficiency through SuiteScript. Non-scriptable records, however, are restricted by the system and cannot be modified through scripting.

For developers and NetSuite administrators, knowing which records support scripting helps determine the right approach for automation and customization. It also prevents unnecessary development efforts on records that do not support scripting. By following best practices and focusing on supported records, teams can build efficient, maintainable customizations that enhance overall system performance.

FAQs

What are scriptable records in NetSuite?

Scriptable records are NetSuite record types that can be accessed and modified using SuiteScript. These records allow developers to automate tasks, apply custom validations, and integrate business logic into different workflows. They are commonly used to extend NetSuite functionality beyond standard configuration.

Common characteristics of scriptable records include:

• They support SuiteScript operations such as create, load, update, and delete
  
  
• They allow automation of business processes and workflows
  
  
• Developers can interact with their fields, sublists, and related data through scripts

What are non-scriptable records in NetSuite?

Non-scriptable records are record types that do not support interaction through SuiteScript. These records are usually controlled internally by NetSuite and are restricted to prevent unintended system changes. Because of these restrictions, developers cannot apply custom scripts directly to these records.

Important points about non-scriptable records include:

• They cannot be accessed or modified using SuiteScript APIs
  
  
• They are often used for system configuration or internal platform operations
  
  
• Customization is limited to standard settings and built-in features

Why does NetSuite restrict certain records from scripting?

NetSuite restricts some records from scripting to maintain system stability and protect critical configuration data. Allowing unrestricted access to certain internal records could create performance issues or cause unintended changes in system behavior.

Reasons for these restrictions include:

• Protecting core system configurations and internal processes
  
  
• Preventing scripts from modifying sensitive system-level records
  
  
• Maintaining platform performance and data integrity

How can developers determine whether a record supports SuiteScript?

Developers can verify whether a record is scriptable by reviewing available NetSuite resources and testing the record through SuiteScript. Identifying scriptable records early helps avoid development errors and saves time during customization.

Developers typically check scriptability by:

• Reviewing NetSuite documentation for supported record types
  
  
• Searching for the record in the SuiteScript Record Browser
  
  
• Attempting to load or create the record through SuiteScript methods

When should developers use scriptable records?

Scriptable records should be used when standard configuration cannot meet specific business requirements. They allow developers to build automation, enforce data validation, and integrate NetSuite with external systems.

Typical use cases include:

• Automating transaction processing and approval workflows
  
  
• Implementing custom validation rules for records
  
  
• Integrating NetSuite with CRM, eCommerce, or other external platforms
  
  
• Creating custom business logic for operational processes