Shopify Acumatica Integration: Native Connector, REST API, and Limits

Acumatica Cloud ERP is popular with US distributors, manufacturers, and multi-channel retailers, partly because it’s licensed by resources rather than per user. For Shopify merchants, the important facts are that Acumatica has its own native Shopify connector and that its API limits come from your license, not from a fixed public table. As on every page, documented marks statements from Acumatica or Shopify documentation, and recommendation marks our guidance.

Start with the native connector

Documented: Acumatica markets a native integration with Shopify and Shopify POS that keeps orders, products, and inventory aligned between the two systems.

Recommendation: map your real processes against the connector before writing code — order types, payment methods, taxes, refunds, multi-location stock, and POS. The connector covers the standard D2C flow; custom work is typically needed for a 3PL in the middle, unusual bundles or kits, B2B approval steps, or orders that must be split across branches. Compare options in custom integration vs. off-the-shelf connectors.

The contract-based REST API

Documented: Acumatica’s contract-based REST API is accessed through endpoints configured on the Web Service Endpoints (SM207060) form. URLs follow the pattern {instance}/entity/{endpoint}/{version}/{Entity} — for example the SalesOrder entity of the Default endpoint at a given version. The API can retrieve, create, update, and delete records. A PUT request creates a record or updates an existing one; adding the If-None-Match: * header restricts it to creation only.

Recommendation:

• Pin the endpoint version your integration was built against and test before moving to a newer one; entity and field shapes differ between versions.
• If you add custom fields, extend the endpoint rather than relying on screen-based workarounds, so the API contract stays explicit.
• Request only the fields and detail entities you need ($select, $expand), because large expanded payloads count against your license’s throughput.

PUT https://{instance}/entity/Default/{version}/SalesOrder
Authorization: Bearer {access_token}
Content-Type: application/json

{
  "OrderType": { "value": "SO" },
  "CustomerID": { "value": "WEBUS" },
  "CustomerOrder": { "value": "SHOP-US-5551234" },
  "Details": [
    { "InventoryID": { "value": "TSHIRT-BLK-M" }, "OrderQty": { "value": 2 } }
  ]
}

Illustrative only. Field names, required values, and available entities depend on your endpoint version and configuration.

Authentication and API sessions

Documented: client applications sign in either with the contract-based REST API’s sign-in method or through OAuth 2.0 / OpenID Connect. OAuth clients are registered on the Connected Applications (SM303010) form, which supports the authorization code, implicit, resource owner password credentials, and hybrid flows.

Documented: each license limits the number of API sessions. When an extra session tries to sign in beyond that limit, the sign-in is rejected, and Acumatica warns that applications which don’t sign out can prevent other applications from signing in.

Recommendation: prefer OAuth with refresh tokens for long-running integrations. If you use session sign-in, reuse a session for a batch of work and always sign out in a finally block. Session leaks are the most common reason an Acumatica integration “randomly” stops working when a second integration goes live.

License-based API limits

Documented: every license sets three limits, shown on the License Monitoring Console (SM604000): the maximum number of API sessions, the maximum number of concurrent API requests, and the maximum number of API requests per minute. Incoming requests wait in an internal queue and are processed in parallel by API processing cores, up to the concurrent-request limit. When the requests in the past minute reach 50% of the per-minute limit, subsequent requests are delayed. API consumption and throttling can be reviewed on the API Monitoring tab of the System Monitor (SM201530).

Recommendation: read your license’s actual values before sizing the sync — don’t rely on figures from blog posts. Budget the per-minute limit across all integrations (Shopify, 3PL, EDI, CRM), batch inventory updates instead of sending one call per SKU, and move bulk loads to off-peak hours.

Push notifications for changes in Acumatica

Documented: Acumatica push notifications send data changes to external systems. The source is a data query — a generic inquiry or a built-in definition — and destinations can be a webhook (HTTP address that receives POST requests), a message queue, a SignalR hub, or a commerce push destination. For webhooks, you can specify a header name and value for security. Notifications that fail after automatic attempts can be reviewed on the Process Push Notifications form and resent.

Recommendation: track only the fields you need (stock quantities, shipment status, tracking numbers), authenticate requests with the custom header, and process them through a queue. Combine push notifications with a scheduled reconciliation query — notifications tell you something changed; reconciliation proves nothing was missed.

Orders without duplicates

Documented (Shopify): Shopify webhooks can be delivered more than once.

Recommendation: store the Shopify order ID in a field you can query (the customer order number or a dedicated custom field) with a per-store prefix, keep your own table of processed events, and look the order up before retrying after a timeout. A PUT without the order number creates a new auto-numbered order every time, so retries without a lookup are a direct path to duplicates. See retries and idempotency.

Inventory, fulfillment, and finance

Recommendation:

• Inventory: let Acumatica own on-hand quantities and publish available-to-sell per warehouse to the matching Shopify location, with a safety buffer for fast movers.
• Fulfillment: confirm the shipment in Acumatica, then create the fulfillment and tracking (UPS, FedEx, USPS) in Shopify.
• Tax: post the sales tax Shopify or your tax engine calculated at checkout rather than recalculating it; have your tax advisor confirm the setup per state. See sales tax in ERP integrations.
• Payouts: reconcile Shopify Payments payouts as net deposits with fees, refunds, and adjustments booked separately — see the approach on the QuickBooks Online page.

Common pitfalls

• Leaked API sessions blocking every other integration.
• Ignoring license limits until a sale-day spike delays every request.
• Duplicate orders from retried PUT requests without a lookup.
• Push notifications tracking every field, flooding the queue.
• Untested endpoint upgrades that change entity shapes under a running integration.