# Shopify Store Intel — Product & Pricing Analytics (Prime Sieve) (`primesieve/shopify-store-intel`) Actor

Batch-scrape any number of Shopify storefronts via the public products.json endpoint and get full product data PLUS store-level rollup analytics: median price, discount rate, top product types, top tags, best sellers. Competitive intelligence for dropshippers, suppliers, and e-commerce analysts.

- **URL**: https://apify.com/primesieve/shopify-store-intel.md
- **Developed by:** [Prime Sieve](https://apify.com/primesieve) (community)
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Shopify Store Intel — Prime Sieve

**Batch-scrape any Shopify storefront and get full product data PLUS store-level analytics in one run.**

Built by Prime Sieve. Uses Shopify's public `/products.json` endpoint — no login, no API key, no browser.

### What you get

Paste store URLs (or search via other actors), get:

**Per-product rows** (one per variant):

- title, handle, product URL
- price, compare\_at\_price, **on\_sale** flag
- variant title, SKU, availability
- product type, vendor, tags, image URL, created/updated timestamps

**Store-level summary row** (one per store):

- product count, median/min/max price
- **on-sale ratio** (dropshippers: what fraction is discounted)
- available-stock ratio
- **top 10 product types**, **top 15 tags**, **top vendors**
- **newest arrivals** (top 5 by created date)
- contact emails (optional, from homepage)
- scrapedAt timestamp

### Pricing

**$2.00 per 1,000 results** — pay per result, no subscriptions.

| | Prime Sieve (this) | logie/shopify-products-scraper | parsebird/shopify-store-leads |
|---|---|---|---|
| Price | **$2.00 / 1K** | $5/mo + usage | $2.70 / 1K |
| Batch store URLs | ✅ | ✅ | ❌ (keyword discovery) |
| Store-level rollup analytics | ✅ | ❌ | partial |
| on-sale / compare-at detection | ✅ | ❌ | ❌ |
| Maintenance | active | 2 yrs stale | active |

Pure products.json scrapers on the Store (khadinakbar, bluefin, ef12, ezzatox) are stale and unmaintained (~2 users each). This ships the same core data **plus analytics** the raw scrapers don't.

### Use cases

1. **Dropshipping/competitive intel** — dump a competitor's catalog, see price bands, discount strategy, and what tags/types they push
2. **Supplier research** — feed store URLs from a keyword-Search actor, extract prices + contact emails for outreach
3. **Market analysis** — track median price, on-sale ratio, and top types across a niche of Shopify stores
4. **E-commerce monitoring** — schedule runs, diff `on_sale` and `price` over time

### Input

```json
{
  "storeUrls": ["https://gymshark.com", "https://allbirds.com"],
  "maxProductsPerStore": 0,
  "includeStoreSummary": true,
  "extractEmails": false
}
```

All fields except `storeUrls` are optional. `maxProductsPerStore: 0` = fetch all pages. Up to 250 products per request, auto-paginated.

### Output sample (product row)

```json
{
  "_type": "product",
  "shop": "https://gymshark.com",
  "title": "Gymshark Boxer Brief 5PK",
  "handle": "gymshark-boxer-brief-5pk",
  "product_type": "Mens>Apparel>Underwear",
  "price": 35,
  "compare_at_price": 45,
  "on_sale": true,
  "available": true,
  "sku": "GLSB5PK-XS",
  "tags": ["size:xs", "mens", "underwear"],
  "url": "https://gymshark.com/products/gymshark-boxer-brief-5pk"
}
```

### Output sample (store summary row)

```json
{
  "_type": "storeSummary",
  "shop": "https://gymshark.com",
  "productCount": 1450,
  "medianPrice": 42,
  "onSaleRatio": 0.14,
  "topProductTypes": [{"value": "womens sports bra", "count": 210}],
  "topTags": [{"value": "sale", "count": 180}],
  "newestProducts": [{"title": "...", "price": "38.00"}],
  "scrapedAt": "2026-09-07T07:00:00.000Z"
}
```

### How it works

1. Normalizes each store URL, strips path/query
2. Fetches `/products.json?limit=250&page=N` until empty page or cap
3. Flattens variants → product rows
4. Computes store summary from the fetched set
5. Optionally fetches homepage and extracts contact emails (`mailto:` + regex)

### Limitations

- **Only public products.json** — no password-protected stores, no hidden SEO variants. Some themes cap `limit=250` per page.
- **Prices are list prices** — no currency conversion, no historical tracking (yet).
- Store checkout/collections/pages are NOT scraped (products only).

### Roadmap

- Historical snapshots: price-change alerts (schedule runs, diff against KV store)
- Collection-level breakdown (which collections drive the catalog)
- Bulk store discovery by keyword (pair with an existing search actor or Shop.com API)

***

### 📬 Get Remote Tech Roles Weekly

Prime Sieve ships the [Remote Signal](https://remotesignal.substack.com) newsletter every Wednesday — 5 featured remote engineering roles + 10 quick hits, with tech stack and salary when disclosed. Keep sharp on the dev side while you scale the e-commerce side.

👉 **[Subscribe to Remote Signal](https://remotesignal.substack.com)** · [@PrimeSieveCoder on X](https://x.com/PrimeSieveCoder)

### About Prime Sieve

Prime Sieve is the dev/tech brand by **PrimeSieveCoder**. We build small, sharp tools for solo developers — Apify actors, micro-SaaS, and the Remote Signal newsletter. Other actors cover GitHub repo search, Apify Store scraping, Substack hiring signals, and more.

Built in Indonesia. Run from anywhere.

# Actor input Schema

## `storeUrls` (type: `array`):

List of Shopify storefront URLs (e.g. https://gymshark.com). Products are fetched via the public /products.json endpoint.

## `maxProductsPerStore` (type: `integer`):

Cap on products fetched per store (0 = fetch all pages).

## `includeStoreSummary` (type: `boolean`):

If true, appends one summary row per store with median price, discount ratio, top types, top tags, and counts.

## `extractEmails` (type: `boolean`):

If true, fetches each store's homepage and extracts mailto: links and email addresses. Adds ~1 request per store.

## Actor input object example

```json
{
  "storeUrls": [
    "https://gymshark.com"
  ],
  "maxProductsPerStore": 0,
  "includeStoreSummary": true,
  "extractEmails": false
}
```

# Actor output Schema

## `_type` (type: `string`):

product | storeSummary

## `shop` (type: `string`):

Base URL of the storefront

## `title` (type: `string`):

Product title

## `handle` (type: `string`):

Product handle

## `product_type` (type: `string`):

Product type

## `vendor` (type: `string`):

Vendor

## `price` (type: `string`):

Price in USD

## `compare_at_price` (type: `string`):

Compare-at price

## `on_sale` (type: `string`):

True when compare\_at\_price > price

## `available` (type: `string`):

Variant availability

## `tags` (type: `string`):

Product tags (comma-joined)

## `url` (type: `string`):

Product URL

## `created_at` (type: `string`):

Product created timestamp

## `medianPrice` (type: `string`):

Store median price (summary)

## `onSaleRatio` (type: `string`):

Fraction of products on sale (summary)

## `topProductTypes` (type: `string`):

Top product types (summary)

## `topTags` (type: `string`):

Top tags (summary)

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("primesieve/shopify-store-intel").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("primesieve/shopify-store-intel").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call primesieve/shopify-store-intel --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,primesieve/shopify-store-intel"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/qecEEtiantrOLBS5c/builds/O307tJFPfPeDxiusp/openapi.json