SuiteScript 1.0 enters end-of-life support in NetSuite 2027.1, which means Oracle fixes critical issues only. By 2028.2, Oracle says all new and existing scripts must use SuiteScript 2.1, and support for 1.0, 2.0, and 2.x is expected to be removed. SuiteScript 2.1 became the standard scripting model in 2026.2. The practical move is to inventory your scripts now and convert or retire them in phases.
Key Takeaways
- Oracle says SuiteScript 2.1 became the standard in 2026.2, 1.0 enters end-of-life support in 2027.1, and all scripts must use 2.1 by 2028.2.
- The scope is wider than 1.0. Oracle's notice also covers SuiteScript 2.0 and scripts annotated 2.0 or 2.x.
- NetSuite Next does not change these dates. They begin in the same release as the Next rollout, but Oracle presents them as separate changes.
- You can list the affected scripts yourself with a script list filter, a saved search, or a SuiteAnalytics workbook.
- For each script you can update it, test it in a 2.1 runtime first, or retire it. Retiring unused scripts is the cheapest option.
Part of the NetSuite Next, Without the Nerves series.
Last reviewed October 5, 2026 against Oracle's published NetSuite Next documentation. NetSuite Next is changing often, so check Oracle's pages for the current state.
Some deadlines get ignored because they are far off. This one is staged, which makes it easy to misjudge. The first step has already happened, the second is a few months away, and the last one is where every script in your account has to comply.
What is the SuiteScript 1.0 end-of-support timeline?
Oracle publishes the schedule in its Transitioning To SuiteScript 2.1 guide. It describes a phased rollout across four releases.
| NetSuite release | What changes, per Oracle | What it means for you |
|---|---|---|
| 2026.2 | SuiteScript 2.1 becomes the standard scripting model for new and existing scripts | Start your inventory and write new scripts in 2.1 |
| 2027.1 | SuiteScript 1.0 enters end-of-life support, covering critical issues only. Other problems require converting to 2.1 first | A 1.0 script with a bug is now your problem to convert, not Oracle's to fix |
| 2028.1 | 1.0 scripts can no longer be deployed in new accounts but remain deployable in existing ones. 2.0 and 2.x scripts run as 2.1 by default | Test 2.0 and 2.x scripts in a 2.1 runtime before this release |
| 2028.2 | All new and existing scripts must use SuiteScript 2.1 | Every script you still need has to be converted. Retire the rest |
Oracle words the final removal carefully: support for legacy SuiteScript versions and annotation values is expected to be removed in NetSuite 2028.2. Re-check the page before you commit dates to a project plan, because the word expected leaves room for change.
Is this only a SuiteScript 1.0 problem?
No, and this is the part many people miss. Oracle's notice covers SuiteScript 1.0 and 2.0, and also scripts annotated with @NApiVersion 2.0 or @NApiVersion 2.x. An account customized over many years often carries a mix, so the 1.0 headline understates the scope.
The effect differs by version. Per the timeline, 1.0 faces the earlier cliff, since it loses general support in 2027.1. Scripts on 2.0 and 2.x begin running as 2.1 by default in 2028.1, which is why testing them in a 2.1 runtime before then is worth doing.
Does NetSuite Next change any of this?
Not the dates. Oracle's SuiteScript guide does not tie the transition to NetSuite Next, and the two are separate changes. They do start in the same release: Oracle's rollout announcement says Next begins rolling out with release 2026.2, which is also when 2.1 became the standard.
For you, that overlap matters in practice. If you are already going through your customizations to prepare for Next, you are opening the same inventory. Scripts that touch the page structure need a Next review, and scripts on older versions need a version decision. Doing both in one pass is less work than two passes a year apart.
How do you find which scripts are affected?
Oracle's guide on identifying scripts that are not using SuiteScript 2.1 gives three routes, depending on how much detail you need.
For a quick look, go to Customization, Scripting, Scripts and filter the API Version to something other than 2.1. For a reusable list, build a saved search on script records that excludes scripts where API Version is 2.1, and add fields such as name, ID, script type, owner, and description. For larger accounts, a SuiteAnalytics workbook lets you group by API version or script type.
One caution from Oracle's page: the API version on the script record shows the version associated with the script. Before you update one, review the source and its dependencies to see whether code changes are needed.
What are your options for each script?
Oracle says to decide, for each legacy script, whether to update it to 2.1, test its compatibility with the 2.1 runtime before updating, or retire it if it is inactive, obsolete, or duplicated. The third option deserves more attention than it gets. Every script you retire is one you never have to migrate, test, or maintain.
Oracle's migration path guide lists the resources behind each choice: account-level 2.1 enablement for testing 2.0 and 2.x server scripts, an agent skill that can automatically upgrade scripts and custom objects, an AI-assisted developer assistant, and manual guides for moving from 1.0 or 2.0. It adds that automated tools can speed the work, but you must review all generated code, object updates, and deployment changes before using them in production.
Why is a conversion never as mechanical as it looks?
Because the versions differ in more than syntax. Oracle's comparison of SuiteScript 1.0 and 2.1 script types says the two differ in script structure, entry point names, context objects, and APIs. Some 1.0 functions have no 2.1 equivalent at all. Oracle names nlapiSetRecoverPoint and nlapiYieldScript, and says scheduled scripts execute differently in 2.1, so a line-by-line translation is the wrong frame.
Moving from 2.0 to 2.1 looks safer, and it is, but it is not free. Oracle's differences between 2.0 and 2.1 page says 2.1 uses a different runtime engine, and some 2.0 capabilities function differently under it. The list includes invalid JSON parsing, error object properties, strict mode, date formats when converting to local date strings, parseInt, and string and return type behavior in RESTlets. A script can pass a code review and still return a different result.
How should you sequence the work?
Oracle's recommended approach is to prioritize scripts that support critical business processes, with higher priority for high-usage scripts, integrations, and scripts with complex dependencies. Move scripts in manageable groups, not all at once, and monitor execution and performance after each group. It also suggests starting with low-complexity scripts to learn the process before tackling harder ones.
Testing deserves its own plan. Oracle's validation list is specific: run the converted script in a sandbox, test all entry points, check sublist behavior, searches, record operations, data handling, and error handling, confirm deployment records and SDF objects still point to the right files, and compare behavior against the original. A script that compiles is not a script that behaves the same.
Where you test matters too. Do the conversion work in a sandbox. Then use Release Preview to see how the account behaves against the coming release. Oracle's suggested Release Preview test plan covers business workflows, custom reports and forms, other customizations, SuiteScript deployments, SOAP web services integrations, and installed SuiteApps, and it says to note the scheduled events in production and disable them before the account is upgraded.
What should you do this quarter?
Build the inventory. It takes little effort and answers the question that drives everything else: how many scripts, on which versions, doing what. From there, mark the ones nobody can explain, the ones tied to critical processes, and the ones that look redundant. Retire what you can before you convert anything.
If the count is large or the owners have left, that is the point to get help. TVG's SuiteScript 2.1 update service follows the same sequence Oracle describes: assess, prioritize, migrate, and validate in a sandbox, with AI-assisted tooling drafting conversions that engineers review and test. That is how the service is described on its page. Outcomes depend on your scripts.
Joe's take: decide first, convert second
I would expect a mature NetSuite account to have a mix of versions. Newer development is more likely to be 2.0 or 2.1, while older accounts can still have 1.0 scripts that have been quietly doing their jobs for years. What tends to surprise customers is not the number of old scripts. It is how little anyone knows about some of them. The original developer is gone, the documentation is thin, the business process has changed, and nobody is completely sure whether the script is still necessary.
So I would not approach this as find every 1.0 script and convert it. The first step is understanding what you have, what it does, who owns the process, and whether you still need it. Is the script deployed? When does it execute? Is the process still used? Has native NetSuite functionality replaced it? Is another customization doing the same thing? Does anyone depend on the output? The decision should be retire, replace, redesign, or convert, not automatically convert. There is no value in spending time converting ten-year-old technical debt just because it exists. I wouldn't put a percentage on how many scripts are retirement candidates without reviewing the account, but I absolutely expect some.
For priority, I would go by business impact and dependencies, not age. Scripts attached to order processing, billing, revenue, fulfillment, integrations, and financial processes come first, along with anything that moves a lot of data. Risk is different from priority. A small script can be risky if nobody understands what depends on it. Integrations deserve attention because changing one side can affect another system. Scheduled scripts can work most of the time and fail under volume. Client scripts are tied to user behavior and the browser, so they need careful testing. Vendor-supplied bundles are a separate category: I wouldn't start modifying vendor code, I would first find out who owns it and whether the vendor has an updated version. For some older scheduled processes, the right answer may not be a direct conversion. Oracle says Map/Reduce, which has no 1.0 equivalent, suits large datasets that can be divided into small independent parts.
The mistake is assuming it is mechanical. I care much more about behavioral equivalence than whether the new code looks like a clean translation of the old code. And "the script ran without an error" is not a test result I would accept. Did it create or update the correct records and use the correct values? Did permissions behave? Did downstream workflows fire? Did the integration receive what it expected? Did scheduled processing finish at realistic volumes? A script can run successfully and still produce the wrong business result.
AI assistance is a good fit for conversion. It can handle repetitive translation, spot old APIs, suggest 2.1 modules, explain unfamiliar legacy code, and draft test cases. I would not treat generated code as production-ready because it compiles. A human who understands NetSuite still has to review what the script is supposed to do, the APIs, permissions, record operations, execution context, error handling, governance, dependencies, and the consequences if it behaves differently. I am most cautious when a script touches financial transactions, integrations, large data sets, or approvals. AI can accelerate conversion. It cannot own the decision that the converted script is equivalent and safe to deploy.
Finally, yes, combine the discovery work. If you are already inventorying scripts for 2.1, another team shouldn't rediscover the same customizations for NetSuite Next. The questions overlap: what is deployed, what forms it affects, which processes depend on it, who uses it, what is obsolete. I would still run them as separate testing tracks, because a script can be perfectly valid SuiteScript 2.1 and still need attention in how it interacts with the Next experience.
Frequently Asked Questions
When does SuiteScript 1.0 reach end of support?
According to Oracle, SuiteScript 1.0 enters end-of-life support in NetSuite 2027.1, which covers critical issues only. In 2028.1, 1.0 scripts can no longer be deployed in new accounts but still can in existing ones. By 2028.2, all new and existing scripts must use SuiteScript 2.1, and Oracle says removal of legacy support is expected.
What is the SuiteScript 2.1 migration deadline?
Oracle's timeline ends in NetSuite 2028.2, when all new and existing scripts must use SuiteScript 2.1. Support for SuiteScript 1.0, 2.0, and scripts annotated 2.0 or 2.x is expected to be removed then. Earlier steps matter too: 1.0 loses general support in 2027.1, and 2.0 and 2.x scripts run as 2.1 by default in 2028.1.
Does SuiteScript 2.0 stop working?
Oracle says 2.0 and 2.x scripts start running as SuiteScript 2.1 by default in 2028.1, and that support for them is expected to be removed in 2028.2. Test them in a 2.1 runtime before then. Oracle's migration guide describes enabling SuiteScript 2.1 at the account level so you can try current server scripts without changing code.
How do I find scripts that are not using SuiteScript 2.1?
Oracle gives three methods. Filter the script list under Customization, Scripting, Scripts by API Version, build a saved search that excludes scripts where API Version is 2.1, or build a SuiteAnalytics workbook to group scripts by version or type. Review each script's source before updating, since the API version alone does not show what code changes are needed.
Should I migrate or retire my old scripts?
Both are options. Oracle says to decide for each legacy script whether to update it to 2.1, test it in the 2.1 runtime first, or retire it if it is inactive, obsolete, or duplicated. Retiring costs the least, so check what each script still does before you spend effort converting it.
Is the SuiteScript change related to NetSuite Next?
Not directly. Oracle's SuiteScript guide treats the 2.1 transition as a separate change, though it begins in the same release, 2026.2, as the NetSuite Next rollout. If you are reviewing customizations for Next anyway, you can inventory scripts for both reasons in one pass and save a second review later.
Should I convert every SuiteScript 1.0 script?
No. Decide for each script whether to retire, replace, redesign, or convert it. Check whether it is still deployed, whether the process is still in use, and whether native NetSuite functionality or another customization now does the job. Oracle also lists retiring inactive, obsolete, or duplicated scripts as an option, and converting a script you no longer need is wasted effort.
Not sure how many scripts you have?
That is a common starting point, and it is fixable in an afternoon. The harder part is deciding what to do with what you find, especially when the person who wrote a script left years ago.
TVG can inventory your scripts, rank them by risk, and plan the conversion in phases. See the SuiteScript 2.1 update service, read about a NetSuite Health Assessment, or start with the NetSuite Next guide.
Ready to Get More From NetSuite?
Whether you are optimizing your current environment, planning your next project, or looking for a partner who does more than close tickets, our NetSuite team is ready to help.
Joseph Lang
Joseph Lang is the Director of inVESTED PRO at The Vested Group. With more than 13 years of NetSuite experience, he helps organizations maximize the value of their ERP investment through strategic guidance, operational improvements, and ongoing managed services. Joseph specializes in NetSuite optimization, manufacturing, warehouse management, inventory management, procurement, and SuiteCommerce, helping clients continuously improve their business processes and long-term ERP performance.





