---
# === IDENTITY ===
id: business/erp-integration/celigo-netsuite-integration/2026
canonical_question: "What are Celigo capabilities for NetSuite - 80+ pre-built integrations, endpoint pricing model?"
aliases:
  - "How does Celigo integrate with NetSuite?"
  - "Celigo integrator.io NetSuite features and pricing"
  - "Celigo iPaaS pre-built NetSuite integration apps"
  - "Celigo endpoint-based pricing for NetSuite integrations"
entity_type: erp_integration
domain: business > erp-integration > celigo-netsuite-integration
region: global
jurisdiction: global
temporal_scope: 2024-2026

# === SYSTEM PROFILE ===
systems:
  - name: "Celigo integrator.io"
    vendor: "Celigo"
    version: "2026.1.1"
    edition: "Standard, Professional, Premium, Enterprise"
    deployment: "cloud"
    api_surface: "REST"
  - name: "Oracle NetSuite"
    vendor: "Oracle"
    version: "2024.2+"
    edition: "All editions"
    deployment: "cloud"
    api_surface: "RESTlet, SuiteTalk SOAP, SuiteTalk REST, SuiteQL"

# === VERIFICATION ===
last_verified: 2026-03-02
confidence: 0.88
version: 1.0
first_published: 2026-03-02

# === TEMPORAL VALIDITY ===
temporal_validity:
  status: volatile
  last_breaking_change: "2026.1.1 — new AI error management enhancements"
  next_review: 2026-08-29
  change_sensitivity: high

# === CONSTRAINTS ===
constraints:
  - "Endpoint-based pricing: Standard edition limited to 3 endpoints, Professional to 5, Premium to 10; only Enterprise offers unlimited"
  - "NetSuite concurrency governance: combined RESTlet + web services concurrency must not exceed account limit (default 5, extendable with SuiteCloud Plus licenses)"
  - "Celigo API rate limit: leaky-bucket algorithm with 1,000 bucket size, 300 tokens/sec fill rate (~1,080,000 requests/hour)"
  - "Flow limits: Standard edition limited to 16 flows, Professional to 100 flows; only Premium+ offers unlimited flows"
  - "NetSuite point limits: exceeding per-request governance units (ss_out_of_points) requires reducing batch size in import configuration"
  - "SuiteApp bundle (ID 20038) must be installed in NetSuite for RESTlet-based connections; Web Services API is fallback but requires SuiteCloud Plus license for high-volume exports"

# === SKIP CONDITIONS ===
skip_this_unit_if:
  - condition: "User needs direct NetSuite SuiteTalk API development without iPaaS middleware"
    use_instead: "business/erp-integration/netsuite-suitetalk-api/2026"
  - condition: "User needs MuleSoft or Boomi for NetSuite instead of Celigo"
    use_instead: "business/erp-integration/mulesoft-netsuite-integration/2026"
  - condition: "User needs SAP or Salesforce integration without NetSuite"
    use_instead: "business/erp-integration/salesforce-rest-api/2026"

# === AGENT HINTS ===
inputs_needed:
  - key: integration_pattern
    question: "What integration pattern do you need?"
    type: choice
    options:
      - "real-time sync (individual records, <1s latency)"
      - "batch/bulk (scheduled, high volume)"
      - "event-driven (webhook, CDC, platform events)"
      - "file-based (CSV/XML import/export)"
  - key: data_volume
    question: "What's your daily data volume?"
    type: choice
    options:
      - "< 1,000 records/day"
      - "1,000-100,000 records/day"
      - "> 100,000 records/day"
  - key: direction
    question: "What's the data flow direction?"
    type: choice
    options:
      - "inbound (writing to NetSuite)"
      - "outbound (reading from NetSuite)"
      - "bidirectional sync"
  - key: target_system
    question: "Which system are you integrating with NetSuite?"
    type: choice
    options:
      - "Shopify / eCommerce"
      - "Salesforce / CRM"
      - "Amazon / marketplace"
      - "3PL / logistics"
      - "Custom / other"

# === DISTRIBUTION ===
canonical_source: "https://knowledgelib.io/business/erp-integration/celigo-netsuite-integration/2026"
suggested_citation: "Source: knowledgelib.io -- AI Knowledge Library (verified 2026-03-02)"

# === RELATED UNITS ===
related_kos:
  depends_on: []
  related_to:
    - id: "business/erp-integration/netsuite-suitetalk-api/2026"
      label: "NetSuite SuiteTalk API capabilities (underlying API Celigo uses)"
  solves: []
  alternative_to:
    - id: "business/erp-integration/mulesoft-netsuite-integration/2026"
      label: "MuleSoft Anypoint for NetSuite (enterprise-grade alternative)"
    - id: "business/erp-integration/boomi-netsuite-integration/2026"
      label: "Boomi for NetSuite (broader enterprise iPaaS alternative)"
    - id: "business/erp-integration/workato-netsuite-integration/2026"
      label: "Workato for NetSuite (AI-powered recipe-based alternative)"
  often_confused_with:
    - id: "business/erp-integration/netsuite-suitetalk-api/2026"
      label: "Direct SuiteTalk API (no middleware, requires custom development)"

# === SOURCES ===
sources:
  - id: src1
    title: "The Leader in NetSuite Integrations"
    author: Celigo
    url: https://www.celigo.com/integrations/netsuite/
    type: official_docs
    published: 2026-01-15
    reliability: authoritative
  - id: src2
    title: "Celigo integrator.io API Documentation"
    author: Celigo
    url: https://github.com/celigo/integrator-api-docs
    type: official_docs
    published: 2025-06-01
    reliability: high
  - id: src3
    title: "Compliance with NetSuite Concurrency Governance"
    author: Celigo
    url: https://www.celigo.com/blog/compliance-with-netsuite-concurrency-governance/
    type: technical_blog
    published: 2024-08-15
    reliability: high
  - id: src4
    title: "Install and use the integrator.io SuiteApp"
    author: Celigo
    url: https://docs.celigo.com/hc/en-us/articles/360050643132-Install-and-use-the-integrator-io-SuiteApp
    type: official_docs
    published: 2025-10-01
    reliability: authoritative
  - id: src5
    title: "Celigo Pricing Guide 2026"
    author: ERP Peers
    url: https://erppeers.com/celigo-pricing-guide/
    type: industry_report
    published: 2026-01-10
    reliability: moderate_high
  - id: src6
    title: "Picking the Best Integration Platform: Celigo, Boomi, Workato or MuleSoft"
    author: Eric Popivker
    url: https://medium.com/entech-solutions/picking-the-best-integration-platform-celigo-boomi-workato-or-mulesoft-5ead0c264737
    type: community_resource
    published: 2025-03-01
    reliability: moderate
  - id: src7
    title: "Celigo Platform and Pricing"
    author: Celigo
    url: https://www.celigo.com/platform/pricing/
    type: official_docs
    published: 2026-02-01
    reliability: authoritative
---

# Celigo NetSuite Integration: Capabilities, Pre-Built Apps, and Endpoint Pricing

## TL;DR

- **Bottom line**: Celigo is the #1 NetSuite integration partner with 80+ pre-built integration apps covering eCommerce (Shopify, Amazon), CRM (Salesforce, HubSpot), EDI, 3PL, and banking -- endpoint-based flat-rate pricing eliminates per-transaction surprises. [src1]
- **Key limit**: Endpoint-based pricing caps connections per tier -- Standard: 3 endpoints/16 flows, Professional: 5/100, Premium: 10/unlimited, Enterprise: unlimited/unlimited. [src5, src7]
- **Watch out for**: NetSuite concurrency governance is shared across ALL integrations (Celigo + non-Celigo) -- exceeding your account limit causes SSS_REQUEST_LIMIT_EXCEEDED errors across all connections. [src3]
- **Best for**: Mid-market NetSuite shops needing turnkey integrations with Shopify, Amazon, Salesforce, or 3PL providers without custom SuiteTalk development. [src1, src6]
- **Authentication**: Token-based auth (TBA) via Celigo SuiteApp bundle (ID 20038); OAuth 1.0 available for direct SuiteTalk/SuiteQL connections. [src4]

## System Profile

Celigo integrator.io is a cloud-native iPaaS (integration platform as a service) that has been Oracle NetSuite's largest integration partner for over a decade. The platform connects NetSuite to 100+ external applications through pre-built SmartConnector apps and a visual flow designer. Celigo communicates with NetSuite primarily via custom RESTlets deployed through the integrator.io SuiteApp bundle (ID 20038), with optional SuiteTalk SOAP/REST API fallback for high-volume scenarios requiring SuiteCloud Plus licensing. [src1, src4]

This card covers Celigo's integration capabilities with NetSuite, including the pre-built integration app library, endpoint-based pricing model, concurrency governance, error handling, and comparison with alternative iPaaS platforms. It does NOT cover direct NetSuite API development without middleware (see the SuiteTalk API card instead).

| Property | Value |
|---|---|
| **Vendor** | Celigo |
| **System** | integrator.io (release 2026.1.1) + Oracle NetSuite (2024.2+) |
| **API Surface** | RESTlet (primary), SuiteTalk SOAP, SuiteTalk REST, SuiteQL |
| **Current Platform Version** | 2026.1.1 |
| **Editions Covered** | Standard, Professional, Premium, Enterprise |
| **Deployment** | Cloud (SaaS) |
| **API Docs URL** | [Celigo API Docs](https://github.com/celigo/integrator-api-docs) |
| **Status** | GA |

## API Surfaces & Capabilities

Celigo uses multiple API surfaces to communicate with NetSuite, selected automatically or manually per flow. [src1, src4]

| API Surface | Protocol | Best For | Max Records/Request | Rate Limit | Real-time? | Bulk? |
|---|---|---|---|---|---|---|
| Celigo RESTlet (Bundle 20038) | HTTPS/JSON | Standard CRUD, saved searches, custom record operations | Configurable batch size | NetSuite concurrency governance | Yes | Yes (batched) |
| SuiteTalk SOAP (Web Services) | HTTPS/XML | High-volume exports, SuiteCloud Plus licensed accounts | 1,000 records/search page | NetSuite concurrency governance | Yes | Yes |
| SuiteTalk REST | HTTPS/JSON | SuiteQL queries, modern REST operations | 1,000 records/page | NetSuite concurrency governance | Yes | No |
| SuiteQL via HTTP Connector | HTTPS/JSON | Complex SQL-like queries, analytics exports | 1,000 records/page | NetSuite concurrency governance | Yes | No |
| Celigo Platform API | HTTPS/JSON | Managing integrations, flows, connections programmatically | N/A | 1,000 bucket / 300 tokens/sec | Yes | N/A |
| Custom RESTlet Proxy | HTTPS/JSON | Custom business logic via user-built RESTlets | Custom | NetSuite concurrency governance | Yes | Custom |

## Rate Limits & Quotas

### Per-Request Limits

| Limit Type | Value | Applies To | Notes |
|---|---|---|---|
| Celigo API bucket size | 1,000 tokens | Celigo Platform API | Leaky-bucket algorithm [src2] |
| Celigo API fill rate | 300 tokens/second | Celigo Platform API | ~1,080,000 requests/hour max [src2] |
| NetSuite saved search page | 1,000 records | RESTlet exports | Celigo auto-paginates [src4] |
| SuiteTalk search page | 1,000 records | SOAP/REST exports | Standard NetSuite limit |
| Import batch size | Configurable (default varies) | All imports | Reduce to avoid ss_out_of_points [src3] |
| Max burst concurrency | 50 | HTTP connections | When auto-recover rate limits + burst mode enabled [src3] |

### Rolling / Daily Limits

| Limit Type | Value | Window | Edition Differences |
|---|---|---|---|
| NetSuite concurrency (default) | 5 concurrent requests | Per account | Extendable with SuiteCloud Plus licenses (10 additional per license) [src3] |
| Celigo endpoint limit | 3 / 5 / 10 / unlimited | Per subscription | Standard / Professional / Premium / Enterprise [src5, src7] |
| Celigo flow limit | 16 / 100 / unlimited / unlimited | Per subscription | Standard / Professional / Premium / Enterprise [src5] |
| NetSuite API request limit | Fair use (no hard daily cap) | Per account | Governed by concurrency, not daily count |

### Transaction / Governor Limits

NetSuite governance applies to all operations routed through Celigo. [src3]

| Limit Type | Per-Transaction Value | Notes |
|---|---|---|
| SuiteScript governance units | 5,000 (RESTlet scheduled), 1,000 (RESTlet client) | Exceeding triggers ss_out_of_points error |
| Concurrent web services + RESTlet requests | Account limit (default 5) | Combined across ALL integrations -- not just Celigo [src3] |
| SuiteTalk concurrent requests | Shared with RESTlet pool | SuiteCloud Plus adds 10 per license |
| Max record size per request | ~5 MB | NetSuite payload limit |
| Saved search row limit | 100,000 rows | NetSuite export cap per saved search |

## Authentication

Celigo supports multiple authentication flows for NetSuite connections. [src4]

| Flow | Use When | Token Lifetime | Refresh? | Notes |
|---|---|---|---|---|
| Token-Based Auth (Automatic) | Standard setup with Celigo SuiteApp installed | Until revoked | Automatic via SuiteApp | Recommended -- requires bundle 20038 [src4] |
| Token-Based Auth (Manual) | Manual token management preferred | Until revoked | Manual token rotation | Requires creating access token in NetSuite |
| OAuth 1.0 (HTTP Connector) | Direct SuiteTalk/SuiteQL access without RESTlet | Until revoked | N/A (signature-based) | For universal HTTP connector to SuiteTalk APIs [src4] |
| Basic Auth (Legacy) | Legacy accounts only | Session-based | No | Deprecated -- migrate to TBA immediately |

### Authentication Gotchas

- **SuiteApp bundle (ID 20038) is required for automatic TBA** -- without it, you must use manual TBA or the Web Services API fallback. The bundle creates the role "Celigo integrator.io Full Access Role w/o 2FA [Locked]". [src4]
- **Token ID and Token Secret are displayed only once** in NetSuite when creating access tokens -- save them immediately in a password manager or you must regenerate. [src4]
- **2FA/MFA conflicts**: The Celigo integration role is specifically "w/o 2FA" -- do NOT enable mandatory 2FA for integration users or connections will break. [src4]
- **OAuth 1.0 for SuiteTalk requires the SuiteTalk URI** found at Setup > Company > Company Information > Company URLs in NetSuite. [src4]

## Constraints
<!-- Agents: read this section before recommending any integration approach from this unit.
     These are hard constraints that must not be violated. -->

- **Endpoint cap is a hard licensing limit**: Standard = 3 endpoints, Professional = 5, Premium = 10. Each unique application (Shopify, Salesforce, etc.) consumes 1 endpoint. Exceeding requires upgrade. [src5, src7]
- **NetSuite concurrency is shared globally**: All Celigo + non-Celigo integrations share the same concurrency pool. Sum of all RESTlet concurrency settings must not exceed account limit. [src3]
- **SuiteCloud Plus license required for high-volume**: Web Services API (non-RESTlet) requires SuiteCloud Plus. Each license adds 10 concurrent connections. [src3, src4]
- **Bundle 20038 installation requires admin access**: Cannot install in sandboxes with restricted admin, or in accounts with SuiteApp installation locks. [src4]
- **Flow limits are hard**: Standard edition caps at 16 flows total -- complex integrations with multiple data objects (orders, items, customers, payments) can exhaust this quickly. [src5]
- **Pre-built integration apps count toward endpoint and flow limits**: Installing a Shopify-NetSuite SmartConnector uses 2 endpoints (Shopify + NetSuite) and multiple flows. [src7]

## Integration Pattern Decision Tree

```
START -- User needs to integrate external system with NetSuite via Celigo
|-- Do they have a pre-built SmartConnector app?
|   |-- YES (Shopify, Amazon, Salesforce, HubSpot, etc.)
|   |   |-- Install SmartConnector from Celigo Marketplace
|   |   |-- Configure connection credentials + field mappings
|   |   +-- Pre-built flows handle standard business processes
|   +-- NO (custom application)
|       |-- Use Celigo Flow Builder with universal HTTP connector
|       +-- Build custom export/import/mapping flows
|-- What's the data volume?
|   |-- < 1,000 records/day
|   |   +-- Standard RESTlet connection (default concurrency)
|   |-- 1,000-100,000 records/day
|   |   |-- Increase batch size + connection concurrency
|   |   +-- Consider SuiteCloud Plus license for more concurrent slots
|   +-- > 100,000 records/day
|       |-- SuiteCloud Plus license required (Web Services API)
|       |-- Multiple concurrent connections (40+ demonstrated) [src3]
|       +-- Coordinate concurrency budget with other integrations
|-- What's the direction?
|   |-- Inbound (writing to NetSuite)
|   |   |-- Use Celigo import flows with batch size tuning
|   |   +-- Enable error management with auto-retry for transient failures
|   |-- Outbound (reading from NetSuite)
|   |   |-- Use saved search exports or SuiteQL queries
|   |   +-- RESTlet for standard, Web Services for high volume
|   +-- Bidirectional
|       |-- Define master record source per entity type
|       |-- Implement conflict resolution in Celigo flow logic
|       +-- Use timestamp-based delta sync to avoid loops
+-- Which Celigo edition?
    |-- 1-3 apps + simple flows --> Standard ($600+/mo)
    |-- 4-5 apps + moderate complexity --> Professional ($1,500+/mo)
    |-- 6-10 apps + unlimited flows --> Premium ($3,000+/mo)
    +-- 10+ apps + enterprise governance --> Enterprise (custom pricing)
```

## Quick Reference

### Pre-Built NetSuite Integration Apps (80+ Available)

| Category | Applications | Key Flows | Typical Use Case |
|---|---|---|---|
| eCommerce | Shopify, Shopify Markets, BigCommerce, WooCommerce, Magento 2 | Orders, inventory sync, fulfillment, returns | Omnichannel retail order-to-cash |
| Marketplace | Amazon, Amazon MCF, eBay, Walmart | Listings, orders, FBA fulfillment, settlements | Multi-marketplace sellers |
| CRM | Salesforce, HubSpot, Zoho CRM | Contacts, opportunities, quotes, invoices | Lead-to-cash automation |
| Marketing | Act-On, Marketo, Mailchimp | Leads, campaigns, engagement data | Marketing attribution |
| Finance | Stripe, PayPal, Bill.com, Avalara | Payments, reconciliation, tax calculation | Financial close automation |
| HR | ADP, Workday HCM, BambooHR | Employee records, payroll, time-off | HR-to-finance sync |
| 3PL/Logistics | ShipStation, ShipBob, Fulfillment by Amazon | Shipments, tracking, inventory | Fulfillment automation |
| EDI | SPS Commerce, TrueCommerce | POs, ASNs, invoices, 850/810/856 | B2B trading partner automation |
| Banking | Various bank feeds | Transactions, reconciliation, receipts | Bank-to-NetSuite auto-reconciliation |
| Procurement | Coupa, SAP Ariba | Purchase orders, invoices, approvals | Procure-to-pay automation |

[src1]

### Celigo Edition Comparison

| Feature | Standard | Professional | Premium | Enterprise |
|---|---|---|---|---|
| Endpoints | 3 | 5 | 10 | Unlimited |
| Flows | 16 | 100 | Unlimited | Unlimited |
| Integration apps | 2 | 4 | 9 | 19 |
| Trading partners | -- | 5 | 10 | 15 |
| Sandbox | No | Yes | Yes | Yes |
| SSO | No | No | Yes | Yes |
| API management | Limited | Yes | Yes | Yes |
| External FTP | No | No | Yes | Yes |
| Support tier | Standard | Preferred | Premier | Premier |
| Approx. cost/mo | $600+ | $1,500+ | $3,000+ | Custom |

[src5, src7]

## Step-by-Step Integration Guide

### 1. Install Celigo SuiteApp bundle in NetSuite

The integrator.io SuiteApp (bundle ID 20038) deploys custom RESTlets that Celigo uses to communicate with NetSuite. [src4]

```
1. In NetSuite, navigate to: Customization > SuiteBundled > Search & Install Bundles
2. Search for "Celigo" or bundle ID "20038"
3. Select "Celigo integrator.io" (SuiteScript 2.0 version)
4. Click Install
5. Accept permissions and wait for installation to complete
6. Verify: Setup > Integration > Manage Integrations > shows "Celigo integrator.io"
```

**Verify**: Navigate to Setup > Integration > Manage Integrations --> you should see "Celigo integrator.io" listed with Status = Enabled.

### 2. Create NetSuite connection in Celigo

Set up token-based authentication between Celigo and your NetSuite account. [src4]

```
1. In Celigo: Settings > Connections > New Connection > NetSuite
2. Select authentication type: "Token Based Auth (Automatic)" (recommended)
3. Enter NetSuite Account ID (found at Setup > Company > Company Information)
4. Click "Connect to NetSuite" -- browser redirects to NetSuite login
5. Authorize integrator.io SuiteApp access
6. Connection is created with auto-managed tokens
```

**Verify**: Click "Test Connection" in Celigo --> expected: green checkmark with "Connection successful".

### 3. Install or build integration flows

Either install a pre-built SmartConnector or create custom flows. [src1]

```
For pre-built app (e.g., Shopify-NetSuite):
1. Navigate to Celigo Marketplace > search "Shopify NetSuite"
2. Click Install > select your NetSuite connection
3. Configure Shopify connection (API key + password)
4. Map fields (pre-populated with defaults, customize as needed)
5. Enable flows: Orders, Inventory, Customers, Fulfillments

For custom flow:
1. Integrations > New Integration > New Flow
2. Configure Export (source system) with connection + query/search
3. Configure Import (target system) with connection + record type
4. Define field mappings with transformations
5. Set schedule (real-time, scheduled, or manual trigger)
```

**Verify**: Run a test flow with a small batch --> expected: records appear in target system with no errors in Celigo dashboard.

### 4. Configure concurrency and error handling

Tune connection concurrency to respect NetSuite governance and enable auto-retry. [src3]

```
1. In Celigo: Connections > select NetSuite connection > Advanced
2. Set "RESTlet Concurrency Level" (default: 1, max: account limit)
3. Enable "Auto-recover rate limit errors" for automatic retry
4. Set retry policy: up to 4 retries with increasing delay
5. Verify: sum of ALL connections' concurrency <= NetSuite account limit
   (Check in NetSuite: Setup > Integration > Web Services Preferences
    > ACCOUNT CONCURRENCY LIMIT)
```

**Verify**: Navigate to Setup > Integration > Web Services Preferences in NetSuite --> confirm ACCOUNT CONCURRENCY LIMIT >= sum of all Celigo + non-Celigo concurrency settings.

## Code Examples

### JavaScript/Node.js: Query Celigo Platform API for flow status

```javascript
// Input:  Celigo API bearer token, integration ID
// Output: List of flows with status and last run info

const fetch = require('node-fetch'); // v3.3.2

const CELIGO_API_TOKEN = process.env.CELIGO_API_TOKEN;
const INTEGRATION_ID = 'your-integration-id';

async function getFlowStatus() {
  const resp = await fetch(
    `https://api.integrator.io/v1/integrations/${INTEGRATION_ID}/flows`,
    {
      headers: {
        'Authorization': `Bearer ${CELIGO_API_TOKEN}`,
        'Content-Type': 'application/json'
      }
    }
  );

  if (resp.status === 429) {
    // Rate limit hit -- wait and retry
    const retryAfter = parseInt(resp.headers.get('retry-after') || '5');
    console.log(`Rate limited. Retrying in ${retryAfter}s...`);
    await new Promise(r => setTimeout(r, retryAfter * 1000));
    return getFlowStatus(); // recursive retry
  }

  const flows = await resp.json();
  flows.forEach(flow => {
    console.log(`Flow: ${flow.name} | Enabled: ${flow.disabled === false}`);
  });
  return flows;
}

getFlowStatus().catch(console.error);
```

### cURL: Test Celigo API connection and list integrations

```bash
# Input:  CELIGO_API_TOKEN environment variable
# Output: JSON array of all integrations

# List all integrations
curl -s -H "Authorization: Bearer $CELIGO_API_TOKEN" \
  -H "Content-Type: application/json" \
  https://api.integrator.io/v1/integrations | jq '.[].name'

# Get specific connector details
curl -s -H "Authorization: Bearer $CELIGO_API_TOKEN" \
  https://api.integrator.io/v1/connectors | jq '.[] | {name, published, applications}'

# Check connection status
curl -s -H "Authorization: Bearer $CELIGO_API_TOKEN" \
  https://api.integrator.io/v1/connections | jq '.[] | {name, type, offline}'
```

## Data Mapping

### Field Mapping Reference (Shopify-NetSuite Example)

| Source Field (Shopify) | Target Field (NetSuite) | Type | Transform | Gotcha |
|---|---|---|---|---|
| order.id | salesOrder.externalId | String | Prefix with "SHOP-" | Must be unique across all external IDs in NetSuite |
| order.email | customer.email | String | Lowercase | NetSuite email must match existing customer or create new |
| order.total_price | salesOrder.total | Currency | None (both USD) | Multi-currency: must set exchange rate + currency record |
| order.line_items[].sku | salesOrder.item[].item | Lookup | SKU to internal ID | NetSuite item must exist -- flow errors if SKU not found |
| order.shipping_address | salesOrder.shippingAddress | Object | Map individual fields | NetSuite address has line1/line2/city/state/zip format |
| order.discount_codes[].amount | salesOrder.discountItem | Currency | Map to discount item | Must create discount items in NetSuite first |
| order.financial_status | salesOrder.status | Enum | Map to NS status codes | "paid" -> "Pending Fulfillment", "pending" -> "Pending Billing" |
| order.created_at | salesOrder.tranDate | DateTime | UTC to account timezone | NetSuite dates use account timezone, not UTC |

### Data Type Gotchas

- **DateTime timezone mismatch**: Shopify/Amazon timestamps are UTC; NetSuite stores dates in the user's or account's preferred timezone. Always convert explicitly or use Celigo's built-in timezone transformation. [src1]
- **Multi-select fields serialize differently**: NetSuite uses pipe-delimited (|) for multi-select custom fields in SuiteTalk; Celigo handles this automatically via RESTlet but NOT when using HTTP connector directly. [src4]
- **Currency precision**: NetSuite stores amounts with 2 decimal places by default; some source systems (crypto, FX) use more -- truncation happens silently without explicit rounding configuration. [src1]
- **Internal ID vs External ID**: NetSuite records have both an internalId (system-assigned integer) and externalId (user-assigned string). Celigo lookups default to internalId; cross-reference via externalId requires explicit lookup configuration. [src4]

## Error Handling & Failure Points

### Common Error Codes

| Code | Meaning | Cause | Resolution |
|---|---|---|---|
| SSS_REQUEST_LIMIT_EXCEEDED | NetSuite concurrency limit exceeded | Sum of concurrent RESTlet + web services requests exceeds account limit | Reduce connection concurrency settings; purchase SuiteCloud Plus licenses [src3] |
| ss_out_of_points | NetSuite governance unit limit exceeded | Too many records in single batch consuming SuiteScript governance units | Reduce batch size in Celigo import Advanced settings [src3] |
| SSS_INVALID_API_USAGE | Invalid SuiteScript API call | Using wrong API method (e.g., getValue vs getSublistValue) in custom hooks | Review SuiteScript 2.0 API reference; fix hook code [src4] |
| INVALID_KEY_OR_REF | Record reference not found | Lookup field value doesn't match any NetSuite record | Fix source data or add lookup/create-if-missing logic in flow |
| RCRD_HAS_BEEN_CHANGED | Optimistic locking conflict | Another process modified the record between read and write | Enable auto-retry; implement record-level locking strategy |
| USER_ERROR | Custom validation failed | NetSuite workflow, user event script, or validation rule rejected the record | Check NetSuite script logs; adjust data to pass validation |

### Failure Points in Production

- **Concurrency budget exhaustion during peak season**: Multiple integrations (Shopify + Amazon + 3PL) simultaneously hitting NetSuite can exhaust the shared concurrency pool, causing cascading SSS_REQUEST_LIMIT_EXCEEDED errors across ALL integrations. Fix: `Pre-allocate concurrency budget per integration; add SuiteCloud Plus licenses before peak; use Celigo's auto-recover rate limit feature`. [src3]
- **SuiteApp bundle version mismatch after NetSuite upgrade**: NetSuite releases can break compatibility with older Celigo bundle versions. Fix: `Always update Celigo SuiteApp bundle within 2 weeks of a NetSuite release; test in sandbox first`. [src4]
- **Saved search schema changes break exports silently**: If someone modifies a NetSuite saved search that Celigo uses for exports (adds/removes columns, changes criteria), the flow silently exports wrong data. Fix: `Use dedicated saved searches prefixed with "[Celigo]" and restrict edit permissions; monitor exported record counts for anomalies`. [src4]
- **Token expiration on dormant connections**: If a NetSuite access token is revoked (admin action, password policy) but the Celigo connection isn't updated, flows fail silently until the error queue is checked. Fix: `Set up Celigo alert notifications for connection failures; use automatic TBA to reduce manual token management`. [src4]
- **Multi-subsidiary complexity**: NetSuite multi-subsidiary setups require subsidiary-aware field mappings. A flow that works for one subsidiary silently creates records in the wrong subsidiary. Fix: `Always include subsidiary field in imports; use conditional logic per subsidiary in flow mappings`. [src1]

## Anti-Patterns

### Wrong: Setting maximum concurrency on all connections

```javascript
// BAD -- setting all connections to max concurrency
// NetSuite account limit: 5 (default)
// Connection 1 (Shopify sync): concurrency = 5
// Connection 2 (Salesforce sync): concurrency = 5
// Connection 3 (Amazon sync): concurrency = 5
// Total: 15 -- exceeds account limit of 5!
// Result: SSS_REQUEST_LIMIT_EXCEEDED errors across ALL integrations
```

### Correct: Budget concurrency across all connections

```javascript
// GOOD -- concurrency budget allocation
// NetSuite account limit: 5 (check: Setup > Integration > Web Services Preferences)
// Connection 1 (Shopify sync): concurrency = 2  (highest priority)
// Connection 2 (Salesforce sync): concurrency = 2
// Connection 3 (Amazon sync): concurrency = 1  (runs off-peak only)
// Total: 5 -- exactly matches account limit
// Enable "Auto-recover rate limit errors" on all connections for safety
```

### Wrong: Using a single large batch size for all imports

```javascript
// BAD -- importing 5,000 records per batch
// Each record consumes ~50 governance units
// 5,000 * 50 = 250,000 units >> 5,000 unit limit
// Result: ss_out_of_points error, entire batch fails
```

### Correct: Tune batch size based on record complexity

```javascript
// GOOD -- calibrate batch size to governance budget
// Simple records (customer updates): batch size = 100 (~50 units each = 5,000 total)
// Complex records (sales orders with line items): batch size = 25 (~200 units each = 5,000 total)
// Test in sandbox first, monitor governance consumption, adjust down if errors occur
```

### Wrong: Sharing saved searches with business users

```javascript
// BAD -- using "Monthly Revenue Report" saved search for Celigo export
// Problem: Finance team modifies columns/criteria for their reporting needs
// Result: Celigo export silently pulls wrong data or breaks on schema change
```

### Correct: Dedicated integration saved searches with restricted access

```javascript
// GOOD -- create "[Celigo] Order Export" saved search
// Restrict edit permissions to integration admin role only
// Add description: "DO NOT MODIFY -- used by Celigo Shopify integration"
// Set up monitoring: compare expected vs actual record counts per flow run
```

## Common Pitfalls

- **Pitfall: Underestimating endpoint consumption**: Each unique application counts as 1 endpoint, but a single Shopify-NetSuite SmartConnector uses 2 endpoints (Shopify + NetSuite). With Standard edition's 3 endpoints, you can only connect 1.5 apps to NetSuite. Fix: `Map out all integrations before purchasing; most NetSuite shops need Professional (5 endpoints) minimum`. [src5, src7]
- **Pitfall: Ignoring sandbox testing**: Celigo sandbox accounts are only available on Professional+ tiers. Standard edition users must test in production. Fix: `Budget for Professional edition if you have any non-trivial integration logic; never deploy untested flows to production`. [src5]
- **Pitfall: Not monitoring the error dashboard**: Celigo's AI error management resolves many issues automatically, but silently failed records accumulate. Fix: `Configure email/Slack alerts for error thresholds; review error dashboard daily during initial deployment, weekly thereafter`. [src1]
- **Pitfall: Assuming pre-built apps need no customization**: SmartConnector apps handle 70-80% of standard flows out of the box, but custom fields, approval workflows, and multi-subsidiary setups always require additional configuration. Fix: `Budget 40-80 hours of configuration even for "pre-built" integrations; engage a Celigo partner for complex setups`. [src1, src6]
- **Pitfall: Running all integrations at the same schedule**: Multiple flows scheduled at the same minute create concurrency spikes that trigger rate limit errors. Fix: `Stagger flow schedules by 5-10 minutes; prioritize order/payment flows over inventory/catalog syncs`. [src3]
- **Pitfall: Forgetting EDI trading partner limits**: Professional edition includes only 5 trading partners; Premium only 10. Large B2B operations with 50+ trading partners need Enterprise. Fix: `Count unique trading partners before selecting a tier; EDI-heavy businesses should budget for Enterprise`. [src5]

## Diagnostic Commands

```bash
# Check all Celigo integrations and their status
curl -s -H "Authorization: Bearer $CELIGO_API_TOKEN" \
  https://api.integrator.io/v1/integrations | jq '.[] | {name, _id, mode}'

# List all connections and check if any are offline
curl -s -H "Authorization: Bearer $CELIGO_API_TOKEN" \
  https://api.integrator.io/v1/connections | jq '.[] | select(.offline==true) | {name, type}'

# Check error counts for a specific integration
curl -s -H "Authorization: Bearer $CELIGO_API_TOKEN" \
  "https://api.integrator.io/v1/integrations/{integration_id}/errors?pageSize=100" | jq '. | length'

# In NetSuite: check concurrency limit via SuiteQL
# Navigate to: Setup > Integration > Web Services Preferences
# Look for: ACCOUNT CONCURRENCY LIMIT

# In NetSuite: check active integrations consuming concurrency
# Navigate to: Setup > Integration > Manage Integrations
# Review: all active integration records and their last activity
```

## Version History & Compatibility

| Platform Version | Release Date | Status | Breaking Changes | Migration Notes |
|---|---|---|---|---|
| 2026.1.1 | 2026-02 | Current | AI error management enhancements | Recommended upgrade |
| 2025.4.x | 2025-10 | Supported | API Builder improvements | -- |
| 2025.2.x | 2025-04 | Supported | SuiteApp bundle update for NS 2025.1 | Update bundle after NetSuite upgrade |
| 2024.4.x | 2024-10 | EOL | -- | Upgrade to 2025.x+ |

NetSuite releases (biannual: .1 in Q1, .2 in Q3) may require Celigo SuiteApp bundle updates. Always test in sandbox after NetSuite upgrades. [src4]

### Deprecation Policy

Celigo supports the current and previous major platform release. NetSuite compatibility depends on the installed SuiteApp bundle version -- Celigo recommends updating the bundle within 30 days of a NetSuite release to avoid compatibility issues. Basic authentication for NetSuite connections is deprecated; migrate to Token-Based Authentication or OAuth 1.0. [src4]

## When to Use / When Not to Use

| Use When | Don't Use When | Use Instead |
|---|---|---|
| Mid-market NetSuite shop with Shopify/Amazon/Salesforce integration needs | Enterprise with 50+ complex integrations requiring API-led connectivity | MuleSoft Anypoint Platform |
| Pre-built SmartConnector app exists for your use case | Need real-time sub-second event streaming from NetSuite | Direct SuiteTalk REST API + custom event architecture |
| Operations team (non-developers) need to manage integrations | Budget allows only 1-2 endpoints and you have simple CSV import needs | NetSuite native CSV import or SuiteCloud Plus bulk API |
| Need EDI/B2B trading partner integration alongside ERP flows | Need on-premise integration or hybrid cloud/on-prem connectivity | Boomi or MuleSoft (support on-prem runtime) |
| Want AI-powered error management and auto-retry for transient failures | Require custom SuiteScript business logic that must run inside NetSuite | Custom SuiteScript + SuiteCloud development |

## Cross-System Comparison

| Capability | Celigo | Boomi | Workato | MuleSoft |
|---|---|---|---|---|
| NetSuite depth | #1 partner, 80+ pre-built apps | Standard connector, fewer pre-built flows | Good connector, recipe-based | Standard connector, API-led approach |
| Pricing model | Endpoint + flow based (flat-rate) | Connection-based + runtime | Recipe/task-based | vCore-based |
| Entry price | ~$600/mo (Standard) | ~$2,000/mo | ~$1,500/mo | ~$3,000/mo |
| Pre-built NetSuite apps | 80+ SmartConnectors | ~10 templates | ~50 recipes | ~20 templates |
| Target user | Operations / business analysts | IT / integration architects | IT + business hybrid | Developers / API architects |
| Learning curve | Low (guided wizards) | Medium-high | Medium | High |
| On-premise support | No (cloud only) | Yes (Atom runtime) | Yes (on-prem agent) | Yes (Mule runtime) |
| EDI capability | Built-in (trading partners) | Via partner connectors | Limited | Via B2B/EDI module |
| Error management | AI-powered auto-resolve | Manual + alerts | Recipe-level error handling | Custom exception handling |
| API management | Built-in (Professional+) | Separate product | Built-in | Core strength |
| Best for | NetSuite-centric mid-market | Large enterprise, hybrid cloud | Cross-functional automation | API-first enterprise architecture |

[src6]

## Important Caveats

- **Pricing is not publicly listed**: All Celigo pricing above is approximate based on third-party reports and industry estimates. Actual pricing requires a custom quote from Celigo sales and varies by contract term, volume, and negotiation. [src5, src7]
- **"80+ pre-built integrations" varies in depth**: Some SmartConnector apps are full-featured (Shopify-NetSuite has 15+ flows), while others are basic templates requiring significant customization. Evaluate the specific app's maturity before committing. [src1]
- **NetSuite concurrency governance is the real bottleneck**: Celigo's own rate limits are generous (~1M requests/hour), but NetSuite's concurrency governance (default 5 concurrent requests) is the practical constraint for most customers. [src3]
- **SuiteCloud Plus licensing adds hidden cost**: High-volume NetSuite integrations via Celigo often require SuiteCloud Plus licenses ($999+/year each) from Oracle, on top of Celigo subscription costs. [src3]
- **Celigo's AI error management is not a substitute for monitoring**: Auto-resolve handles transient errors (timeouts, rate limits) well, but data quality errors (missing required fields, invalid references) require human review. [src1]

## Related Units

- [NetSuite SuiteTalk API capabilities](/business/erp-integration/netsuite-suitetalk-api/2026) -- underlying API surface
- [MuleSoft for NetSuite integration](/business/erp-integration/mulesoft-netsuite-integration/2026) -- enterprise-grade alternative
- [Boomi for NetSuite integration](/business/erp-integration/boomi-netsuite-integration/2026) -- hybrid cloud alternative
- [Workato for NetSuite integration](/business/erp-integration/workato-netsuite-integration/2026) -- recipe-based alternative