# Shopify Product Scraper (`ef12/shopify-scraper`) Actor

Scrape product listings from any Shopify store. Get titles, prices, availability, images, and tags via the Shopify JSON API.

- **URL**: https://apify.com/ef12/shopify-scraper.md
- **Developed by:** [Daniel Wilson](https://apify.com/ef12) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 17.4% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 per results

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/platform/actors/running/actors-in-store#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

### What does Shopify Product Scraper do?

**Shopify Product Scraper** extracts product listings from any Shopify-powered store. It fetches titles, prices, availability, vendor info, images, and tags directly from the store's **JSON API** — no HTML scraping required. Just provide a store URL and get structured data in seconds.

Run it on [Apify](https://apify.com) to get API access, scheduling, automatic proxy rotation, monitoring, and data export in JSON, CSV, HTML, or Excel.

### Why use Shopify Product Scraper?

- **Extract product catalogs** — Download complete product listings from any Shopify store for market research, price monitoring, or inventory analysis.
- **No scraping infrastructure** — The Shopify JSON API returns clean, structured data. No need to parse HTML or handle dynamic content.
- **Collection scoping** — Target specific collections (e.g., "mens-shoes", "sale") to narrow results.
- **Pay per result** — 10 free results per run, then $0.02 per additional result. Only pay for what you use.

### Use Cases

#### How to scrape product listings from any Shopify store

Enter the store URL (e.g., `https://allbirds.com`) and the scraper fetches products via the public `/products.json` API. No authentication needed — every Shopify store exposes this endpoint.

#### How to monitor competitor prices on Shopify

Schedule weekly runs of competitors stores. Compare the `price` and `compare_at_price` fields across runs to detect price changes, sales, and new product launches.

#### How to build a product catalog from multiple Shopify stores

Run the scraper against multiple store URLs and aggregate results. Filter by `product_type` or `tags` to categorize products. Export to CSV for import into your database.

#### How to track product availability on Shopify

The `available` boolean field tells you if a product is in stock. Schedule daily runs and track when products go in and out of stock.

### How to use Shopify Product Scraper

1. **Enter the store URL** — Provide the Shopify store's base URL, e.g. `https://allbirds.com`.
2. **(Optional) Enter a collection handle** — If you want products from a specific collection, add the handle (the URL slug from `/collections/{handle}`).
3. **Set the max results** — Choose how many products to scrape (up to 500).
4. **Run the Actor** — Click "Run" and wait for results to appear in the dataset.

The Actor fetches products via the store's public `/products.json` API endpoint, paginates through results, and pushes each product to the output dataset.

### Input

| Field | Type | Required | Description |
| ------- | ------ | ---------- | ------------- |
| `store_url` | string | Yes | Shopify store URL (e.g. `https://allbirds.com`) |
| `collection` | string | No | Collection handle for a subset of products |
| `max_results` | integer | No | Max products to return (default: 50, max: 500) |

Example input:

```json
{
    "store_url": "https://allbirds.com",
    "collection": "mens-shoes",
    "max_results": 100
}
```

### Output

Each result is a JSON object with these fields:

| Field | Type | Description |
| ------- | ------ | ------------- |
| `title` | string | Product title |
| `handle` | string | Product URL slug |
| `url` | string | Full product page URL |
| `price` | string | Formatted price (e.g. `$95.00`) |
| `compare_at_price` | string or null | Original price (if on sale) |
| `available` | boolean | Whether the product is in stock |
| `vendor` | string | Brand or vendor name |
| `product_type` | string | Product category |
| `image_url` | string or null | Main product image URL |
| `tags` | array of strings | Product tags |

Example output:

```json
{
    "title": "Wool Runner",
    "handle": "wool-runner",
    "url": "https://allbirds.com/products/wool-runner",
    "price": "$95.00",
    "compare_at_price": null,
    "available": true,
    "vendor": "Allbirds",
    "product_type": "Shoes",
    "image_url": "https://cdn.shopify.com/.../image.jpg",
    "tags": ["wool", "sneakers", "sustainable"]
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel from the Apify Console.

n**Cost example:** 50 products = 40 paid × $0.02 = **$0.80 per run**. First 10 results are free.

### Pricing / Cost estimation

The first 10 results of each run are **free**. After that, each additional result costs **$0.02** (2 cents) through Apify's pay-per-event (PPE) billing.

For a typical run of 100 products: 90 chargeable results × $0.02 = **$1.80**.
For 500 products: 490 chargeable results × $0.02 = **$9.80**.

These costs are estimates — actual Apify platform fees may apply. Check the [Apify pricing page](https://apify.com/pricing) for details.

### Tips

- **Collection handles** are the URL slugs from `/collections/{handle}` — navigate to a collection page on the store and copy the last segment of the URL.
- **Max results** caps at 500. If you need more, run the Actor multiple times with different collection handles or contact us for a custom solution.
- **Rate limits** — Shopify stores may rate-limit public API access. The Actor uses sensible timeouts, but for large-scale scraping consider using Apify proxy.

### FAQ, disclaimers, and support

**Is this legal?** Scraping publicly available data from e-commerce stores generally falls under legitimate data collection. However, always review the target website's Terms of Service and `robots.txt`. The Actor uses the public JSON API — it does not bypass authentication or access private data.

**Known limitations:** The Shopify public products API returns at most 250 products per page and may not include all product variants. For variant-level detail, you would need to scrape individual product pages.

**Need help or a custom solution?** Open an issue on the [GitHub Issues](https://github.com/apify/fleet/issues) tab or contact us for tailored scraping solutions.

# Actor input Schema

## `store_url` (type: `string`):

Shopify store URL (e.g. https://allbirds.com)

## `collection` (type: `string`):

Optional collection handle (e.g. mens-shoes). Leave empty to scrape all products.

## `max_results` (type: `integer`):

Maximum number of products to scrape (max 500)

## Actor input object example

```json
{
  "store_url": "https://allbirds.com",
  "max_results": 50
}
```

# Actor output Schema

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

No description

# 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 = {
    "store_url": "https://allbirds.com",
    "collection": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("ef12/shopify-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 = {
    "store_url": "https://allbirds.com",
    "collection": "",
}

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

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

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

```

## CLI example

```bash
echo '{
  "store_url": "https://allbirds.com",
  "collection": ""
}' |
apify call ef12/shopify-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ef12/shopify-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/SrULc4gTcrGGQhKeq/builds/TecQfAbNeqYaUZySb/openapi.json