NetSuite CPQ Custom Launch Parameters Explained

CPQ Ecommerce Integration 1.2.6 adds JSON launch parameters for configured line-item conversion, with session-only access and debugger input.

·6 min read·20 views·NetSuite 2026.2·View Oracle Docs

NetSuite CPQ Ecommerce Integration version 1.2.6 adds custom launch parameters for transaction line-item conversion. Launch scripts can pass JSON data to the conversion scheduled script, and Configurator actions can retrieve it to tailor conversion. The parameter object is temporary: it is not saved with the submitted configuration.

What Changes for CPQ Line-Item Conversion?

Custom launch parameters connect the script that starts conversion with the NetSuite CPQ Configurator actions that perform it. The launch script supplies a custom parameter object; actions retrieve either the complete object or an individual value. Oracle’s example passes a numeric desk identifier and an ecommerce channel string.

Use this handoff when conversion actions need context supplied by the launching script. Developers must still define how actions interpret each parameter and what happens when an expected value is missing.

For the broader conversion workflow, see converting multiple transaction line items into configured items.

Prerequisites and transaction impact

NetSuite CPQ Configurator must be installed to use NetSuite CPQ Ecommerce Integration. The integration converts standard transaction lines into configured lines and updates transactions in the background using Configurator products. Transactions can include lines originating in SuiteCommerce web stores or other ecommerce platforms.

Conversion can use transaction line items or information from custom line fields as materials, build a configuration from those materials, delete the original lines, and add the configured line item. Testing should therefore verify the resulting transaction lines as well as the configuration.

The processing script is CPQE-SC-BCL, with script ID customscript_cpqe_sc_bcl. Conversion requires a server-side script that launches this scheduled script and a Configurator product. A common implementation uses a user event script when a transaction is saved or edited. That script includes the product ID and a custom condition determining whether conversion should launch.

How Do You Pass Custom Launch Parameters?

In the user event script, set custscript_cpqe_scf_custparams to a JSON object serialized with JSON.stringify(). Each object key defines a parameter name, and each associated value can be any valid JSON value.

This excerpt shows the documented task creation and parameter assignment, with a closing wrapper added:

javascript
1define(['N/task'], (_nTask) => {
2 // Other launch logic goes here.
3
4 _nTask.create({
5 taskType: _nTask.TaskType.SCHEDULED_SCRIPT,
6 scriptId: 'customscript_cpqe_sc_bcl',
7 params: {
8 custscript_cpqe_scf_productid: '13',
9 custscript_cpqe_scf_rectype: 'salesorder',
10 custscript_cpqe_scf_oid: '1086',
11 custscript_cpqe_scf_nosub: false,
12 custscript_cpqe_scf_custparams: JSON.stringify({
13 deskId: 48933,
14 channel: 'ecommerce'
15 })
16 }
17 });
18
19 // Other launch logic goes here.
20});

Implementation note: This is a task-creation excerpt, not a complete deployable user event script or task-submission workflow. Incorporate the custom parameter assignment into your existing launch implementation rather than treating this code as a replacement.

The custom-parameter interfaces are:

InterfaceWhere it is usedPurpose
custscript_cpqe_scf_custparamsLaunch scriptSupplies the custom object as a JSON string.
SOLE/LAUNCH_PARAMETERSConfigurator actionsRetrieves the complete custom parameter object.
getLaunchParameter('parameter')Configurator actionsRetrieves one named value; returns undefined if it does not exist.
Custom parameters (JSON)Conversion testing and debuggingAccepts a JSON object for test inputs.

Agree on parameter names and expected types between the launch-script developer and the Configurator action author. In the example, deskId is numeric and channel is a string. Test the types wherever action logic depends on that distinction.

How Do Configurator Actions Read the Parameters?

Retrieve the complete object

Use the new predefined answer SOLE/LAUNCH_PARAMETERS:

javascript
var parameters = getValue('SOLE', 'LAUNCH_PARAMETERS');
if (parameters) {
console.log(JSON.stringify(parameters));
}

During development, compare the retrieved object with the launch payload to check that the action receives the intended names and values. Logging the object verifies the handoff; it does not by itself verify the conversion outcome.

Retrieve one named value

Use getLaunchParameter('parameter') when an action needs an individual value:

javascript
var deskId = getLaunchParameter('deskId');
console.log(deskId);

If the named parameter does not exist, the function returns undefined. Define how actions should handle that case. Avoid treating every falsy value as missing: valid JSON values can include false, 0, and an empty string.

Persistence limitation: The predefined answer stores custom launch parameters only for the current configuration session. Its value is not saved in the configuration record when the configuration is submitted. Do not design later processing around retrieving this temporary object from the saved configuration.

Where Do Actions Fit in the Conversion Sequence?

The integration makes one pass through four processing phases:

  1. Runs before-event actions in sequence-number order. The event is the building-block refresh.
  2. Refreshes building blocks in sequence-number order.
  3. Runs after-event actions in sequence-number order.
  4. Submits the configuration to the transaction, including creating the configuration record and adding configured items.

Review where parameter-dependent actions sit in this sequence. Test whether their logic produces the intended building-block and transaction results, rather than stopping after confirming that a parameter was received.

How Can You Test and Debug Custom Parameters?

Before writing the server-side launcher, use the Ecommerce Integration debugger to validate the Configurator product containing the conversion tasks. The new Custom parameters (JSON) field lets you supply a JSON object while testing and debugging conversion.

To begin creating a testing task, go to CPQ > eComm Integration > BC-Launcher and click New CPQE BC Launcher. Name the task and select the transaction containing the data to convert.

Three debugging modes are available:

ModeLogs and intended use
Client scriptDetailed console logs for checking the product and its conversion actions.
Suitelet scriptDetailed logs in a separate browser tab for investigating simple server-side product logic. Limited to 1,000 governance usage units.
Scheduled scriptComplete logs under the scheduled script’s Execution Log subtab.

For scheduled-script logs, go to Customization > Scripting > Scripts, set Type to Scheduled, locate CPQE-SC-BCL, and open Execution Log. To process the transaction multiple times, enter a number in the Counter field.

Test both a representative parameter object and an object missing a key your actions expect. Check the resulting configured items, not just logged inputs. For related scripting context, see NetSuite CPQ functions and governance.

Who This Affects

  • SuiteScript developers adopting the feature: Add the serialized object to the launcher and agree on parameter names with action authors.
  • CPQ administrators and product designers: Implement parameter-aware actions and test them within the conversion sequence.
  • Ecommerce integration teams: Validate conversion for transactions originating in SuiteCommerce or other ecommerce platforms.
  • Transaction owners and testers: Confirm that original lines are replaced with the expected configured items.

Key Takeaways

  • Custom launch parameters are supported in CPQ Ecommerce Integration version 1.2.6.
  • Send the custom object through custscript_cpqe_scf_custparams using JSON.stringify().
  • Read the object through SOLE/LAUNCH_PARAMETERS, or retrieve one value with getLaunchParameter().
  • Missing named parameters return undefined; the predefined answer is not saved with the configuration.
  • Use Custom parameters (JSON) during debugging and verify both action behavior and resulting transaction lines.

Frequently Asked Questions (4)

How do I pass custom JSON values from a launch script into CPQ line-item conversion?
Set `custscript_cpqe_scf_custparams` in the scheduled-script task parameters to `JSON.stringify()` of your object. Each object key becomes a parameter name, and values can be any valid JSON value. For example, the payload can include a numeric `deskId` and a string `channel`.
How can a Configurator action read all launch parameters or just one value?
Use `getValue('SOLE', 'LAUNCH_PARAMETERS')` to retrieve the complete parameter object. Use `getLaunchParameter('parameter')` to retrieve one named value; it returns `undefined` when that key is absent. Actions should distinguish missing values from valid falsy values such as `false`, `0`, or an empty string.
Are custom launch parameters saved with the submitted configuration?
No. Custom launch parameters are available only during the current configuration session and are not saved in the configuration record when it is submitted. Later processing should not depend on retrieving this temporary object from the saved configuration.
How can I test custom parameters before implementing the server-side launcher?
Use the Ecommerce Integration debugger and enter a JSON object in the **Custom parameters (JSON)** field when creating a CPQE BC Launcher task. The client, Suitelet, and scheduled-script debugging modes provide different logs; Suitelet debugging is limited to 1,000 governance usage units. Test representative and missing-key inputs, then verify the configured transaction lines as well as the logged parameters.

Weekly Update History (1)

NetSuite CPQadded

Added an entry for Add Custom Parameters for Conversion into Configured Line Items.

View Oracle Docs
Source: Add Custom Parameters for Conversion into Configured Line Items — Oracle NetSuite Help Center. This article was generated from official Oracle documentation and enriched with additional context and best practices.

Was this article helpful?

More in NetSuite CPQ

View all NetSuite CPQ articles →

Also from NetSuite 2026.2

View all NetSuite 2026.2 changes →