# Shopify Products Scraper (`parseforge/shopify-stores-scraper`) Actor

Scrapes product data from any public Shopify storefront. Feed it store, collection, or product URLs and get back a flat row per product with all variants, pricing, images, and stock status.

- **URL**: https://apify.com/parseforge/shopify-stores-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 11 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $11.99 / 1,000 result items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Shopify Products Scraper

**Scrape product catalogs from any Shopify store, collection, or product URL, up to a million items per run.** Each product row includes its title, price, variants, images, and stock status. No API key or store admin access needed. Export to CSV, JSON, Excel, or XML.

Shopify's storefront API is rate-limited and often requires store owner approval. This actor reads the public product feeds directly from any Shopify-powered store, collection page, or individual product URL. You get a complete, structured catalog in one fixed schema, ready for analysis.

| Who uses it | What they scrape Shopify for |
|---|---|
| E-commerce analysts | Benchmark a competitor's full product catalog and pricing strategy. |
| Dropshippers | Find trending products and monitor supplier stock levels across multiple stores. |
| Brand managers | Monitor how your products are listed and priced by authorized retailers. |
| Market researchers | Track product assortment changes and new arrivals in a specific niche. |

### What it does

This Actor collects product data from Shopify storefronts by homepage, collection, or product URL and returns each product as a flat row with its variants, pricing, and images.

- 🔍 **Keyword search:** Filter products by a keyword within a store's catalog to target specific items.
- 📦 **Stock filtering:** Exclude out-of-stock items to see only products with at least one available variant.
- 🔗 **Flexible start URLs:** Feed it store homepages, collection pages, or individual product URLs, alone or mixed together.
- 🔄 **Product recommendations:** Optionally fetch up to 10 recommended products for each scraped item.
- 📊 **Sorted output:** Order results by price, title, or recency before they hit your dataset.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with Shopify data

**📈 Monitor competitor pricing.**

An e-commerce analyst scrapes a competitor's entire catalog weekly, sorts by price descending, and flags products where the competitor undercuts their own pricing.

**🛍️ Build a dropshipping product feed.**

A dropshipper scrapes multiple niche Shopify stores, filters out out-of-stock items, and exports the results to CSV for import into their own store backend.

**🔎 Audit retail partner listings.**

A brand manager scrapes authorized dealer storefronts to verify that product titles, images, and MSRPs match the brand's guidelines.

**📊 Track product assortment trends.**

A market researcher scrapes a set of fashion stores monthly, sorting by newest first, to identify which styles and categories are being added for the upcoming season.

### Why choose this scraper

|  | What you get |
|---|---|
| **No API keys** | Scrape any public Shopify store without registration, tokens, or store admin approval. |
| **Complete product data** | Get title, description, price, compare-at price, variants, images, SKU, vendor, and stock status. |
| **Handles large catalogs** | Collect up to a million products per run, respecting the store's own pagination limits. |

### How it compares

No other Store actor targets Shopify the same way, so the honest comparison is with the alternatives teams actually weigh.

| | Shopify Products Scraper | Build it in-house | By hand |
|---|---|---|---|
| Setup | Run it now, zero config | Days of engineering | None, but hours per pull |
| When Shopify changes | Maintained for you | You fix it | You re-learn the page |
| Proxies, retries, anti-bot | Built in | Your problem | Browser only |
| Output | Fixed JSON schema, CSV/Excel export | Whatever you build | Copy-paste |
| Cost | Pay per result | Engineering time | Analyst hours |

### Configure the run

Drive the Actor from store homepages, collection pages, and product URLs, alone or together, and filters run as each product is read so only matches reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "startUrls": [
    {
      "url": "https://allbirds.com/"
    }
  ],
  "maxItems": 10
}
```

A larger pull:

```json
{
  "startUrls": [
    {
      "url": "https://allbirds.com/"
    }
  ],
  "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.01599 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $1.60 |
| 1,000 results | $15.99 |
| 10,000 results | $159.90 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Shopify Products Scraper](https://apify.com/parseforge/shopify-stores-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Shopify through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/shopify-stores-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check that the store URL is correct and the store is publicly accessible. If you are using a keyword search, try a broader term or leave it empty to see all products. Also verify that 'Include Out of Stock' is checked if the store has no available inventory.

**The actor is only returning a few products from a large store.**

Some Shopify stores limit the number of products shown on their public pages. Try using collection page URLs instead of the homepage to access deeper parts of the catalog. The actor respects the store's own pagination limits.

**Why are product images missing?**

The actor captures the image URLs as provided by the store's theme. If images are lazy-loaded or hosted on a CDN that blocks automated requests, they may not be captured. The main image and all image URLs are included when available.

**The keyword search is not finding products I know exist.**

The keyword search uses the store's own search endpoint. Try variations of the keyword, check for spelling, and ensure the store's search function works in a regular browser. The search only applies to store homepages, not collection or product URLs.

**I am getting a timeout or the run is very slow.**

Large catalogs take time. Increase the run's timeout in the actor settings. If scraping many stores, reduce the 'Maximum stores' count or split the URLs across multiple runs.

### FAQ

| Question | Answer |
|---|---|
| Can I scrape any Shopify store? | Yes, any store hosted on Shopify with a public storefront can be scraped. You do not need the store owner's permission or an API key. |
| What data do I get for each product? | Each row includes the product title, description, vendor, product type, tags, all variant details (SKU, price, compare-at price, stock status, option values), the main image URL, and all other image URLs. |
| How do I scrape only products that are in stock? | Uncheck the 'Include Out of Stock' option in the input. The actor will then return only products that have at least one variant with available inventory. |
| Can I search for a specific product across a store? | Yes, use the 'Store or product keyword' field. This searches the store's product listings and returns only matching items. It works on store homepages, not on collection or product URLs. |
| How do I scrape multiple stores at once? | Add multiple store URLs to the 'Shopify store URLs' input field. The actor will process them sequentially up to the 'Maximum stores' limit you set. |
| What is the maximum number of products I can scrape? | You can set the 'Maximum stores' input up to 1,000,000. The actual number of products depends on the store's catalog size and its pagination limits. |
| Can I get product recommendations? | Yes, set the 'Recommendations Per Product' field to a number between 1 and 10. The actor will fetch the store's own recommended products for each scraped item. |
| How do I sort the results? | Use the 'Sort By' dropdown to order the output by price, title, or date added before the data is saved to your dataset. |
| Does this work with Shopify Plus stores? | Yes, Shopify Plus stores use the same public storefront structure. The actor scrapes them the same way as any other Shopify store. |
| What format is the export? | You can export your results in CSV, JSON, Excel, or XML formats from the dataset tab after the run completes. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Shopify Inc. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `startUrls` (type: `array`):

Shopify store, collection, or product URLs. Supports store homepages (all products), collection pages, and individual product pages.

## `maxItems` (type: `integer`):

Maximum number of stores to collect per run.

## `query` (type: `string`):

Search products by keyword within store URLs. Only applies to store homepages, not collection or product URLs. Leave empty to get all products.

## `includeOutOfStock` (type: `boolean`):

If unchecked, only products with at least one available variant are returned.

## `sortBy` (type: `string`):

Sort the output results. Default order is as returned by the store.

## `maxRecommendationsPerProduct` (type: `integer`):

Fetch recommended products for each scraped product. Set to 0 to disable.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://allbirds.com/"
    }
  ],
  "maxItems": 10,
  "includeOutOfStock": true,
  "sortBy": "",
  "maxRecommendationsPerProduct": 0
}
```

# Actor output Schema

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

Dataset with all scraped items

# 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 = {
    "startUrls": [
        {
            "url": "https://allbirds.com/"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/shopify-stores-scraper").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 = {
    "startUrls": [{ "url": "https://allbirds.com/" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/shopify-stores-scraper").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 '{
  "startUrls": [
    {
      "url": "https://allbirds.com/"
    }
  ],
  "maxItems": 10
}' |
apify call parseforge/shopify-stores-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/85xHWKbuNGNrb4N9A/builds/5NGYs6HcFjmIPmiKi/openapi.json