Shopify and NetSuite integration: native connector vs Celigo vs custom (2026)

If you run Shopify on the front end and NetSuite as your ERP, you have three realistic ways to connect them: Oracle's own NetSuite Connector (formerly FarApp), Celigo's Shopify–NetSuite integration app on its integrator.io platform, or a custom integration that your team or a partner builds and maintains.

All three can move orders into NetSuite and inventory back to Shopify. The differences show up when you add a second store or subsidiary, sell B2B, or try to reconcile a payout. This guide compares the routes using what Oracle, Celigo and Shopify publish, then covers data ownership, common failure points and a go-live checklist.

The short answer

• Pick NetSuite Connector if you run one store per subsidiary, sell mostly direct-to-consumer, and your order-to-cash process is close to standard. You get an Oracle-supported product with published plans.
• Pick Celigo if you need more configuration than the Connector gives you, want to monitor and fix errors in one dashboard, and may later connect other systems (3PL, CRM, marketplaces) on the same platform.
• Build custom only when your process really doesn't fit either product, and you have someone to own the code after launch. A custom build is not a one-off project. It's a small product you maintain.

A fourth option is often the best one: a connector plus a small custom piece for the one flow it doesn't handle.

If your ERP is Microsoft Dynamics 365 Business Central rather than NetSuite, see our Shopify Business Central integration guide.

Route 1: NetSuite Connector (formerly FarApp)

Oracle describes NetSuite Connector as point integrations for ecommerce, logistics and point-of-sale systems. It's configured in its own web app at app.farapp.com. To add the Shopify connector, Oracle's setup guide tells you to contact your NetSuite account manager.

What Oracle publishes about the Shopify connector:

• Plans on the Shopify App Store: B2C Standard, POS, B2C Premium and B2B, billed in USD every 30 days, with external charges that Oracle NetSuite may bill separately. The B2B plan costs considerably more than the B2C plans. Check the current prices on the App Store listing. Real-time order sync is included in B2C Premium. Oracle's docs warn that turning on real-time order sync "may result in a subscription increase."
• One store per connector. Oracle's FAQ says you need a separate connector account for every Shopify store, including multiple stores under one Shopify Plus organization.
• One subsidiary per connector account. If you sync a non-fixed subsidiary on orders, Oracle recommends a separate connector account per subsidiary, because mixing them can cause errors from records referenced in the wrong subsidiary.
• Metafields can be mapped on products. The connector can add and update Shopify metafields but can't delete them, so removals are a manual job in Shopify.
• Payout Report Sync creates a NetSuite deposit, deposits the matching cash sales and cash refunds, and adds Shopify Payments fees as lines. It runs every 24 hours and needs cash sales (not invoices) that are still undeposited.
• B2B (on the B2B plan) covers company sync, B2B orders, invoice posting or customer deposits, catalog and price list sync from NetSuite, and reverse payment sync, which by default looks back 90 days.

Known limits from Oracle's FAQ: the connector can't add a default item to every order (Oracle suggests a NetSuite workflow or script), doesn't create transfer orders in Shopify, and syncs Shopify wholesale prices as discounts off the regular price. Oracle's suggested fix for the last one is a separate wholesale store, which means a second connector.

Good at: standard DTC and POS order-to-cash, with Oracle as the single vendor. Weak at: anything that needs logic outside its settings and mappings.

Route 2: Celigo Shopify–NetSuite integration app

Celigo sells two things that are easy to confuse:

• The Shopify – NetSuite Integration App, which Celigo calls "managed, prebuilt integrations". Its published flows cover orders (as sales orders, cash sales or invoices), customers in both directions, customer deposits, item and inventory export from NetSuite, fulfillments in both directions, billing, cancellations and refunds in both directions, and payout report import as an add-on.
• The Shopify – NetSuite Integration Template, a set of 16 flows you install into integrator.io and customize yourself. It includes flows that the app page doesn't list, such as abandoned checkouts and draft orders to NetSuite quotes, and NetSuite promotions to Shopify discounts.

Celigo's product page also lists multi-location inventory, order risk data, discount codes matched to NetSuite coupon codes, gift cards as order lines, POS orders, settlement reconciliation, sales tax reports, kit items, and store-to-store cloning of settings and mappings. The template page mentions JavaScript hooks for custom flow logic.

Pricing: Celigo doesn't publish amounts. Its pricing page describes Standard, Professional and Enterprise editions with flat-rate pricing "based on endpoints and flows" rather than per transaction. When we checked on September 25, 2026, Celigo's developer page on the Shopify App Store listed no apps, so you'd go through Celigo directly (demo or 30-day trial).

Good at: configurable order-to-cash with error dashboards, plus room to add other systems on the same platform. Weak at: you depend on a second vendor's roadmap and pricing, and deep changes still need someone who knows integrator.io.

Route 3: custom integration

A custom build is usually a small service that sits between the two systems. On the Shopify side, build it on the GraphQL Admin API. Shopify has treated the REST Admin API as legacy since October 1, 2024, and our REST to GraphQL migration guide covers the switch. On the NetSuite side, SuiteTalk REST web services give you CRUD on records without writing scripts. For logic that doesn't fit, you deploy a RESTlet, which is a SuiteScript that an external app calls over HTTP.

The Shopify facts that shape a custom design:

• Versions: Shopify releases a new API version every quarter and supports each stable version for at least 12 months. If you call a version that's no longer available, Shopify falls forward to the oldest supported one. Plan an upgrade at least once a year.
• Rate limits: GraphQL Admin API limits are 100 points per second on standard plans, 200 on Advanced, 1,000 on Plus and 2,000 on Commerce Components. A single query can't cost more than 1,000 points.
• Bulk operations: for initial loads and nightly reconciliation, bulk queries return a JSONL file. From version 2026-01, an app can run up to five bulk queries per shop at once. A query must finish within 10 days, and the download URL expires after a week.
• Webhooks: Shopify says delivery isn't always guaranteed and doesn't guarantee ordering. Deduplicate on X-Shopify-Webhook-Id and run a reconciliation job. Our webhook reliability guide has the full pattern.
• B2B: companies, company locations, contacts, catalogs and payment terms are all objects in the GraphQL Admin API, so a custom build can sync them directly. Check which B2B features your Shopify plan includes before you design around B2B orders and catalogs.

Good at: exactly the process you have. Weak at: you own every bug, every API upgrade and every 2 a.m. failure.

Comparison table

Who owns which data

Most integration bugs start with two systems both owning the same field. Decide the owner for each record before anyone configures a mapping. This is the split we usually recommend:

Get sign-off on this table from finance and operations. It becomes your test plan.

Where Shopify–NetSuite integrations break

SKU mismatches

The NetSuite Connector's default product mapping pairs Shopify's sku with NetSuite's itemId, and most Celigo and custom setups also match on SKU. Blank SKUs, duplicates, trailing spaces and case differences end in orders that fail to import or post against the wrong item. Audit first. Export every variant with a bulk query:

mutation {
  bulkOperationRunQuery(
    query: """
    {
      productVariants {
        edges {
          node {
            id
            sku
            product { title status }
          }
        }
      }
    }
    """
  ) {
    bulkOperation { id status }
    userErrors { field message }
  }
}

Then compare the downloaded JSONL with a NetSuite saved-search export of item names:

// sku-audit.mjs: node sku-audit.mjs variants.jsonl netsuite-items.csv
import { readFileSync } from "node:fs";
const [jsonlPath, csvPath] = process.argv.slice(2);
const norm = (s) => (s ?? "").trim().toUpperCase();
const shopify = new Map();
const blanks = [];
for (const line of readFileSync(jsonlPath, "utf8").split("\n")) {
  if (!line.trim()) continue;
  const v = JSON.parse(line);
  if (!v.sku || !v.sku.trim()) { blanks.push(v.id); continue; }
  const key = norm(v.sku);
  shopify.set(key, [...(shopify.get(key) ?? []), { id: v.id, raw: v.sku }]);
}
// Assumes the item name is the first CSV column and contains no commas
const netsuite = new Map();
for (const row of readFileSync(csvPath, "utf8").split("\n").slice(1)) {
  const raw = row.split(",")[0]?.replace(/^"|"$/g, "");
  if (raw) netsuite.set(norm(raw), raw);
}
const dupes = [...shopify].filter(([, list]) => list.length > 1).map(([k]) => k);
const missing = [...shopify.keys()].filter((k) => !netsuite.has(k));
const nearMiss = [...shopify].filter(([k, list]) => netsuite.has(k) && list.some((v) => v.raw !== netsuite.get(k))).map(([k]) => k);
console.log({ blankSkus: blanks.length, duplicates: dupes.length, missingInNetSuite: missing.length, caseOrSpaceOnly: nearMiss.length });
console.log({ dupes: dupes.slice(0, 20), missing: missing.slice(0, 20), nearMiss: nearMiss.slice(0, 20) });

Fix every duplicate and blank in Shopify, and decide how kits and bundles map, before the first sync.

Tax and rounding

UK, EU, Australian and New Zealand stores usually show tax-inclusive prices, while US stores add sales tax at checkout. Shopify flags this per order (taxes_included in the Connector's default order mapping). If NetSuite recalculates tax instead of accepting Shopify's amounts, totals drift by a cent here and there, and Oracle notes that its connector runs validation checks between the storefront and NetSuite order totals. Post Shopify's tax lines as they are, set a tolerance for rounding, and test orders with discounts, free shipping and several tax rates.

For multi-currency, Shopify money fields come as a bag with both shopMoney and presentmentMoney. Decide which one NetSuite books, and make sure payouts reconcile against the same one.

Partial fulfillments

In Shopify, an order is split into fulfillment orders by location, and a partial fulfillment splits a fulfillment order in two. NetSuite has its own item fulfillments. Test an order shipped from two locations, an order shipped in two parcels, and a backordered line. Each must end with the right tracking numbers in Shopify and the right quantities in NetSuite.

Returns, refunds and cancellations

These fail most because both systems can start them. Oracle's FAQ notes that syncing a NetSuite cancellation can refund a paid Shopify order unless you configure it not to. Pick one origin per case (for example, returns start in Shopify, cancellations before shipping start in NetSuite), then test refunds with and without restock, partial refunds, shipping refunds, exchanges and gift card payments.

Payouts and settlement

Payout reconciliation only works if orders were posted the way the payout sync expects. For NetSuite Connector, that means undeposited cash sales and cash refunds. Agree the posting method with finance before go-live, not after the first month-end close.

When custom makes sense

A custom integration, or custom pieces next to a connector, is worth it when:

• You run several stores or subsidiaries with shared rules that neither product expresses cleanly.
• B2B pricing, credit holds or approvals live in NetSuite logic that no mapping can reproduce.
• You sync data beyond order-to-cash: metaobjects, bundles, subscriptions, or product content from a PIM.
• Your volume or timing needs control over rate limits, queues and retries.
• You have a named owner for the code after launch, whether in-house or a dedicated developer.

Stay with a connector when your process is standard and nobody will own custom code. An unowned custom integration is worse than a limited connector.

Go-live checklist

1. Sign off the data-ownership table with finance, operations and ecommerce.
2. Clean SKUs: no blanks, no duplicates, consistent case and spacing, kits mapped.
3. Map locations, subsidiaries, currencies, tax codes, payment methods and shipping methods.
4. Choose how orders post (sales order, cash sale or invoice) and confirm it works with payout reconciliation.
5. Connect a development store or sandbox first, never production on day one.
6. Run test orders: multi-line, discounted, tax-inclusive and tax-exclusive, foreign currency, gift card, POS and B2B if you use them.
7. Test partial fulfillment, split shipment, cancellation, partial refund, return with restock and exchange.
8. Run a payout sync and reconcile it to the bank deposit.
9. Set up error alerts that reach a named person, and write down who fixes what.
10. Schedule a reconciliation check (order counts and totals, inventory by location) daily for the first weeks.
11. Freeze catalog changes during cutover and agree on a rollback plan.
12. Put the next Shopify API version upgrade and the connector's release notes on someone's calendar.

Want help with your NetSuite integration?

We build and fix Shopify integrations: connector setup and mapping reviews, custom middleware on the GraphQL Admin API, and the small custom pieces that close a connector's gaps. Tell us your stores, subsidiaries and the flows that hurt today on our Shopify integrations page, and we'll tell you honestly whether a connector alone will do.

Sources

• Oracle NetSuite: Shopify Connector FAQ
• Oracle NetSuite: Setting Up Order Sync to Handle Multiple Subsidiaries in NetSuite
• Oracle NetSuite: Shopify Payout Report Sync
• Oracle NetSuite: Shopify B2B
• Oracle NetSuite: Setting Up Real-Time Order Sync for Shopify in NetSuite Connector
• Shopify App Store: NetSuite ERP Connector by Oracle NetSuite
• Celigo: Shopify – NetSuite Integration App
• Celigo: Shopify – NetSuite Integration Template
• Shopify: REST Admin API (legacy status)
• Shopify: API versioning
• Shopify: GraphQL Admin API rate limits
• Shopify: Perform bulk operations with the GraphQL Admin API