LLMs Inside ERP: How AI Language Models Are Being Used in NetSuite Workflows in 2026

The promise of AI inside ERP is real but often oversold. NetSuite does not have a built-in LLM as of 2026. AI capabilities come from SuiteScript code calling external APIs — Claude, OpenAI, or any REST-accessible model — over the N/https module. That makes every AI use case in NetSuite a custom integration, with the same governance, error-handling, and versioning discipline any external API call needs. This guide covers the three highest-value patterns in production today; for the full catalog of trigger points — Workflow Action, User Event, Suitelet, and RESTlet — see Calling AI APIs from SuiteScript in 2026.

Contents

• Use Case 1: Purchase Order Approval Drafting
• Use Case 2: GL Account Suggestion
• Use Case 3: Customer Communication Generation
• Handling Rate Limits, Timeouts, and Retries
• Governance Budget for LLM Calls
• Choosing and Future-Proofing the Model You Call
• Production Checklist Before Shipping

Use Case 1: Purchase Order Approval Drafting

When a PO arrives for approval, a Workflow Action Script calls a SuiteScript that fetches the PO lines, vendor history, and budget data, then asks an LLM to draft a recommendation memo. The approver receives a structured summary — PO total, vendor payment history, budget availability, and a recommended action — instead of raw PO data they have to cross-reference by hand.

The script itself is a small amount of code around one https.post() call:

define(['N/https', 'N/record', 'N/runtime'], (https, record, runtime) => {
  function draftRecommendation(poId) {
    const po = record.load({ type: record.Type.PURCHASE_ORDER, id: poId });
    const prompt = buildPrompt(po); // pulls total, vendor, budget fields

    const response = https.post({
      url: 'https://api.anthropic.com/v1/messages',
      headers: {
        'content-type': 'application/json',
        'x-api-key': runtime.getCurrentScript().getParameter({ name: 'custscript_llm_key' }),
        'anthropic-version': '2023-06-01'
      },
      body: JSON.stringify({
        model: runtime.getCurrentScript().getParameter({ name: 'custscript_llm_model' }),
        max_tokens: 300,
        messages: [{ role: 'user', content: prompt }]
      })
    });

    if (response.code !== 200) return handleFailure(response); // see below
    return JSON.parse(response.body);
  }
  return { draftRecommendation };
});

Two details matter beyond the happy path: the API key and the model name are both Script Parameters, not string literals — see the security callout below — and response.code is checked explicitly, because https.post() returns whatever status the provider sent rather than throwing on a bad one.

Use Case 2: GL Account Suggestion for Uncategorised Transactions

Uncategorised vendor bills and expense reports sit in a holding account waiting for manual classification. An LLM reads the line description, vendor name, and amount, then suggests the most likely GL account with a confidence score. High-confidence suggestions — most teams start the threshold around 90%, a business decision, not a technical one — auto-assign; everything below it routes to the accountant with the suggestion pre-populated rather than blank.

This use case runs at volume — a backlog of a few hundred uncategorised lines is normal after a batch import — so it belongs in a Scheduled Script or Map/Reduce script, not a User Event firing on every save. A Map/Reduce script’s map or reduce stage can make one https.post() call per key without threatening the 1,000-unit ceiling a User Event script would hit after roughly the same number of calls plus the record loads around them. The governance math for each script type is in the table below.

Use Case 3: Customer Communication Generation

When a customer invoice is overdue, a Scheduled Script generates a personalised reminder email: the LLM takes the invoice details, payment history, and account standing and drafts a tone-appropriate email — firm for persistently late payers, gentle for first-time late payers with an otherwise good history. The draft is queued for review and sent through NetSuite’s own email framework, not sent automatically by the script that generated it.

That review step is not optional. An LLM drafting a collections email occasionally gets the tone wrong — too soft for a repeat late payer, or too firm for an account that paid the day after the due date because of a bank holiday. A person catches that in seconds; an unsupervised send doesn’t get a second chance once it lands in the customer’s inbox.

Handling Rate Limits, Timeouts, and Retries

https.post() does not throw when the provider returns a 429 or a 5xx — it returns a normal response object with response.code set to whatever the provider sent. A script that only checks for a thrown exception treats a rate-limited call as a success and writes an empty or malformed recommendation to the record. Every call needs an explicit status check before the response body is parsed.

NetSuite also adds its own fixed timeouts on top of whatever the provider does: a 5-second connection timeout and a 45-second timeout on sending the request payload, neither configurable through the call’s options. A slow provider response past that window fails on NetSuite’s side before the provider’s own rate-limit or overload response ever arrives.

SuiteScript has no blocking sleep call, so classic exponential backoff — wait, then retry, inside one execution — is not available server-side the way it is in a long-running process. A busy-wait loop burns governance and wall-clock time without actually waiting. The pattern that fits NetSuite’s execution model is architectural rather than a delay loop: catch the 429 or 5xx, log it, and let the record wait for the next scheduled run or Map/Reduce pass to retry, rather than blocking the current execution to ride out the limit. The same queue-and-requeue logic covers NetSuite’s own APIs too — the retry-on-429 patterns that work against NetSuite’s REST API port directly to LLM calls, since neither side of the https.post() call gets special treatment from SuiteScript’s governance model.

Governance Budget for LLM Calls

Every https.post() call costs a flat 10 governance units, confirmed against NetSuite’s own API governance table — regardless of whether the destination is Claude, OpenAI, or any other REST API. Ten units is cheap in isolation. The real constraint is what else the script does in the same execution: loading the PO, vendor, and budget records in Use Case 1 costs more governance than the LLM call that follows them.

Verdict: a single-record User Event or Workflow Action script can afford one or two LLM calls once its own record I/O is accounted for; anything processing more than a handful of records per run belongs in a Scheduled Script or Map/Reduce, which have the headroom — and in Map/Reduce’s case, no fixed ceiling at all — to make the call worthwhile.

Choosing and Future-Proofing the Model You Call

A SuiteScript that hardcodes a model name in the request body works until the provider retires that model. Anthropic gives at least 60 days’ notice before retiring a publicly released model, moving it through Active, Legacy, Deprecated, and Retired stages and emailing accounts with active usage — but that notice is only useful if the model name lives in a Script Parameter instead of application logic. Claude Opus 4.1, for example, was marked deprecated on June 5, 2026 and retired on August 5, 2026: a script still calling it by name past that date gets a failed request, not a graceful fallback.

The fix is the same discipline as the API key: store custscript_llm_model as a Script Parameter, not a string literal in the prompt-building code. Swapping models becomes a deployment configuration change instead of a script edit and redeploy. It is also worth testing the replacement model against the same PO-approval, GL-suggestion, and customer-email prompts before migrating — output structure and refusal behavior can shift enough between model versions to break a downstream JSON.parse() that assumed a stable shape. The tradeoffs between providers for this kind of work, including how their retirement schedules compare, are covered in Claude vs GPT vs Gemini for Business in 2026.

Production Checklist Before Shipping an LLM Feature in SuiteScript

• Store the LLM API key and the model ID as Script Parameters, never as string literals
• Check response.code explicitly after every https.post() call — it does not throw on a provider 4xx or 5xx
• Call Script.getRemainingUsage() before an LLM call in a User Event or Workflow Action script instead of assuming a fixed budget
• Route batch use cases like GL account suggestion through a Scheduled Script or Map/Reduce, never a User Event loop
• Require a person to confirm any AI-drafted change before it posts a transaction or sends a customer communication
• Log each prompt and response to a custom record for audit purposes, not only to the Execution Log, which rolls off
• Treat a repeated 429 or 5xx as queued-for-next-run, not a reason to block the current execution waiting for it to clear
• Confirm the replacement model produces the same response shape before migrating off a deprecated model ID

The governance and error-handling discipline above is the same whether the record is a purchase order or an expense report — and it’s usually not what breaks first in production. What breaks first is a search or a set of record loads quietly eating governance the script’s author didn’t budget for, surfacing only once the LLM call starts failing intermittently under real volume. A SuiteScript code review catches that before it reaches production, not after.

These three patterns — approval drafting, account suggestion, and communication generation — are a starting set, not a ceiling. The broader shift from rule-based automation to AI-assisted workflows across commerce and ERP stacks is covered across the AI for commerce teams guide series, including governance and reliability patterns that repeat outside NetSuite specifically.

Frequently asked questions

Related guides

• AI Invoice Reconciliation in NetSuite: A SuiteScript Pattern That Scales Past 10,000 Invoices a Month
• How AI Is Reshaping E-Commerce Integrations: Why a Model in the Data Path Breaks Retry
• AI-Generated Product Data at Scale: What NetSuite Integrators Need to Handle in 2026