Does StoreTwin work with SparkLayer?
Yes, and the two apps do not overlap. SparkLayer turns a Shopify store into a wholesale storefront: price lists, customer groups, ordering rules, all kept in SparkLayer's own service and computed on top of the store's catalogue. StoreTwin keeps that catalogue in step with the retail store it came from: products, variants, SKUs, tags, descriptions and your own metafields flow one way, and both stores are compared field by field every hour and every day. We installed SparkLayer on the receiving store of a StoreTwin pair, edited and created products in the retail store, wrote SparkLayer-style data into the wholesale store, and read every result back from the stores themselves on 4 September 2026. Nothing below comes from reading documentation.
We are not affiliated with SparkLayer. This page describes what happened when both apps ran on the same pair of stores.
What we tested, and what actually happened
Tested on 4 September 2026. Source: a retail development store with seventeen products. Receiving store: a second development store with SparkLayer installed and set up - an automatic price list (20% off the Shopify price) assigned to a customer group, trading allowed, the SparkLayer app embed enabled on the live theme. StoreTwin on the free plan, with syncing switched on for the products picked on the connection page.
| Scenario | What happened | What did not |
|---|---|---|
| SparkLayer installed on the receiving store | SparkLayer registered itself as a sales channel and touched fourteen of the eighteen products in the receiving store within two seconds - each got a new modification time, without a single product webhook. StoreTwin's next check picked up all fourteen as changed, re-read them field by field and reported nothing: no difference, no repair. | No false differences from the install. |
A synced product edited in the retail store: title, a new tag, a metafield in the custom namespace | The webhook reached StoreTwin in under a second; the title, the tag and the metafield were written into the receiving store seven seconds after the edit. The wholesale storefront, with SparkLayer's embed running, showed the new title on the product page. | A price change made in the same edit was not copied and not reported. StoreTwin sets a price once, when it creates a product, and never moves it afterwards - so a retail price edit does not reach the wholesale store, and the difference is not listed either. |
| A new product created in the retail store | While not picked for syncing, the check listed it as not in the other store and created nothing - the free plan copies only what you pick. Picked on the connection page, it was created in the receiving store nine seconds later with its SKU, price, tags, description and custom metafield, and appeared in that store's catalogue like any other product. | Nothing lost. |
SparkLayer-style data written on the wholesale side: two variant metafields in the sparklayer namespace, one product metafield in a b2b namespace | The variant metafields were invisible to StoreTwin: the next check did not mention them and the repair did not touch them. The product metafield was named as a difference - none in the retail store, a value in the wholesale store - and left exactly where it was. | That product-level difference stays in the report on every check until you remove it or mirror it in the retail store. StoreTwin never deletes anything, so the value is safe; it is just visible. |
| SparkLayer's 20% price list assigned to a customer group | The Shopify variant price in the wholesale store stayed what it was. SparkLayer never wrote to a product or variant during the run - the variants' modification times did not move, and no product webhook arrived from it. StoreTwin had nothing to see, and saw nothing. | Nothing to repair, nothing repaired. |
Why this pairing is clean
SparkLayer keeps its wholesale layer outside the product record. Price lists, customer groups and ordering rules live in SparkLayer's service; the little it stores in the shop sits on variant metafields in its own namespace. StoreTwin reads product-level fields and metafields, compares them, and writes only into the custom namespace merchants use for their own fields. The two apps touch different parts of the same product, and the run above is what that looks like in practice: catalogue changes flow in from the retail store, the wholesale layer stays put.
The one deliberate gap is price. StoreTwin does not copy price changes after a product is created, precisely because a wholesale store usually has its own reasons for a different base price - and SparkLayer's automatic price lists compute from the wholesale store's own Shopify price, not the retail one. If you want the retail price to follow, set it once at creation and let SparkLayer's lists do the wholesale arithmetic.
The boundaries, stated plainly
- Variant metafields are not read, compared or written by StoreTwin. That is why SparkLayer's per-variant data is safe from the sync - and also why a variant metafield you maintain yourself in the retail store will not travel.
- Product metafields outside the
customnamespace are compared but never written: a value that exists only in the wholesale store shows up as a named difference on every check and is left alone. - Prices are set at creation and never moved. Retail price edits do not reach the wholesale store and are not listed as differences.
- Stock is copied one way, location by location - a wholesale sale does not reduce retail stock. If both stores sell the same units, you need pooled inventory, which StoreTwin is not; the split is explained on shared inventory between a wholesale and a retail store.
- SparkLayer's own settings - price lists, customer groups, ordering rules, its dashboard - live in SparkLayer's infrastructure and are neither synced nor touched by StoreTwin.
- Not covered by this run: a signed-in wholesale buyer's view and a B2B checkout. The run verified the catalogue underneath SparkLayer, not SparkLayer's own storefront.
If you run both apps
- Put SparkLayer on the store that receives the catalogue - the wholesale one.
- Keep your own product fields in the
customnamespace if you want them to travel; keep wholesale-only product fields in another namespace if you want them to stay - and expect to see them in the report. - Set the wholesale base price when the product is first created there, then let SparkLayer's price lists do the rest. Do not expect retail price edits to follow.
- After installing SparkLayer, glance at the connection page once: the install touches every product, and you should see the check pass clean - as it did here.
What the app syncs and what it leaves alone is listed in full on what sync apps can and cannot do.
Tested 4 September 2026 with SparkLayer installed on the receiving store of a StoreTwin pair, both stores Shopify development stores. Every line above was read back from the stores after each step. App behaviour changes with releases; if you see something different, tell us at support@storetwin.app and we will re-run the test. The other pairing we have tested: Arigato Automation. Comparing sync apps themselves: the category compared.
The free plan audits the whole catalogue under your wholesale store and names every difference by product and field - before you switch syncing on.