# 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:** 3 total users, 2 monthly users, 57.7% 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# 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(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 '{
  "store_url": "https://allbirds.com",
  "collection": ""
}' |
apify call ef12/shopify-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ef12/shopify-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/SrULc4gTcrGGQhKeq/builds/TecQfAbNeqYaUZySb/openapi.json