SAP ECC to Shopify Inventory Sync: How to Update Stock in Bulk Without Throttling Your Shopify API

To sync inventory from SAP ECC to Shopify at scale, stop updating one product at a time. Read a batch of products from Shopify with a single GraphQL query, fetch live stock for the whole batch from SAP ECC in one call, map each SAP quantity to the right Shopify variant and location, and write the results back together. This guide explains why that pattern works, what Shopify’s API limits say today, and how a live APPSeCONNECT workflow runs the pattern end to end.

Why SAP ECC to Shopify inventory sync usually runs overnight

Picture 500 jackets arriving at your warehouse. Your team books the goods receipt in SAP ECC at 9 a.m. Shopify still shows the jackets as sold out, because the inventory sync runs at night. Every shopper who lands on that product page before then sees “sold out” and buys somewhere else. The stock existed. The store could not sell it.

The delay is rarely a business choice. It comes from how Shopify’s API meters access and from how most syncs are built.

How Shopify’s API budget works

Shopify does not give an app unlimited access. The GraphQL Admin API uses a leaky-bucket model: every query has a cost in points, and the bucket refills continuously. Shopify’s rate limits documentation says short bursts are fine “as long as your average cost stays under the restore rate.” The limit applies to each combination of app and store, and it scales with the store’s plan:

Cost is calculated per field. Scalars and enums cost 0, objects cost 1, mutations cost 10, and connections are sized by their first or last argument. A single query may not exceed 1,000 points on any plan, and Shopify enforces that cap before the query runs, using the requested cost. After execution the bucket is refunded the difference between requested and actual cost. Each response includes an extensions.cost block, and the Shopify-GraphQL-Cost-Debug header adds a per-field breakdown.

Why one-product-at-a-time sync stalls

A common implementation handles each product on its own. It finds the product in Shopify, finds its inventory item, finds the location where it is stocked, queries SAP ECC for the stock, then updates Shopify. That is five steps for one product, and most of them are separate API calls.

Take an illustrative catalog of 500 products at five calls each. That is 2,500 calls drawing on one bucket. Requests start to throttle, the sync slows down, and the team moves it to the night, where it competes with nothing. The overnight schedule is a workaround for the call pattern, not a business preference.

How Shopify and SAP ECC describe the same stock

A sync is only as good as its mapping. The two systems model inventory differently, and the mapper has to bridge them.

• Shopify: a product has variants. A variant carries the SKU and points to an inventory item. The inventory item has an inventory level at each location. The admin shows Unavailable, Committed, Available and On hand per location, and the API’s inventorySetQuantities mutation accepts available or on_hand as the quantity name.
• SAP ECC: stock is held per material, plant and storage location, and it is split by stock category such as unrestricted-use, in transit, in quality inspection, restricted and blocked. The stock overview screens show each category in its own column, as in the recording.

Settle these mapping decisions before you build anything:

Which system should be the source of truth?

Shopify’s own inventorySetQuantities documentation is specific: use it only when calling on behalf of a system that acts as the source of truth for inventory quantities, and otherwise use inventoryAdjustQuantities. Some Shopify automation vendors take the opposite position and argue that Shopify should be the source of truth for most stores, with write-back from outside tools avoided unless there is a deliberate reason.

If goods receipts, transfers and warehouse stock are booked in SAP ECC, you have that deliberate reason. A practical rule:

The bulk inventory sync pattern in four steps

The fix is to change the call pattern, not to ask Shopify for more room. Instead of asking about each product separately, the flow asks once for a batch, once for SAP stock, and writes once.

Step 1: Read a batch from Shopify in one query

One GraphQL query returns a page of products with every variant, each variant’s inventory item, and every location where that item is stocked. Everything needed for the update arrives in one response. The demo query uses first: 80 products filtered by a creation date, with variants, inventoryItem and inventoryLevels nested inside.

Size the nested connections so the requested cost stays under the 1,000-point cap. Page through large catalogs with cursors, and check the real cost with the Shopify-GraphQL-Cost-Debug header before you pick a page size. For full catalog pulls, Shopify also offers bulk queries, which can read any connection field, allow up to five connections and two levels of nesting, and must complete within 10 days.

Step 2: Read SAP stock for the whole batch in one request

Send the SKU list to SAP ECC once and get live stock for all of it back. Use whichever interface your SAP landscape exposes: IDoc, RFC or BAPI calls, or REST web services. One request replaces what would have been dozens or hundreds of single-material lookups.

Step 3: Map SAP quantities to Shopify items and locations

The mapper matches each SAP material to a Shopify variant by SKU, then builds one record per inventory item and location with the quantity to set. This is where the decisions in the mapping table above are applied.

Step 4: Write everything back to Shopify in bulk

Shopify’s bulk operations for imports are built for this. The documented sequence is:

1. Write a JSONL file where each line is one input to the mutation.
2. Call stagedUploadsCreate to get an upload target, then upload the file.
3. Call bulkOperationRunMutation with the mutation and the staged upload path.
4. Wait for completion by subscribing to the bulk_operations/finish webhook and polling bulkOperation(id:) as a fallback, because webhook delivery is not guaranteed.
5. Download the result file and read the per-line results.

Shopify states that bulk operations do not have the max-cost and rate limits that single queries have. The input file cannot exceed 100 MB, an operation must finish within 24 hours, and from API version 2026-01 each app can run up to five bulk mutation operations per shop at once (earlier versions allow one per type). You can supply any Admin API mutation except the two bulk-run mutations, with a limit of one connection field. The documentation does not name every supported mutation, so test your inventory mutation on a development store first.

Walkthrough: SAP ECC to Shopify bulk inventory sync in APPSeCONNECT

The recording behind this section runs in an APPSeCONNECT demo environment with a Shopify store and an SAP system. It is a single demonstration with a small batch, not a benchmark.

Before the sync: Shopify shows zero stock

The Shopify admin lists products that also exist in SAP ECC. Every product shows 0 in stock, although SAP ECC holds stock for them.

Figure 1. Shopify product list before the sync: each product shows 0 in stock.

Opening one product shows the same picture at variant level. The Central Warehouse location has Unavailable, Committed, Available and On hand all at 0, and the variant carries SKU 1342. That SKU is what the workflow uses to find the matching material in SAP ECC.

Figure 2. Product detail before the sync: the Central Warehouse location shows 0 for every quantity column.

The workflow

The flow is built in the APPSeCONNECT ProcessFlow designer. It runs Start, then a Shopify node, a Mapper, an SAP ECC node, a second Mapper, and a final Shopify node. The first Shopify node reads the batch, the SAP node fetches stock for it, and the last Shopify node writes the result back.

Figure 3. The Shopify Bulk Inventory ECC workflow in the APPSeCONNECT ProcessFlow designer.

Running it with a runtime filter

At execution time the user chooses a runtime filter for the first Shopify node. The demo reads 80 products created on or after a chosen date, and the selection includes each variant’s inventory item and the locations where it is stocked. That is the single read from Step 1.

Figure 4. Execute With Runtime Filter: a Shopify products query with first: 80, a created_at filter, and nested variants, inventoryItem and inventoryLevels.

What the execution tracker shows

The tracker lists each node as it starts and finishes. After the SAP ECC node completes its Get inventory step, the flow passes through a Mapper and then runs two Shopify steps named Get staged Uploads URL and Get Bulk Upload Status. Those names line up with the stage-upload, run and status-check sequence in Shopify’s documented bulk import process described in Step 4.

Figure 5. The execution tracker: SAP ECC Get inventory, Mapper, Shopify staged upload, Mapper, Shopify bulk upload status.

After the sync: Shopify shows stock

Back in the Shopify admin, the same products now show quantities in the Inventory column, where the earlier screen showed 0 in stock for all of them. Compare the products in Figure 6 with Figure 1: the same items, now populated.

Figure 6. The same product group after the sync: quantities now appear in the Inventory column.

The demo shows the shape of the pattern: one read from Shopify, one read from SAP, a mapping step and a bulk write. It does not show timings, and it does not replace testing with your own SKUs, locations and stock categories.

Design choices that keep a batch sync reliable

Guard against stale writes

As of API version 2026-04, each quantity in an inventorySetQuantities call must include a changeFromQuantity value. The mutation updates the quantity only if the stored quantity matches that value, and otherwise returns a CHANGE_FROM_QUANTITY_STALE error. You can opt out per quantity by passing null, and omitting the field returns an error. For a sync, this protects a sale that lands between your read and your write. Decide per workflow whether a stale line should be retried with fresh data or skipped.

Make retries safe with idempotency keys

From API version 2026-04 the idempotency key is required on inventorySetQuantities and is supplied with the @idempotent directive. Shopify recommends a UUID. Generate one key per logical write so a retry cannot apply the same change twice. See Shopify’s idempotent requests guide.

Expect partial failure

Bulk results come back one line per input, each with a line number, and lines are not processed in order. A bulk operation fails as a whole only on critical errors, so a file can complete with a few bad lines. Read the result file, retry the failed lines, and note that result URLs expire after one week.

Choose the trigger: scheduled batches or events

Batching does not force an overnight run. A short-interval batch, or a batch started by a goods-receipt event, closes the gap that caused the sold-out problem in the first place. Keep a full reconciliation pass as a safety net, and compare SAP and Shopify totals after it.

Watch the sync, not only the result

Track success and error rates, retry transient failures automatically, and re-sync missed records. The APPSeCONNECT SAP ECC integration page describes a Sync Info dashboard and auto-retry for this purpose.

How to evaluate an SAP ECC Shopify integration platform

Whether you build or buy, these questions separate a sync that works in a demo from one that works on a Black Friday morning.

Where APPSeCONNECT fits

APPSeCONNECT connects ERP, eCommerce and CRM systems, and its pages describe Shopify connectivity through the Shopify Admin REST and GraphQL APIs and SAP ECC connectivity over IDoc, RFC or BAPI, and REST web services. The workflow in this article is one example of the same ProcessFlow approach applied to inventory. If you want the platform detail behind it, start with the SAP ECC integration and Shopify integration pages, and see inventory management automation for the wider picture.

Teams that want agent-based automation on top of the same connections can look at appse ai, the AI and automation orchestration layer built on APPSeCONNECT.

See the SAP ECC to Shopify workflow on your own data

If your Shopify store still waits for a nightly job to learn about stock that SAP ECC already has, explore the SAP ECC integration or talk to the APPSeCONNECT team about your SKU volume, locations and SAP landscape.

Frequently Asked Questions