# Shopify Store Scraper - Products, Prices, Stock & Store Info (`scrapercompany/shopify-store-scraper`) Actor
Scrape any public Shopify store: full catalog, products on sale, new arrivals, best sellers or a collection (price, compare-at price, stock, variants, images), products by URL, store search, stock per variant, collections, store info, theme and apps. Batch many stores.
- **URL**: https://apify.com/scrapercompany/shopify-store-scraper.md
- **Developed by:** [ScraperCompany](https://apify.com/scrapercompany) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $5.00 / 1,000 product pages
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 Store Scraper - Products, Prices, Stock & Store Info
**Shopify Store Scraper** reads public Shopify storefronts. Give it a list of store domains and pick a mode: the **full product catalog**, **products on sale**, **new arrivals**, **best sellers** or one **collection**, each 50 products per page with **title, vendor, type, tags, price, compare-at price, discount, availability, low-stock flag, images, options and every variant**. Look up **products by handle or URL** (up to 50 per request), **search** a store, check **stock per variant**, list **collections**, or get **store info** (name, domains, location, currency, product and collection counts), a **store profile** (theme, detected apps, policies, menus, published emails, phones and social links), a cheap **Shopify check** for a list of domains, or **catalog stats** (vendors and price range). Pricing is pay-per-event: **$0.005 per page of 50 products**, **$0.003 per product looked up**; failed requests and empty pages are not charged.
Proxies, retries and anti-bot handling are built in, so you don't need your own proxies or an API key. Start a run, get structured JSON.
### What can this Shopify scraper do?
- **Catalog modes**: all products, on sale, new arrivals, best sellers or a collection, 50 products per page and up to 100 pages per store.
- Each product with **price and compare-at price** (amount, minor units, currency), **discount percent**, availability and **every variant** (SKU, price, stock flag, quantity where shown).
- **Products by handle or URL** for monitoring known items: up to 50 per request, charged only for products found.
- **Store search** and **stock per variant** for a product.
- **Store info, profile and check**: identity, currency, counts, theme, apps, policies, contacts and socials; the check tells Shopify stores from other sites at the lowest price.
- Batch many stores in one run; empty pages and not-found products are free.
#### Modes
| Mode | What it returns | Price per request |
| --- | --- | --- |
| `products` | Every product in the store catalog, 50 per page: title, vendor, type, price, compare-at price, stock, images, variants | $0.005 |
| `on-sale` | Products with a compare-at price above the price, with the discount percent | $0.005 |
| `new-arrivals` | Catalog products, newest first | $0.005 |
| `best-sellers` | Catalog products in the store's best-selling order | $0.005 |
| `collection` | Products in one collection, 50 per page | $0.005 |
| `product` | Full product details for handles or product URLs, up to 50 per request; charged per product found | $0.003 |
| `search` | Up to 10 products matching a search on each store | $0.003 |
| `inventory` | Availability, low-stock flag and per-variant stock (with quantity where the store shows it) | $0.003 |
| `collections` | Published collections: title, handle, product count, link | $0.006 |
| `store` | Store name, domains, country and city, currency, product and collection counts | $0.005 |
| `profile` | Theme, detected apps, policies, menus, published emails, phones and social links | $0.021 |
| `check` | Is the domain a Shopify store, reachable, with a public catalog or behind a password | $0.002 |
| `catalog-stats` | Products seen, vendors and lowest and highest price across 1-5 catalog pages of 250; charged per page scanned | $0.014 |
### Use cases for Shopify data
- **E-commerce brands**: Track competitors' prices, markdowns and new arrivals on their Shopify stores.
- **Resellers and deal sites**: Watch stock per size or color and catch products as they go on sale.
- **Agencies and app makers**: Profile Shopify stores by theme, installed apps, catalog size and published contacts for outreach.
- **Market researchers**: Compare assortments, vendors and price ranges across many stores.
### What Shopify data can you extract?
| Field | Description |
| --- | --- |
| `products[].title / handle / url / vendor / product_type / tags` | Product identity |
| `products[].price / compare_at_price` | Lowest and highest price and compare-at price (amount, amount_minor, currency) |
| `products[].on_sale / discount_percent` | Markdown flag and discount |
| `products[].available / low_stock` | Stock status |
| `products[].variants[]` | Variant id, title, SKU, price, compare-at price, available, quantity, options |
| `products[].images[] / options[]` | Image URLs with sizes; option names and values |
| `products[].published_at / created_at / updated_at` | Dates |
| `next_cursor` | Paging (followed automatically up to Pages per store) |
| `product.variants[] (Product stock)` | Per-variant SKU, availability, quantity and low-stock flag |
| `collections[] (Collections list)` | Title, handle, description, product count, link, image |
| `name / domain / myshopify_domain / country / currency / products_count (Store info)` | Store identity and counts |
| `theme / apps / policies / contacts / socials (Store profile)` | Theme, detected apps, policies and published contacts |
| `is_shopify / reachable / catalog_public / password_protected (Store check)` | Whether the domain is a public Shopify store |
| `products_seen / vendors / price_min_minor / price_max_minor (Catalog stats)` | Catalog size, vendors and price range |
Every dataset item also carries `input` (the exact request that was sent), `request_id` (quote it to support), `billed` and `scraped_at`.
### How to scrape Shopify stores
1. Open Shopify Store Scraper in Apify Console and go to the **Input** tab.
2. Enter one or more store domains and pick a **Mode**. For products by handle, stock, a collection or a search, also fill the matching list under **Mode options**; full product or collection URLs work too and are matched to their own store.
3. Adjust the options if needed. Dates accept an exact date (`2026-12-01`) or a relative one (`30 days` from today), so saved tasks and schedules never go stale.
4. Click **Start** and wait for the run to finish.
5. Download the results from the **Output** tab as JSON, CSV, Excel or HTML, or fetch them with the Apify API.
### Input example
This is the default input; running the Actor without changes uses it.
```json
{
"mode": "products",
"stores": [
"allbirds.com"
],
"maxPages": 1,
"handles": [
"mens-wool-cruiser"
],
"collections": [
"mens"
],
"queries": [
"socks"
],
"catalogPages": 1,
"includeErrors": true,
"maxConcurrency": 3,
"maxRetries": 2
}
```
### Output example
One dataset item per request (trimmed here; real items contain every field the API returns):
```json
{
"mode": "products",
"endpoint": "/v1/retail/shopify/products",
"input": {
"store": "allbirds.com",
"limit": 50
},
"currency": "USD",
"fetched_at": "2026-10-24T15:04:00Z",
"products": [
{
"available": false,
"body": "Light flip flops.",
"compare_at_price": {
"max": {
"amount": "50.00",
"amount_minor": 5000,
"currency": "USD"
},
"min": {
"amount": "50.00",
"amount_minor": 5000,
"currency": "USD"
}
},
"discount_percent": 50,
"handle": "womens-allbirds-flip-flop-dusty-pink",
"id": 7340901859408,
"images": [
{
"height": 4000,
"url": "https://cdn.shopify.com/s/files/1/1104/4168/files/flip.png",
"width": 4000
}
],
"low_stock": false,
"on_sale": true,
"options": [
{
"name": "Size"
}
],
"price": {
"max": {
"amount": "25.00",
"amount_minor": 2500,
"currency": "USD"
},
"min": {
"amount": "25.00",
"amount_minor": 2500,
"currency": "USD"
}
},
"product_type": "Shoes",
"published_at": "2026-09-25T16:58:13-07:00",
"selling_plans": [],
"tags": [
"allbirds::edition => limited"
],
"title": "Women's Allbirds Flip Flop - Dusty Pink",
"url": "https://www.allbirds.com/products/womens-allbirds-flip-flop-dusty-pink",
"variants": [
{
"available": false,
"grams": 455,
"id": 42146889039952,
"low_stock": false,
"option1": "5",
"quantity": 0,
"requires_shipping": true,
"sku": "A12513W050",
"title": "5"
}
],
"vendor": "Allbirds"
}
],
"request_id": "req_3f9c0d6e2b8a4c1f9e7d5b3a1c0e8f6d",
"store": "allbirds.com",
"billed": true,
"scraped_at": "2026-10-01T14:03:27.512Z"
}
```
A request that fails is saved with an `error` message instead (turn off **Include failed requests** to skip those). Failed requests are never charged.
### How much does it cost to scrape Shopify stores?
This Actor uses **pay-per-event** pricing: you pay for successful API requests, not for compute time.
| Event | Charged when | Price | Per 1,000 |
| --- | --- | --- | --- |
| `product-page` | One page of up to 50 products (catalog, on sale, new arrivals, best sellers or a collection). Empty pages are free. | $0.005 | $5.00 |
| `product` | One product found by handle or URL (full details with variants). Handles that are not found are free. | $0.003 | $3.00 |
| `search-request` | Products matching a search on one store. Searches with no results are free. | $0.003 | $3.00 |
| `inventory-request` | Stock status of one product and each of its variants. | $0.003 | $3.00 |
| `collections-page` | One page of up to 50 published collections. Empty pages are free. | $0.006 | $6.00 |
| `store-info` | A store's name, domains, location, currency and product and collection counts. | $0.005 | $5.00 |
| `store-profile` | A store's theme, detected apps, policies, menus and published contacts and social links. | $0.021 | $21.00 |
| `store-check` | Whether a domain is a reachable Shopify store with a public catalog. | $0.002 | $2.00 |
| `catalog-stats-page` | One catalog page (250 products) scanned for product counts, vendors and price range. A store with no products is free. | $0.014 | $14.00 |
For example, the first 1,000 products of a store (20 pages of 50) cost **$0.10**; checking 1,000 domains costs **$2.00**.
- Failed requests (errors, invalid input, blocked upstream after retries) are **free**.
- Requests where the source returns nothing at all (no results, nothing priced) are saved but **not charged**.
- Set **Maximum cost per run** when you start a run and the Actor stops cleanly before going over it.
### FAQ
#### Do I need proxies or an API key?
No. Proxy rotation, retries and anti-bot handling are built in, and the Actor is ready to run as is. You only pay the per-event prices above.
#### Which stores work?
Any Shopify store whose catalog is public, which is most of them. Password-protected stores and sites that are not on Shopify return an error and are not charged. Run the **Store check** mode first to filter a long list of domains cheaply.
#### How do I find product or collection handles?
The handle is the last part of a product or collection link: `mens-wool-cruiser` in `/products/mens-wool-cruiser`. You can paste the full links instead, and each is looked up on its own store. The **Collections list** mode lists every collection handle of a store.
#### Why are prices in the store's own currency?
Shopify publishes one currency per store (or per locale site). Each price carries its `currency`; use the **Locale** option for a store's other country sites when it has them.
#### How does On sale paging work?
It reads the catalog 50 products per page and keeps those marked down (compare-at price above the price), so a page can hold fewer than 50, and a page with none is free. Paging stops at the first page with no sale items. For stores whose first catalog pages are full price, use **All products** (every product has `on_sale` and `discount_percent`) or the store's sale collection with **Products in a collection**.
#### Are stock quantities exact?
Each variant has an `available` flag. A `quantity` is filled only when the store publishes it; many stores do not.
#### What does Store profile return?
The theme name, apps detected on the storefront, the store's policies and menus, and any emails, phones and social links the store publishes on its own pages. Fields stay empty when the store does not publish them, which is common on stores with a custom (headless) storefront; the profile is still charged.
#### Is it legal to scrape Shopify stores?
The Actor collects publicly available information that anyone can see without logging in. You are responsible for how you use the results: respect the source site's terms, copyright and privacy law (such as GDPR) and do not collect personal data without a lawful basis. If in doubt, ask a lawyer.
#### What happens when a request is blocked or rate-limited?
Rate limits (HTTP 429) and temporary errors (5xx) are retried automatically with exponential backoff, respecting `Retry-After`. If a request still fails it is saved with the error message and not charged, and the rest of the batch keeps going. A run only fails when every request failed.
#### Why did a request return an error?
Read the `error` field: validation problems (for example a malformed date or an unknown id) are reported exactly as the API sees them. Fix the input and run again; failed requests cost nothing.
#### How many requests can I run at once?
Any number per run. The Actor sends up to 3 requests in parallel by default (change it under **Run options**); larger batches simply take longer.
### Use it from your code
Call the Actor from any language through the [Apify API](https://docs.apify.com/api/v2). With the JavaScript client (`npm install apify-client`):
```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('scrapercompany/shopify-store-scraper').call({
"mode": "products",
"stores": [
"allbirds.com"
]
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```
With Python (`pip install apify-client`):
```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("scrapercompany/shopify-store-scraper").call(run_input={
"mode": "products",
"stores": ["allbirds.com"],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(item)
```
You can also schedule runs, chain them with webhooks, or connect them to Make, Zapier, n8n, Google Sheets and other integrations from the **Integrations** tab.
### Related scrapers
- [Amazon Scraper](https://apify.com/scrapercompany/amazon-scraper): the same products on Amazon
- [Walmart Scraper](https://apify.com/scrapercompany/walmart-scraper): products and reviews on walmart.com
- [Google Shopping Scraper](https://apify.com/scrapercompany/google-shopping-scraper): prices across merchants on Google Shopping
### Support
Questions, a field you need, or a site that stopped working? Open an issue on the **Issues** tab. Include the `request_id` from the dataset item so we can trace the request.
# Changelog
This Actor's version history is a separate document: https://apify.com/scrapercompany/shopify-store-scraper/changelog.md
# Actor input Schema
## `mode` (type: `string`):
What to collect from each store. Product lists come 50 per page; the other modes make one request per store (or per store and handle, collection or query).
## `stores` (type: `array`):
Shopify stores, one per line: a domain such as allbirds.com or an https URL. Every mode runs once per store.
## `maxPages` (type: `integer`):
Product and collection lists: how many pages of 50 to fetch per store (1-100). Each page is a separate request and is charged separately; paging stops at the last page. On sale stops at the first page of 50 catalog products with none on sale.
## `handles` (type: `array`):
For Products by handle or URL and Product stock: a product handle (the part after /products/, e.g. mens-wool-cruiser) is looked up on every store above; a full product URL such as https://www.allbirds.com/products/mens-wool-cruiser is looked up on its own store. Up to 50 handles go in one request.
## `collections` (type: `array`):
For Products in a collection: a collection handle (the part after /collections/, e.g. mens) is read on every store above; a collection URL such as https://www.allbirds.com/collections/mens on its own store. Use Collections list to find handles.
## `queries` (type: `array`):
For Search a store: one search per line, run on every store above. Each search returns up to 10 products.
## `catalogPages` (type: `integer`):
For Catalog stats: catalog pages of 250 products to scan per store (1-5). Each page scanned is one charged event.
## `locale` (type: `string`):
Optional locale path the store publishes, such as en or en-ca, for stores with several language or country sites. Leave empty for the main site.
## `customRequests` (type: `array`):
Optional list of JSON objects, one request each, using the API field names shown above. Each object is merged over the options above, so you only need to give what differs. Each object needs store, plus handles, handle, collection or q for those modes. Example: {"mode":"collection","store":"gymshark.com","collection":"mens"}
## `includeErrors` (type: `boolean`):
When on, a request that fails (for example an unknown property id) is saved as a dataset item with an error message so you can see what went wrong. Failed requests are never charged.
## `maxConcurrency` (type: `integer`):
How many API requests run at the same time (1-8). Parallel runs share one limit, so extra requests wait for a free slot instead of failing.
## `maxRetries` (type: `integer`):
Retries for rate limits (HTTP 429), temporary server errors (5xx) and network errors, with exponential backoff. Validation errors are never retried.
## Actor input object example
```json
{
"mode": "products",
"stores": [
"allbirds.com"
],
"maxPages": 1,
"handles": [
"mens-wool-cruiser"
],
"collections": [
"mens"
],
"queries": [
"socks"
],
"catalogPages": 1,
"includeErrors": true,
"maxConcurrency": 3,
"maxRetries": 2
}
```
# Actor output Schema
## `results` (type: `string`):
One dataset item per request.
## `summary` (type: `string`):
Counts of succeeded, failed, skipped and charged requests.
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"stores": [
"allbirds.com"
],
"handles": [
"mens-wool-cruiser"
],
"collections": [
"mens"
],
"queries": [
"socks"
]
};
// Run the Actor and wait for it to finish
const run = await client.actor("scrapercompany/shopify-store-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"stores": ["allbirds.com"],
"handles": ["mens-wool-cruiser"],
"collections": ["mens"],
"queries": ["socks"],
}
# Run the Actor and wait for it to finish
run = client.actor("scrapercompany/shopify-store-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 '{
"stores": [
"allbirds.com"
],
"handles": [
"mens-wool-cruiser"
],
"collections": [
"mens"
],
"queries": [
"socks"
]
}' |
apify call scrapercompany/shopify-store-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapercompany/shopify-store-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 ` 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/jAFRoJ5E98oM3P4qC/builds/VpKVlZS9Gsx72OmH8/openapi.json