# Shopify Products + Store Info (`s-r/shopify-products`) Actor

Hosted shopify scraper that pulls the full product catalog and store metadata from any Shopify storefront as structured JSON. Run it from the Apify Store with one click, or call it from your own service via the Apify API. Pay per product, not per month.

- **URL**: https://apify.com/s-r/shopify-products.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** E-commerce, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Product Scraper: Full Catalog via products.json

Hosted **shopify scraper** that pulls the full product catalog and store metadata from any Shopify storefront as structured JSON. Run it from the Apify Store with one click, or call it from your own service via the Apify API. Pay per product, not per month.

If you've been searching for a **shopify product scraper**, a **shopify scraper chrome extension** that doesn't depend on a brittle browser plugin, a **shopify scraper github** repo that's actually maintained, or a free Shopify scraper that doesn't crap out on stores with thousands of products, this Actor is the hosted, maintained alternative.

### What you get

- **Full product catalog** from any Shopify storefront, title, handle, vendor, product type, tags, variants (with prices and SKUs), images, options, full body HTML.
- **Store metadata** in the same dataset, name, currency, country, shipping coverage, the internal `myshopify_domain`, and active theme ID (signals tech-stack detection).
- **No proxy needed**, Shopify exposes `/products.json` and `/meta.json` openly on every storefront. The Actor doesn't need any auth or proxy.
- **Up to 5,000 products per run**, paginated 250 per page with gentle rate-limiting.
- **Pay only for what you scrape**, pricing scales per product (cheap for catalogs) plus a separate event for store-detected (BuiltWith-replacement use case).

### Why scrape shopify product data

Shopify powers ~30% of the world's e-commerce stores. For competitive pricing monitoring, dropshipping research, affiliate catalog enrichment, or BuiltWith-style tech detection, the `/products.json` endpoint is the cleanest data source on the open web, it returns the entire catalog in pure JSON without any anti-bot complications.

The challenge is operational: most teams don't want to write the pagination logic, the `meta.json` detection probe, the variant-flattening, and the daily-diff scheduling themselves. This Actor packages all of that as a hosted, billable Apify Actor, same data, no infrastructure.

### Two billing modes (one Actor, two use cases)

- **Catalog scraping** (dropshippers, competitive pricing): pay per product row returned. A 1,000-product catalog costs roughly $1.
- **Tech detection** (BuiltWith replacement, sales prospecting): pay per store confirmed Shopify. One charge per store includes currency, country, theme ID, ships-to countries, and the `myshopify_domain`, billed at a fraction of BuiltWith's $295-$995/month flat fee.

Both modes share the same Actor. Set `include_meta=true` (the default) and the first row of every run is the `store_meta` record.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `domain` | string | **required** | Shopify storefront domain (with or without `https://`). E.g. `allbirds.com`, `www.gymshark.com`. |
| `max_products` | integer | `250` | Pagination cap (250 per page, up to 5,000 total). |
| `include_meta` | boolean | `true` | Emit a leading `record_type='store_meta'` row with name/currency/country/myshopify\_domain/theme\_id/ships-to. |

### Output

Two record types in the dataset.

#### `store_meta` (one row, first)

```json
{
  "record_type": "store_meta",
  "is_shopify": true,
  "domain": "www.allbirds.com",
  "myshopify_domain": "weareallbirds.myshopify.com",
  "name": "Allbirds",
  "currency": "USD",
  "country": "US",
  "city": "San Francisco",
  "ships_to_countries": ["US"],
  "theme_id": "129694433360",
  "page_type": "index",
  "detection_signals": ["meta.json: Shopify JSON payload", "server-timing.theme=…"]
}
```

#### `product` (one row per product)

```json
{
  "record_type": "product",
  "id": 6847823183952,
  "title": "Trino® Cozy Crew - Sienna",
  "handle": "trino-cozy-crew-sienna",
  "url": "https://www.allbirds.com/products/trino-cozy-crew-sienna",
  "vendor": "Allbirds",
  "product_type": "Socks",
  "variant_count": 4,
  "available_variant_count": 3,
  "min_price": 18.0,
  "max_price": 22.0,
  "image_count": 6,
  "first_image_url": "https://cdn.shopify.com/s/files/...",
  "domain": "www.allbirds.com"
}
```

### Use cases for the shopify scraper

#### Competitive pricing monitoring

Run the Actor daily on your top 10 competitors. Diff `min_price` and `available_variant_count` over time to surface price changes and stock-outs before they appear on price-comparison sites, useful input for your own pricing strategy.

#### Dropshipping product research

Pull catalogs from 100+ Shopify stores in your target category. Cluster by `product_type` and `vendor` to find under-supplied niches. The `min_price` and `max_price` columns surface typical category price ranges instantly.

#### BuiltWith replacement for Shopify-specific tech detection

If all you need is "is this a Shopify store, what currency, what country, what theme ID, where do they ship", a single run of this Actor (with `max_products=1`) gives you that for $0.025 per store, versus BuiltWith's $295/month flat fee or Wappalyzer Pro's $250/month / 5,000 lookups.

#### Sales prospecting and CRM enrichment

Pipe the `myshopify_domain`, `currency`, and `ships_to_countries` fields into your CRM as part of a nightly enrichment job. Filter prospects by Shopify Plus indicators (often visible in the theme metadata) to identify higher-budget accounts worth a sales touch.

#### Catalog migration and audit

Migrating off Shopify or auditing your own catalog before a re-platform? This Actor exports the full product catalog with variants, images, and metadata in a single run, usable as the source-of-truth dataset for the migration script.

### How it compares

Most tools are browser extensions you drive by hand, CSV-export SaaS sites, or credit-metered APIs. This Actor reads the public products.json endpoint server-side and returns the full catalog plus store metadata as JSON.

| | No account or key | Hosted for you | JSON output | Handles pagination past 250 |
|---|---|---|---|---|
| This Actor | Yes | Yes | Yes | Yes |
| Shopify Scraper (Chrome extension) | Install required | No, runs in your browser | CSV | Manual, page by page |
| shopify-scraper.com | No, account | Yes | CSV export | Plan-based |
| HasData Shopify Scraper | No, API key | Yes | Yes | Yes |

### FAQ

#### Is this shopify scraper free?

The Actor itself is hosted on Apify with pay-per-event pricing, no monthly subscription. A small store (200 products) costs a fraction of a dollar to scrape. You only pay for what you actually receive.

#### Is there a shopify scraper chrome extension equivalent?

Several Chrome extensions exist for Shopify product scraping, but they require a browser, manual one-page-at-a-time operation, and break when Shopify ships UI updates. This Actor runs server-side via the public `/products.json` endpoint, much faster, automatable, and resilient to UI changes.

#### Is there a shopify scraper github repo I could use instead?

There are dozens of open-source `/products.json` scrapers on GitHub, but most don't handle pagination correctly past 250 products, don't merge `meta.json` for store metadata, and don't have any retry/error handling. This Actor is the maintained, hosted alternative, same underlying endpoint, production-grade infrastructure.

#### Does this work for any Shopify store?

It works for every Shopify storefront whose owner hasn't actively disabled `/products.json` (which is rare, most stores leave it on for SEO and integrations). The Actor probes both the apex and `www.` domain forms automatically.

#### What about Shopify Plus stores with custom domains?

Yes, fully supported. The Actor reads the `myshopify_domain` from `meta.json` and surfaces it in the `store_meta` record, which is useful for cross-referencing custom-domain storefronts with their underlying Shopify Plus account.

#### Can I scrape a shopify scraper free of variants and images for a quick run?

Currently the Actor returns the full payload Shopify exposes per product. To trim variants/images post-fetch, use Apify's dataset transformation features or filter in your downstream pipeline. The pricing is per product row returned, so a 200-product catalog costs the same regardless of how much per-product detail you keep.

#### Can I run this on a schedule?

Yes, Apify has built-in scheduling. Most pricing-monitoring teams schedule a daily run at 03:00 local time and pipe the diff into Slack/email for next-morning review.

### Pricing

This Shopify scraper uses Apify's pay-per-event pricing with three events: a tiny per-run start fee, a per-store `store_detected` event (the BuiltWith-replacement charge), and a per-product event (the catalog-scrape charge). Your bill scales with what you actually consume, tech-detection-only runs cost cents per store, full-catalog runs scale with product count. See the Apify Store page for current per-event prices.

# Actor input Schema

## `domain` (type: `string`):

Shopify storefront domain (with or without https://). E.g. 'allbirds.com', 'www.allbirds.com'.

## `max_products` (type: `integer`):

Pagination cap (250 per page, up to 5000 total).

## `include_meta` (type: `boolean`):

Emit a leading record\_type='store\_meta' row with name/currency/country/myshopify\_domain/theme\_id/etc.

## Actor input object example

```json
{
  "domain": "allbirds.com",
  "max_products": 250,
  "include_meta": true
}
```

# Actor output Schema

## `results` (type: `string`):

First row is the store\_meta record; remaining rows are one product each.

## `output` (type: `string`):

OUTPUT record with the run's counts and status flags.

## `errors` (type: `string`):

Failures with a code and a redacted message. Absent when the run had none.

# 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 = {
    "domain": "allbirds.com",
    "max_products": 250,
    "include_meta": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/shopify-products").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 = {
    "domain": "allbirds.com",
    "max_products": 250,
    "include_meta": True,
}

# Run the Actor and wait for it to finish
run = client.actor("s-r/shopify-products").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 '{
  "domain": "allbirds.com",
  "max_products": 250,
  "include_meta": true
}' |
apify call s-r/shopify-products --silent --output-dataset

```

## MCP server setup

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

```

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/G1qTtF4zWy9Gsufu2/builds/AYh6Cvv5TDp3HkWKR/openapi.json