Shopify Store Intelligence — Catalog, Price & Stock Tracker

Track product launches, price changes, and stock signals across hundreds of Shopify stores in one actor. KV-checkpointed delta detection plus AI-powered store audits. Replaces Storeleads ($75–950/mo) and Particl ($250–1000/mo) at fraction-of-a-cent PPE pricing.

What does Shopify Store Intelligence do?

Five modes against the public Shopify storefront endpoints (/products.json + /products/<handle>.json + sitemap fallback):

1. catalog_snapshot — full product dump for one or many stores
2. new_launches — products created in the last N days OR new since your last run; each launch is reported (and billed) once
3. price_changes — variant-level price + compare-at-price deltas vs your previous run (the Particl-killer)
4. stock_signals — variants going in/out of stock; with deep-probe enabled, true inventory_quantity deltas including low-stock alerts
5. store_audit — one-shot per-store report with aggregate stats and Gemini-powered niche classification (BD/M&A use case)

All output is one unified row shape discriminated by type (product / delta / audit).

Why use Shopify Store Intelligence?

• DTC competitive intel teams — track 50–500 competitor stores weekly, surface price moves and new launches the same day
• Trend hunters / dropshippers — find what competitors test before it explodes
• M&A scouts / agencies — one-shot store_audit returns niche, buyer persona, brand positioning, price tier, and full catalog stats per store
• Repricing / brand pricing analysts — price_changes deltas down to the variant SKU level
• Demand forecasters — stock_signals flag products selling out fast (predictive of hot SKUs)

How to use Shopify Store Intelligence

1. Pick a mode (start with store_audit for one store to see what you get)
2. Paste 1–500 store domains (allbirds.com, kith.com, mvmt.com — bare domains, http stripped automatically)
3. Set maxProductsPerStore to control PPE budget (small catalogs: leave default; big brands: cap at 500)
4. For price_changes / stock_signals / new_launches: schedule the actor (Apify Schedules or a saved task) weekly or daily — the first run captures a baseline, every later run reports changes against the previous run (see How monitoring state works)
5. For big brands behind WAF (Gymshark-tier), enable proxyConfiguration → useApifyProxy: true — sitemap fallback handles the rest
6. Export results as JSON / CSV / Excel via Apify's standard download

Input

Minimal example (audit one store with AI niche classification):

{
  "mode": "store_audit",
  "storeDomains": ["allbirds.com"],
  "enableAiNiche": true
}

Track price changes across a competitor set (run weekly):

{
  "mode": "price_changes",
  "storeDomains": ["allbirds.com", "rothys.com", "vejashoes.com"],
  "maxProductsPerStore": 500,
  "concurrency": 8
}

Two independent monitors on the same store (e.g. daily + weekly) — give each its own state store:

{
  "mode": "price_changes",
  "storeDomains": ["allbirds.com"],
  "stateStoreName": "allbirds-weekly-prices"
}

Find new launches in the last 14 days:

{
  "mode": "new_launches",
  "storeDomains": ["mvmt.com", "thursdayboots.com"],
  "lookbackDays": 14
}

Stock signals with true inventory probe (slower, more expensive, higher signal):

{
  "mode": "stock_signals",
  "storeDomains": ["bombas.com"],
  "deepInventoryProbe": true,
  "lowStockThreshold": 10
}

Bypass WAF on big brands with residential proxy:

{
  "mode": "catalog_snapshot",
  "storeDomains": ["gymshark.com"],
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}

Output

Sample product row (from catalog_snapshot / new_launches):

{
  "type": "product",
  "store": "allbirds.com",
  "title": "Trino® Cozy Crew - Heathered Onyx",
  "vendor": "Allbirds",
  "productType": "Socks",
  "available": true,
  "variantCount": 4,
  "priceMin": 12,
  "priceMax": 12,
  "currency": "USD",
  "publishedAt": "2026-04-21T12:39:05-07:00",
  "productUrl": "https://allbirds.com/products/trino-cozy-crew-heathered-onyx",
  "variants": [
    {
      "title": "S (W5-7)",
      "sku": "PCC1HONU301",
      "price": 12,
      "compareAtPrice": 24,
      "available": true,
      "inventoryQuantity": null
    }
  ],
  "source": "products.json"
}

Sample delta row (from price_changes / stock_signals):

{
  "type": "delta",
  "store": "allbirds.com",
  "deltaType": "price_change",
  "productTitle": "Wool Runner",
  "variantTitle": "Black / Size 10",
  "oldValue": 110,
  "newValue": 88,
  "detectedAt": "2026-05-08T12:00:00.000Z"
}

Sample audit row (from store_audit with enableAiNiche: true):

{
  "type": "audit",
  "store": "allbirds.com",
  "isShopify": true,
  "productCount": 50,
  "vendorCount": 1,
  "avgPrice": 32.90,
  "medianPrice": 25,
  "currency": "USD",
  "availableShareOfCatalog": 0.16,
  "primaryNiche": "sustainable footwear and apparel",
  "secondaryNiches": ["eco-friendly accessories", "comfortable everyday wear"],
  "buyerPersona": "Environmentally conscious consumers who prioritize comfort, sustainability, and minimalist design",
  "brandPositioning": "Allbirds positions itself as a leader in sustainable fashion, offering comfortable products made from natural, renewable materials",
  "priceTier": "premium",
  "aiConfidence": 0.95
}

Data fields

Field	Type	Where it appears	Notes
type	string	every row	product / delta / audit discriminator
store	string	every row	bare domain (no scheme)
productId	string	product, delta	<domain>::<shopifyId>
variants[]	array	product	array of { title, sku, price, compareAtPrice, available, inventoryQuantity }
inventoryQuantity	number|null	variant	only populated when store exposes it (depends on Shopify config)
deltaType	string	delta	price_change, compare_at_change, stock_in, stock_out, low_stock, restock
primaryNiche	string	audit	Gemini classification when enableAiNiche: true
priceTier	enum	audit	budget / mid / premium / luxury
source	enum	product	products.json / product-handle / sitemap-fallback

How much does it cost to scrape Shopify with this actor?

Event	Price	When it fires
Actor start	$0.01	Once per run, per GB of memory
Product fetched	$0.005	Each product written in catalog_snapshot mode
Price change detected	$0.02	Variant price or compare_at_price changed since last run
New launch detected	$0.01	Product created in the lookback window OR new since last run — once per product, never again on later runs
Stock signal detected	$0.01	Variant flipped in/out of stock or crossed low-stock threshold
Store audited	$0.50	One-shot per-store report with aggregate stats
AI niche classified	$0.05	Gemini classification appended to a store_audit row
Residential proxy fetch	$0.003	Fired only when proxyConfiguration.useApifyProxy: true

Free trial: the first 10 custom chargeable events per run are free.

Typical-run costs:

• Audit 5 stores with AI: 5 × ($0.50 + $0.05) = $2.75
• Catalog snapshot 10 stores × 200 products: 2,000 × $0.005 = $10
• Weekly price-change monitor across 100 stores (~50 deltas/week observed): 50 × $0.02 = $1/week
• Stock signals on 50 high-traffic stores (~30 signals/run): 30 × $0.01 = $0.30/run

Compare: Storeleads $75–950/mo, Particl $250–1,000/mo, Charm.io enterprise.

How monitoring state works

price_changes, stock_signals and new_launches compare each run with the previous run's snapshot of every store. That snapshot has to outlive the run, so it is saved in a named key-value store in your own Apify account (a run's default storage is wiped for every new run):

Mode	Default state store
price_changes	shopify-intel-price-changes
stock_signals	shopify-intel-stock-signals
new_launches	shopify-intel-new-launches

• One record per store and mode, key <mode>--<domain> (e.g. price-changes--allbirds.com). Adding a store to your list baselines only that store; the others keep their history. Modes never share a snapshot, so a price_changes run can't hide stock changes from your stock_signals monitor.
• First run for a store = baseline. The snapshot is captured and no change rows are emitted for that store (and no change events are charged). The run log says BASELINE, and the run's OUTPUT record (Storage → Key-value store → OUTPUT, also linked as Monitoring run summary in the Output tab) lists every store as baseline or compared, with the time of the snapshot it was compared against. new_launches still returns products published inside lookbackDays on a first run; that criterion needs no baseline.
• Every later run compares against the stored snapshot, emits the changes, then saves the new snapshot.
• Failed scans never overwrite a baseline. If a store is blocked, returns an empty catalog, errors, or is skipped because the run is about to time out or hit maxItems, its previous snapshot is kept and the changes are picked up on the next successful run. If maxItems cuts a store off partway, the changes that weren't delivered are held back and reported next run.
• Independent monitors: two schedules that track the same store in the same mode (e.g. a daily and a weekly one) should each set their own stateStoreName. Otherwise each run compares against whichever ran last.
• Reset / start over: either set a new stateStoreName (the next run is a fresh baseline), or delete the store — or a single <mode>--<domain> record — in Apify Console → Storage → Key-value stores. Named stores are kept until you delete them.
• Each launch is reported once. new_launches remembers the products it already returned (in the same state record) and never returns or charges them again, even while they are still inside lookbackDays. A launch is dated by the product's creation date: stores often bulk-republish their whole catalog, which resets Shopify's publish date but not the creation date. Once a store has a baseline, a product that was already in it is never a launch; a product the previous run didn't see counts only if it was created inside the window or after the previous run. Launches that were detected but couldn't be delivered (maxItems, the run's cost limit, timeout) are kept and delivered on the next run. Remembered products are forgotten once their creation date leaves the window, so the record stays small.
• Restarts and timeouts are safe: if Apify migrates or restarts a run mid-way, rows it already delivered are neither pushed nor charged again (in every mode). If the run is aborted or about to time out while a store is delivering changes, it stops after the current row and saves the baseline for what was delivered; the rest is reported next run.

Maximum cost per run

If you set Maximum cost per run (run options), the actor checks the remaining budget before every paid step and never works past it. When the budget runs out it stops gracefully: the row being written finishes, monitor baselines move forward only for the changes actually delivered (changes it could not deliver are reported on the next run), stores it didn't reach keep their previous baseline, and the run succeeds with status charge limit reached in the status message and the OUTPUT record. In store_audit, the AI niche classification is skipped when the budget covers the audit but not the AI step; a proxied request is never sent without budget for its proxy-fetch event.

Tips & advanced options

• First run of a monitor mode = baseline only. See above. Schedule the actor for repeated runs to see real changes.
• maxProductsPerStore is your budget knob. Large catalogs (5,000+ products) blow through PPE fast. Cap aggressively for monitoring use cases.
• WAF-blocked stores (Gymshark-tier) auto-fall-back to sitemap parsing — slower but works without a proxy. Enable useApifyProxy: true for full /products.json access.
• deepInventoryProbe only adds inventory counts. In-stock / out-of-stock always comes from the store's product list; the probe adds inventoryQuantity where the store exposes it, and a failed probe changes nothing.
• inventory_quantity exposure varies by store. Many stores (e.g. Allbirds, checked 2026-09-29) expose it on /products/<handle>.json; others hide it and it stays null. The available boolean is always populated.
• Schedule with Apify Schedules. Run price_changes weekly, new_launches daily for a low-cost monitoring stack.
• One actor for many use cases. The dataset is discriminated by the type field — filter downstream consumers (BI tools, n8n, Make.com webhooks) on type === 'delta' or type === 'audit'.

Legal disclaimer

This actor reads only publicly accessible Shopify storefront endpoints (/products.json, /products/<handle>.json, /sitemap.xml) — the same data any browser can request without authentication. No Shopify accounts, OAuth, or admin access is required or used. We do not bypass paywalls, login walls, or rate limits.

Each store's robots.txt should be respected by users; if a store explicitly disallows crawling, do not use this actor against it. Public catalog data is generally not personal information under GDPR/CCPA, but consult counsel for your jurisdiction before storing or republishing.

Shopify and the Shopify storefront APIs are trademarks of Shopify Inc. This actor is not affiliated with, endorsed by, or sponsored by Shopify Inc.

FAQ

Will this work on every Shopify store? Most. About 70–80% of Shopify stores leave /products.json open by Shopify default. Big brands (Gymshark, fashion-world enterprise) WAF-block the JSON path — for those, the actor automatically falls back to sitemap-based discovery. Enable Apify residential proxy to recover full coverage on these.

Why does inventoryQuantity come back as null sometimes? Shopify lets store owners hide inventory counts via theme settings. When hidden, you only get available: true|false. The deepInventoryProbe option fetches /products/<handle>.json (which exposes counts on stores that allow it) but cannot bypass intentional hiding.

How is this different from existing Shopify actors on Apify? Existing actors return raw catalog dumps. This one adds: cross-run delta detection with a persistent per-store baseline (price + stock changes between runs), per-store AI niche classification, sitemap fallback for WAF-blocked stores, and unified output shape discriminated by type. No incumbent ships these together.

Can I find Shopify stores I don't already know about? Not in v1. Pass your own domain list. There is no public Shopify store directory — paid aggregators (BuiltWith, Wappalyzer) are required for at-scale discovery. We may add a niche-seeded discovery mode in v2.

Does this respect Shopify's ToS? We use only public storefront endpoints. Shopify's general ToS prohibits abusive scraping; this actor uses one User-Agent, defensive concurrency caps, and respects 4xx/429 responses. We recommend you respect each store's robots.txt and rate-limit your runs to the data freshness you actually need.

For issues / feature requests: report at Apify Console → Actor → Issues.

Changelog

• 2026-10 — AI niche classification (store_audit) now runs on Google Gemini 3.5 Flash-Lite, because OpenRouter retires Gemini 2.5 Flash on 2026-10-20. Same fields and same price. The wording of primaryNiche, secondaryNiches, buyerPersona and brandPositioning can differ from earlier runs on the same store, and priceTier / aiConfidence can shift. If the AI provider rejects the account (out of credit or key refused), the run now stops calling it once, delivers the remaining audits without AI fields (no ai-niche-classified charge), and says so in the run's status message and OUTPUT.