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, CRM, EDI, 3PL, and banking -- endpoint-based flat-rate pricing eliminates per-transaction surprises.
• Key limit: Endpoint-based pricing caps connections per tier -- Standard: 3 endpoints/16 flows, Professional: 5/100, Premium: 10/unlimited, Enterprise: unlimited/unlimited.
• 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.
• Best for: Mid-market NetSuite shops needing turnkey integrations with Shopify, Amazon, Salesforce, or 3PL providers without custom SuiteTalk development.
• Authentication: Token-based auth (TBA) via Celigo SuiteApp bundle (ID 20038); OAuth 1.0 available for direct SuiteTalk/SuiteQL connections.

System Profile

Celigo integrator.io is a cloud-native iPaaS 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.

API Surfaces & Capabilities

Rate Limits & Quotas

Per-Request Limits

Rolling / Daily Limits

Transaction / Governor Limits

Authentication

Authentication Gotchas

• SuiteApp bundle (ID 20038) is required for automatic TBA -- 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 immediately. [src4]
• The Celigo integration role is specifically "w/o 2FA" -- do NOT enable mandatory 2FA for integration users. [src4]
• OAuth 1.0 for SuiteTalk requires the SuiteTalk URI from Setup > Company > Company Information > Company URLs. [src4]

Constraints

• Endpoint cap is a hard licensing limit: Standard = 3, Professional = 5, Premium = 10. Each unique application consumes 1 endpoint.
• NetSuite concurrency is shared globally: All Celigo + non-Celigo integrations share the same concurrency pool.
• SuiteCloud Plus license required for high-volume: Web Services API (non-RESTlet) requires SuiteCloud Plus. Each license adds 10 concurrent connections.
• Bundle 20038 installation requires admin access: Cannot install in sandboxes with restricted admin or accounts with SuiteApp locks.
• Flow limits are hard: Standard edition caps at 16 flows total.
• Pre-built apps count toward limits: Installing a Shopify-NetSuite SmartConnector uses 2 endpoints and multiple flows.

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 (default concurrency)
|   |-- 1,000-100,000 records/day --> Increase batch + concurrency; consider SuiteCloud Plus
|   +-- > 100,000 records/day --> SuiteCloud Plus required; 40+ concurrent connections
|-- Which Celigo edition?
|   |-- 1-3 apps --> Standard (~$600/mo)
|   |-- 4-5 apps --> Professional (~$1,500/mo)
|   |-- 6-10 apps --> Premium (~$3,000/mo)
|   +-- 10+ apps --> Enterprise (custom pricing)

Quick Reference

Pre-Built NetSuite Integration Apps (80+ Available)

Celigo Edition Comparison

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: 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, accept permissions
5. Verify: Setup > Integration > Manage Integrations shows "Celigo integrator.io"

Verify: Setup > Integration > Manage Integrations --> "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 "Token Based Auth (Automatic)"
3. Enter NetSuite Account ID
4. Click "Connect to NetSuite" -- authorize access
5. Test connection

Verify: Click "Test Connection" --> green checkmark with "Connection successful".

3. Install or build integration flows

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

Pre-built: Marketplace > search app > Install > configure connections > map fields
Custom: New Integration > New Flow > Export (source) > Import (target) > mappings > schedule

Verify: Run test flow with small batch --> records appear in target with no errors.

4. Configure concurrency and error handling

Tune connection concurrency to respect NetSuite governance. [src3]

1. Connections > NetSuite connection > Advanced
2. Set RESTlet Concurrency Level (max: account limit)
3. Enable "Auto-recover rate limit errors"
4. Verify: sum of ALL concurrency <= NetSuite account limit

Verify: Setup > Integration > Web Services Preferences --> ACCOUNT CONCURRENCY LIMIT >= sum of all concurrency settings.

Code Examples

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

// 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;

async function getFlowStatus(integrationId) {
  const resp = await fetch(
    `https://api.integrator.io/v1/integrations/${integrationId}/flows`,
    { headers: { 'Authorization': `Bearer ${CELIGO_API_TOKEN}` } }
  );
  if (resp.status === 429) {
    const retryAfter = parseInt(resp.headers.get('retry-after') || '5');
    await new Promise(r => setTimeout(r, retryAfter * 1000));
    return getFlowStatus(integrationId);
  }
  return resp.json();
}

cURL: Test Celigo API and list integrations

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

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

Data Mapping

Field Mapping Reference (Shopify-NetSuite Example)

Data Type Gotchas

• DateTime timezone mismatch: Shopify/Amazon timestamps are UTC; NetSuite stores dates in account timezone. Always convert explicitly. [src1]
• Multi-select fields: NetSuite uses pipe-delimited (|) for multi-select custom fields in SuiteTalk; Celigo handles this via RESTlet but NOT via HTTP connector. [src4]
• Internal ID vs External ID: NetSuite records have both; Celigo lookups default to internalId. Cross-reference via externalId requires explicit config. [src4]

Error Handling & Failure Points

Common Error Codes

Failure Points in Production

• Concurrency budget exhaustion during peak season: Multiple integrations simultaneously hitting NetSuite exhaust the shared pool. Fix: Pre-allocate concurrency per integration; add SuiteCloud Plus before peak; enable auto-recover. [src3]
• SuiteApp bundle version mismatch after NetSuite upgrade: NetSuite releases can break older bundle compatibility. Fix: Update Celigo SuiteApp within 2 weeks of NS release; test in sandbox first. [src4]
• Saved search schema changes break exports silently: Modified saved searches cause wrong data exports. Fix: Use dedicated "[Celigo]" prefixed searches with restricted edit permissions. [src4]
• Token expiration on dormant connections: Revoked tokens cause silent failures. Fix: Set up alert notifications; use automatic TBA. [src4]
• Multi-subsidiary complexity: Flows that work for one subsidiary create records in wrong subsidiary. Fix: Always include subsidiary field; use conditional logic per subsidiary. [src1]

Anti-Patterns

Wrong: Setting maximum concurrency on all connections

// BAD -- all connections set to max concurrency
// Connection 1: concurrency = 5, Connection 2: concurrency = 5, Connection 3: concurrency = 5
// Total: 15 -- exceeds account limit of 5!
// Result: SSS_REQUEST_LIMIT_EXCEEDED across ALL integrations

Correct: Budget concurrency across all connections

// GOOD -- concurrency budget allocation within account limit
// Connection 1 (Shopify): 2, Connection 2 (Salesforce): 2, Connection 3 (Amazon): 1
// Total: 5 = account limit. Enable auto-recover on all.

Wrong: Using a single large batch size for all imports

// BAD -- 5,000 records/batch, each ~50 governance units
// 5,000 x 50 = 250,000 units >> 5,000 limit = ss_out_of_points

Correct: Tune batch size based on record complexity

// GOOD -- calibrate to governance budget
// Simple records (customer updates): batch = 100 (~50 units x 100 = 5,000)
// Complex records (sales orders): batch = 25 (~200 units x 25 = 5,000)

Wrong: Sharing saved searches with business users

// BAD -- using "Monthly Revenue Report" for Celigo export
// Finance team modifies columns = Celigo export breaks or returns wrong data

Correct: Dedicated integration saved searches

// GOOD -- "[Celigo] Order Export" with restricted edit permissions
// Description: "DO NOT MODIFY -- used by Celigo Shopify integration"

Common Pitfalls

• Underestimating endpoint consumption: A Shopify-NetSuite SmartConnector uses 2 endpoints. Standard's 3 endpoints = only 1.5 apps. Fix: Map all integrations before purchasing; most need Professional minimum. [src5]
• Ignoring sandbox testing: Sandbox only available on Professional+. Fix: Budget for Professional if you have non-trivial logic. [src5]
• Not monitoring error dashboard: AI error management resolves many issues, but failed records accumulate silently. Fix: Configure alerts; review dashboard daily during deployment. [src1]
• Assuming pre-built apps need no customization: SmartConnectors handle 70-80% out of box; custom fields and multi-subsidiary always need config. Fix: Budget 40-80 hours even for pre-built integrations. [src1]
• Running all integrations at same schedule: Concurrent flows create concurrency spikes. Fix: Stagger schedules by 5-10 minutes; prioritize order flows. [src3]
• Forgetting EDI trading partner limits: Professional includes only 5 partners. Fix: Count partners before selecting tier; EDI-heavy = Enterprise. [src5]

Diagnostic Commands

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

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

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

# In NetSuite: check concurrency limit
# Setup > Integration > Web Services Preferences > ACCOUNT CONCURRENCY LIMIT

Version History & Compatibility

When to Use / When Not to Use

Cross-System Comparison

Important Caveats

• Pricing is not publicly listed -- all figures above are approximate based on third-party reports. Actual pricing requires a custom quote from Celigo sales.
• "80+ pre-built integrations" varies in depth -- some are full-featured (Shopify has 15+ flows), others are basic templates requiring significant customization.
• NetSuite concurrency governance (default 5) is the real bottleneck, not Celigo's own rate limits (~1M requests/hour).
• High-volume integrations often require SuiteCloud Plus licenses ($999+/year each from Oracle) on top of Celigo costs.
• AI error management handles transient errors well but data quality errors still require human review.