Real-time bidirectional Shopify sync. Across every store. Without drift.
Store Sync is the movement layer inside Apimio. Subscribes to Shopify's native product, variant, inventory, metafield, and media webhooks per connected store. Writes from Catalogue Hub fan out through a durable queue with exponential backoff and dead-letter handling. Sub-second propagation on healthy networks. Auto catch-up when Shopify recovers from an outage. Plus Organization Admin connects entire orgs without per-store reauthorization. The Friday-afternoon manual sync ritual ends here.
Store Sync in production
Numbers from multi-store Shopify operators running on Store Sync — across 2–10 connected stores per workspace and Shopify Plus organizations with 8+ stores.
The sync-drift failure pattern
Multi-store sync breaks in four distinct ways. Each one costs you a different kind of trust — with customers, dealers, or finance. Store Sync is the operational answer to all four.
How sync fails today
What Store Sync does about it
"Real-time" sync apps are actually polling
Most third-party Shopify sync apps poll on a 5-minute cadence. That's your drift window every hour. Combined with missed retries on transient network errors, drift compounds across stores until a customer or dealer flags it.
Webhook-driven, not polling
Store Sync subscribes to Shopify's native product, variant, inventory, metafield, and media webhooks per connected store at OAuth time. Events trigger writes within seconds. Polling is never used as the primary mechanism — only as a reconciliation backstop.
Webhooks get missed and never replayed
Webhook deliveries fail (rate limits, brief network issues, app downtime). Most integrations don't retry beyond Shopify's built-in attempts. Events vanish silently. The change made in Store A never reaches Store B. The diff surfaces in customer complaints, not in the Activity Log.
Durable queue + dead-letter retry
Every webhook event lands in a durable queue with exponential backoff. Failed deliveries are retried for hours before landing in the dead-letter side-channel. Nothing is silently dropped. The Activity Log shows the exact retry trail per event.
Shopify outages = data loss for naive integrations
When Shopify's API is slow or unreachable, naive sync integrations either fail loudly (paging engineers) or silently drop events (paging support a week later). Neither outcome is what production needs.
Auto catch-up when Shopify recovers
During a Shopify-side incident, Store Sync queues the events your stores generate plus the writes Apimio wants to send back. When Shopify returns, the queue catches up in the original event order — within minutes for short outages, within the SLO window for longer ones. No manual replay needed.
Shopify Plus orgs hit per-store OAuth tax
A Plus organization with 8 stores. Each store needs its own OAuth grant for most sync apps. Reauthorizing 8 stores when scopes change is hours of click-through. Adding the 9th store is a re-onboarding exercise. That tax compounds across years.
Plus Org Admin native — one OAuth, every store
Shopify Plus organizations connect via the Organization Admin API. One OAuth grant at the org level. Every store in the org surfaces for connection. Adding the 9th store is a configuration toggle in Apimio, not a re-onboarding sprint. Scope changes propagate across the org.
The six sync mechanics, in operational detail
These are the surfaces your ops + engineering teams will observe. Each capability described here is the actual production behavior, not the brochure version.
Webhook subscriptions per store
At OAuth, Store Sync subscribes to Shopify's native webhooks per resource per store: product create/update/delete, variant edits, inventory level changes, metafield updates, media attached/detached. Subscriptions are kept in sync with Apimio's feature surface.
- Native webhook subscriptions (no polling as primary mechanism)
- Subscriptions registered automatically per connected store
- Reconciliation sweep nightly to catch missed events
- Webhook health dashboard surfaces delivery rate per store
- Per-resource subscriptions: product, variant, inventory, metafield, media
- Auto re-subscribe if a store reinstalls Apimio
Durable queue + exponential backoff
Every inbound webhook event and outbound write lands in a durable queue. Retries follow exponential backoff (immediate, 30 sec, 2 min, 10 min, 30 min, 1 hr, ...) up to the dead-letter threshold.
- Persistent queue — survives worker restarts and deployments
- Per-resource ordering preserved (no out-of-order writes)
- Exponential backoff: ~1m → 30m → 2h → 6h → dead-letter
- Dead-letter side channel for events that never succeed
- Replay UI: manually retry a dead-lettered event after a fix
- Visible queue depth + age in the Activity Log
Multi-store fan-out from one canonical edit
When an edit lands in Catalogue Hub (canonical record), Store Sync fans it out to every connected store via the same queue. Per-store overrides apply at write time so each store gets the right merged values.
- One canonical edit → N store writes, one queued operation per store
- Per-store override layer merged at write time
- Fan-out queue depth visible per store + per operation
- Failed store retries without restarting the whole fan-out
- Sale Scheduler + Supplier Bridge writes use the same fan-out
- Independent retry budgets per store (one slow store does not block others)
Plus Organization Admin support
Shopify Plus orgs connect via the Organization Admin API. One OAuth grant covers every store in the org. Adding the next store inside the org is a configuration toggle. Scope changes propagate.
- One Org-level OAuth (no per-store reauth)
- Every org store auto-discovered + available for connection
- Adding the 9th store is a 1-click toggle, not re-onboarding
- Scope updates propagate across the org in one grant
- Org-level activity log + per-store filtering
- Recognized natively — no manual feature flag
Conflict resolution + audit per attribute
When two writes target the same attribute concurrently (manual edit vs Shopify-side webhook), Store Sync resolves via last-write-wins at the attribute level with full audit trail of the contender writes. ETag / If-Match used where Shopify supports it.
- Last-write-wins at the attribute level (not the row level)
- Losing writes captured in the audit log (not silently dropped)
- ETag / If-Match against Shopify where supported (concurrent-edit safe)
- Optimistic concurrency control on canonical writes
- Conflict surfaces in Activity Log for human review on high-value attrs
- Per-attribute rollback (via Catalogue Hub) if conflict resolution went wrong
Activity Log + sync health metrics
Every sync event observable: source webhook, target store, target resource, timestamp, status (succeeded/queued/retrying/dead-lettered). Metrics surface queue depth, retry rate, latency P50/P95/P99 per store.
- Per-event status + retry trail (no silent failures)
- Per-store metrics: queue depth, retry rate, latency percentiles
- Filter by store, resource type, time range, status
- Webhook delivery rate dashboard (per Shopify store)
- Alerting hooks for dead-letter events (Slack, email, webhook)
- "Queued — waiting on Shopify" status during outages
Five steps from OAuth to continuous multi-store sync
From the first OAuth to bidirectional sync running across every connected store. Most teams add stores 2–5 in their first week and reach steady-state sync within the same session.
Install + OAuth (per store or per org)
Install on the first Shopify store via the App Store. OAuth grants product / variant / inventory / metafield / media read+write + webhook registration scopes. Shopify Plus orgs grant at the org level once and connect every store from there.
Webhook subscriptions registered
Store Sync registers native webhook subscriptions per store at OAuth time — for products, variants, inventory levels, metafields, and media. The webhook health dashboard shows delivery rate per store from this moment forward.
Initial reconciliation pull
Store Sync runs a paginated GraphQL pull of your existing Shopify catalog to seed Catalogue Hub's canonical records. After this, the system is bidirectional — edits in Apimio sync to Shopify, edits in Shopify sync to Apimio.
Connect store 2, 3, 4…
Each additional store is OAuth + add. Shared SKUs merge against the canonical record in Catalogue Hub. The per-store override layer surfaces immediately for differentiation. Fan-out queues activate from the moment of connection.
Steady-state sync + monitoring
From here on, every edit flows in real time through the canonical record. The Activity Log shows every sync event. Webhook health, queue depth, and retry rate are continuously surfaced. Drift becomes structurally impossible.
Outcomes from real-time bidirectional multi-store sync
The operational changes teams report within their first month after Store Sync replaces the Friday-afternoon manual sync ritual — separate from the PIM outcomes (those are on the Catalogue Hub page).
Friday-afternoon sync ritual ends
The 1–2 hour weekly task of pushing edits across stores manually disappears. The reclaimed time flows into work that was always being deferred — alt text, descriptions, dealer outreach, supplier onboarding.
Real-time edits across stores
A product update in Catalogue Hub propagates to every connected store within seconds, not the next sync window. Customer-facing inconsistencies disappear. The reviews mentioning "different price on different site" stop.
Shopify outages stop costing data
Durable queue + auto catch-up means an extended Shopify-side incident becomes a "wait it out" event, not a "page engineering" event. Production teams stop spending nights chasing missing webhooks.
Plus orgs unblock fast scaling
Adding the next store in a Shopify Plus org becomes a 5-minute task instead of a quarterly project. International market expansion via dedicated stores stops being a re-onboarding decision.
Fan-out queues unblock other Apimio products
Sale Scheduler's multi-store fan-out runs on the same queue. Supplier Bridge imports write through it. Trade Portal publishes through it. Every other Apimio surface benefits from Store Sync's reliability.
Sync observability turns ops into engineering
The Activity Log + per-store metrics turn "I think the sync is working" into "I can prove it." Ops teams move from reactive (waiting for complaints) to proactive (watching webhook delivery rate).
Store Sync vs Shopify admin and third-party sync apps
Three approaches to keeping multi-store Shopify catalogs in sync. Store Sync is the only one with webhook-driven events + durable queue + Plus Org Admin support together.
Shopify admin alone | Third-party sync apps | Webhook + queue + Plus org Store Sync | |
|---|---|---|---|
| Real-time event source | |||
| Durable queue + retry | |||
| Auto catch-up on Shopify outages | |||
| Multi-store fan-out (one canonical → N stores) | |||
| Plus Organization Admin support | |||
| Conflict resolution + audit per attribute | |||
| Activity Log + sync health metrics | |||
| Setup per store | Manual workflows | 1 day per pair | 30 seconds (OAuth) |
Questions about running multi-store Shopify sync at scale
The questions we get most often from ops + engineering teams evaluating Store Sync. PIM-data-model questions live on the Catalogue Hub page if that's your area.
Catalogue Hub is the PIM layer — it holds the canonical product records, variant matrices, per-store override structure, locales, schema, and audit log. Store Sync is the movement layer — it bidirectionally synchronizes those canonical records to every connected Shopify store in real time via webhooks + a durable queue. Catalogue Hub holds the data; Store Sync moves it. The two work together; most teams adopt both.
At OAuth, Store Sync subscribes to Shopify's native webhooks per store (product, variant, inventory, metafield, media). Every event lands in a durable queue with exponential backoff + dead-letter side-channel. Writes from Apimio to Shopify use the same queue model. Sub-second propagation on healthy networks; minutes during Shopify-side incidents; never silently lost.
Last-write-wins at the attribute level — not the row level. The losing write is captured in the audit log with full source attribution (manual / API / AI / sync), so you can review and roll back if needed. ETag / If-Match is used against Shopify where supported, to fail the second write rather than silently overwrite. High-value attributes (price, inventory) can surface conflicts to the Activity Log for human review.
The queue persists. Failed writes are retried with exponential backoff. If Shopify's API is unreachable for an extended window, the queue catches up in the original event order when the API returns — usually within minutes. The Activity Log surfaces "Queued — waiting on Shopify" status so you know events are queued but held up. We haven't lost a write yet, and Shopify outages are public + traceable.
No — Store Sync recognizes Shopify Plus Organization Admin natively. One OAuth grant at the organization level surfaces every store in the org for connection. Adding a new store inside the org becomes a configuration toggle in Apimio. Teams running 8+ stores on Plus never reauthorize per-store, and scope updates propagate across the org in one grant.
Yes — all of them, individually. Webhook subscriptions cover product create/update/delete, variant edits, inventory level changes (per location), metafield updates, media attached/detached. Sync is per-resource, with ordering preserved per resource (no out-of-order writes within a product's history).
The Activity Log + per-store metrics dashboard surface: per-store queue depth, retry rate, P50/P95/P99 sync latency, webhook delivery rate, dead-letter event count + age. Filter by store, resource type, status, time range. Alerting hooks (Slack, email, webhook) fire on dead-letter events or sustained latency degradation.
No. First connection is read-only from Shopify into Catalogue Hub. Your existing Shopify data is the starting source of truth. Bidirectional sync activates only after the first pull completes and you've had a chance to review what's in the Hub. No automatic writes back to Shopify until you explicitly opt in.
Store Sync is the underlying movement layer. Catalogue Hub edits fan out through it. Sale Scheduler's multi-store fan-out uses the same queue. Supplier Bridge's imports write through it. Trade Portal's publishes use it. Quality Guard's gate is enforced before any write enters the queue. Every other Apimio product reads from Catalogue Hub and writes through Store Sync.
End the manual sync ritual — real-time bidirectional Shopify sync
Install Apimio, connect your first Shopify store, watch Store Sync register webhooks and start moving edits in seconds. The 14-day trial includes the full sync stack — webhook subscriptions, durable queue, multi-store fan-out, Plus Organization Admin, Activity Log. No credit card required.