Shopify ERP Integration
HelloDevs connects Shopify to the ERP or accounting system you already run — NetSuite, Odoo, Microsoft Dynamics 365 Business Central, SAP Business One or Xero — so orders, inventory, products and customers stop drifting apart.
- Six years building on Shopify's APIs
- GraphQL Admin API and webhooks, not screen-scraping
- Fixed quotes, not hourly guesses
Most "ERP integrations" are a nightly CSV export that breaks the week nobody is watching it. HelloDevs builds the kind that reconciles itself and tells you when it can't.
Which ERP integration do you actually need?
Which ERP integration do you actually need?
"ERP integration" covers very different jobs depending on which system you run and how much of it needs to talk to Shopify. Find your situation below.
| Your situation | What it usually calls for |
|---|---|
| Orders, inventory or customers drift out of sync between Shopify and your ERP | A real integration — webhooks plus a scheduled reconciliation job, not a nightly export someone has to notice has stopped running. |
| You're already on NetSuite, Odoo, Business Central or SAP Business One | A connector or custom app built against that ERP's own API, not a generic one-size-fits-all sync. |
| You just need Xero for accounting, not a full ERP | A lighter sync — orders and invoices into Xero, tax and payouts reconciled — not a full two-way ERP build. |
| You're choosing between an iPaaS (Celigo, Boomi, Make) and a custom app | Depends on how standard your workflow is against that platform's prebuilt connector. We'll give you the honest comparison, not a pitch for whichever we'd rather sell. |
| You sell in multiple currencies or ship into several of the UK, US, EU, Australia and New Zealand | Multi-currency pricing and VAT/GST handling designed in from the first schema decision, not patched on once numbers stop matching. |
| You run B2B wholesale alongside DTC on the same store | Company-level price lists and catalogues synced from the ERP, which stays the system of record — not maintained twice by hand. |
Six parts of a Shopify ERP integration
An ERP integration is not one sync — it's several, each with its own failure modes. HelloDevs scopes and builds each piece on its own merits rather than selling one bundle that half-fits.
The ERPs and accounting systems we connect
The ERPs and accounting systems we connect
Each of these has its own API, its own rate limits and its own way of modelling an order — the integration is built against the system you actually run, not a lowest-common-denominator template.
- NetSuiteSuiteTalk (REST or SOAP) or SuiteScript for the ERP side, matched to Shopify's GraphQL Admin API. NetSuite's own concurrency and governance limits usually decide whether a custom app or an iPaaS fits better.
- OdooOdoo's external API (XML-RPC/JSON-RPC, or a custom module for anything its REST layer doesn't expose) synced against Shopify. Self-hosted Odoo often favours a custom app over a subscription connector.
- Microsoft Dynamics 365 Business CentralBusiness Central's own OData/REST API, with its multi-entity structure (items, locations, sales orders) mapped carefully onto Shopify's simpler model rather than forced to fit it exactly.
- SAP Business OneThe Service Layer REST API, typically the heaviest of the five to integrate — SAP B1's data model and approval workflows usually need more mapping work than a prebuilt connector covers.
- XeroFor stores that need accounting sync without a full ERP: orders and invoices into Xero, VAT/GST reconciled against what Xero records, inventory read back where Xero tracks it. A much smaller build than a full ERP integration, and a common fit for the UK, Australia and New Zealand.
- Something elseAny ERP or accounting system with a documented API can usually be connected — tell us which one and we'll say honestly whether it's a sensible build.
What these terms actually mean
What these terms actually mean
Vendors use a lot of vocabulary here. This is what the terms mean, so you can tell whether a quote describes real engineering or a reseller's sales sheet.
- IdempotencyProcessing the same webhook or message twice without creating a duplicate order, refund or stock adjustment. Shopify and most ERPs deliver at-least-once, not exactly-once — so every handler has to be written assuming it will sometimes run twice.
- Webhooks vs pollingWebhooks push a change the moment it happens; polling asks the ERP "anything new?" on a schedule. Webhooks are faster and cheaper at scale, but need a reconciliation job behind them for the ones that never arrive.
- Bulk operationsShopify's GraphQL Admin API runs large reads and writes as an asynchronous job rather than one request per item — the only practical way to sync a catalogue of thousands of SKUs without hitting rate limits.
- iPaaSIntegration Platform as a Service — Celigo, Boomi, Make and similar tools that ship prebuilt connectors and a visual mapping layer. Faster to stand up for a standard workflow; a monthly cost and a ceiling on how far you can bend it for a non-standard one.
- ReconciliationA scheduled job that compares both systems and fixes what the real-time sync missed — the dropped webhook, the request that failed mid-retry, the record edited directly in the ERP. Without one, small gaps compound silently.
- Rate limitsBoth Shopify and most ERPs cap how fast you can call their API. A sync that ignores this works in testing and throttles or fails on your busiest sales day — which is why throttling and backoff are designed in from the start, not added after the first outage.
Where ERP integrations actually fail
- A webhook retried after a slow response creates the same sales order twice in the ERP. Every write has to be keyed on an idempotency key — usually Shopify's own order ID — so a retry updates instead of duplicating.
- An order syncs but its line-item tax doesn't, or inventory updates for nine SKUs out of ten. The ninth failure needs to be visible and retryable on its own, not silently dropped because the batch as a whole "succeeded".
- Shopify records the currency and tax at the moment of sale; the ERP may convert at a different rate or post VAT/GST differently. Left unreconciled, this is the gap that shows up as a finance problem at month-end, not an engineering one at launch.
- A full catalogue resync run at peak traffic competes with real customers for the same API quota. Bulk operations and backoff exist specifically so a sync job never slows down checkout.
- A sync with no monitoring can be wrong for weeks before anyone notices a stock count or a price is off. Alerting on failed jobs, and a reconciliation report someone actually reads, is part of the build — not an optional extra.
- When something does go wrong, you need to stop the sync without losing data mid-flight. Every integration we build has a clean off switch and a way to replay what queued up while it was off.
If a quote doesn't mention reconciliation,
it's pricing the easy 90% and leaving the part that actually keeps two systems honest for later. HelloDevs scopes that part first.
What a Shopify ERP integration project includes
What every HelloDevs integration quote covers
Every HelloDevs quote covers all of this. If an agency leaves any of it out, the cost reappears later as a change request or a 2am incident.
- Scoping documentWhich entities sync, in which direction, and which system owns each field — agreed before any code is written.
- The integration itselfWebhooks or scheduled sync against your ERP's own API, not a generic template stretched to fit.
- Idempotent handlersEvery write keyed so a retried or redelivered webhook updates instead of duplicating.
- Reconciliation jobA scheduled check that catches what the real-time sync missed, on a schedule your volumes justify.
- Rate-limit handlingBackoff and bulk operations so a resync never competes with checkout for API quota.
- Error alertingA failed sync tells someone, rather than waiting to be discovered in a stock count.
- Data-mapping documentationWhich field maps to which, and which system is the source of truth for it — so your team isn't dependent on us to understand your own data.
- Source codeYours, in your repository, from the first commit.
- 30 days of post-launch fixesIncluded, not billed.
How an ERP integration project runs
Five steps, with a parallel run before anything cuts over
Nothing switches off the old process until the new one has proven itself against real data, side by side with it.
- Problem callYou tell us what's drifting and which ERP it's drifting from. We tell you honestly whether a connector, a custom app, or middleware fits best.
- Fixed quoteA written scope — which entities, which direction, which system owns what — a timeline, and a price.
- Build against a sandboxBuilt and tested against your ERP's sandbox or test account first, never your live ledger.
- Parallel runThe new sync runs alongside your existing process on real data until it's trusted, before the old process is retired.
- Launch and watchThirty days of fixes included, with reconciliation reports and error alerting live from day one, not added after something breaks.
Shopify ERP integration tech stack
Built on the real APIs, not a black-box connector
Included because technical buyers ask, and because a vague answer here usually means the agency is reselling someone else's connector with no visibility into how it actually works.
The Integration Stack
Shopify's GraphQL Admin API with bulk operations for full-catalogue syncs, verified and idempotent webhook handlers, a job queue for retries and backoff, and a scheduled reconciliation pass — against NetSuite, Odoo, Business Central, SAP Business One or Xero's own API, or through an iPaaS (Celigo, Boomi, Make) where that's the better fit.
- GraphQL Admin API
- Bulk Operations
- Webhooks
- Node.js
- TypeScript
- PostgreSQL
- Job Queues
- lib/integrations/webhooks/orders.ts01
- lib/integrations/reconcile.ts02
- lib/integrations/erp-client.ts03
- app/api/webhooks/inventory.ts04
Idempotent by Default
Every write is keyed so a retried webhook or a replayed job can never create a duplicate order, refund or stock adjustment.
await syncOrder(order, {
idempotencyKey: order.id,
});No Black-Box Connector
Where a custom app fits better than a subscription connector, you get code you own — not a mapping sheet locked inside someone else's platform.
generic-connector.zip
No Subcontracting
We do not subcontract. The people on the scope call are the people writing the integration.
MapSync
Shopify ERP integration questions
- It typically depends on four things: how many entities sync (orders only, versus orders, inventory, products and customers), whether the sync is one-way or two-way, which ERP it's against — SAP Business One and NetSuite usually need more mapping work than Odoo or a Xero-only accounting sync — and whether an iPaaS subscription or a custom app fits better. We quote a fixed price once those are answered, not an hourly estimate that grows.
- It typically depends on scope and on how clean your ERP's data already is. A single-direction sync — inventory or orders only — usually takes four to six weeks. A full two-way integration across orders, inventory, products and customers typically takes eight to sixteen weeks, including a parallel run against real data before cutover.
- NetSuite, Odoo, Microsoft Dynamics 365 Business Central and SAP Business One for full ERP integrations, and Xero where accounting sync is the actual need rather than a full ERP. Any system with a documented API can usually be connected — tell us which one and we'll give you an honest read on the effort.
- Depends on how standard your workflow is. An iPaaS like Celigo, Boomi or Make is usually cheaper and faster to stand up when your mapping is close to its prebuilt template. A custom app usually wins when your workflow has enough edge cases that you'd spend as much time fighting the connector's limits as you would just building it. We'll tell you which applies before quoting either.
- Orders flow mostly one way — Shopify to the ERP — and need to be written exactly once each. Inventory is usually two-way and continuous, so it needs conflict handling for the moment both systems try to update the same stock count at the same time, plus a reconciliation job for whatever a dropped webhook missed.
- Multi-currency pricing is designed into the data model from the start, not patched on afterwards, and we reconcile the VAT or GST Shopify records on each order against what the ERP posts to the ledger — that gap is the most common finance-side defect in ERP integrations we're asked to fix.
- Usually not. Multi-location inventory, the GraphQL Admin API, webhooks and Shopify B2B all work on standard Shopify plans. Plus only comes into it for certain checkout-level customisations, which most ERP sync work never touches — we'll flag it specifically if your scope is the exception.
Tell us what's out of sync
Send the problem and which system it's drifting from. A developer at HelloDevs replies within one business day.
Project examples and buying guides
Review the work, compare your options and prepare a brief before choosing your next step.
- Shopify revenue attribution
An example of building reliable order and webhook data for reporting and downstream systems.
- Scaling a Shopify app
How we handle webhooks and background queues once a sync has to run at volume.
- AI integrations
A connected system is also what most useful AI features are built on top of.
Talk to us about an ERP integration
Tell us what's out of sync
Send the problem and which system it's drifting from. A developer at HelloDevs replies within one business day.
