# Shopify Products Scraper: $0.016 per 1,000 Products (`zaiq/shopify-products-scraper`) Actor

Export public Shopify products with prices, variants, SKUs, availability, images and collection evidence. Read stores, collections or product links and compare complete snapshots for price and stock changes. No login or Admin API key. $0.016 per 1,000 products.

- **URL**: https://apify.com/zaiq/shopify-products-scraper.md
- **Developed by:** [Zaiq](https://apify.com/zaiq) (community)
- **Categories:** E-commerce, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / 1,000 products

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 Products Scraper: Prices, Variants & Stock Status

Export public Shopify products with every listed variant, price, compare-at price, SKU and buyable status. Supply a store domain, a collection link or an individual product link. The output is one product per row, with a plain verdict first.

**$0.000016 per product + $0.00002 per non-empty page that delivers a new product.** Ten products from one page cost **$0.00023 including Apify’s $0.00005 start charge**. Store summaries and failure notes have no product or page fee. The same price on every Apify plan.

Smallest input: `{"urls":["https://shop.example.org"]}` — replace the example address with the store you want. The prefilled form reads 10 real products from a public store. No account or Admin API key is needed.

### What you get

| Field | What it holds |
|---|---|
| Product and verdict | Stable product identity, title, URL, vendor, product type, tags, created/published/updated dates and a one-line availability/price verdict. |
| Prices and evidence | Lowest and highest variant price, compare-at prices, currency and evidence URLs. Unknown currency stays null. |
| All listed variants | Each variant’s ID, title, SKU, price, compare-at price, buyable status, option values and weight in grams when published. No exact inventory quantities. |
| Images and text | Image URLs and optional cleaned source description; images are not downloaded. |
| Collections | Membership evidenced by the collection inputs supplied in this run. Overlapping inputs combine their collection handles into one product row. |
| Monitoring | Optional comparison of two complete, matching scopes: added products, changed prices/stock/variants, unchanged products and free removal notes. |
| Free store summary | Observed products, published store count where available, pages read, currency and whether coverage is complete. |
| SUMMARY | Coverage, skipped inputs, source failures, malformed records, spending/output limits, delivered rows and charged events. |
| Source page | sourceUrl links to the response; catalogPageId groups products delivered from the same billed page. |

### What people use it for

- **Catalogue exports:** Import public product and variant data into a spreadsheet or internal catalogue.
- **Price monitoring:** Schedule the same complete scope with a snapshot key to see price and compare-at changes.
- **Availability monitoring:** Track whether listed variants are buyable; unavailable does not establish an exact stock quantity.
- **Collection comparisons:** Read selected collections together and deduplicate products while retaining collection evidence.

### How to use it

1. Add up to 20 store, collection or product URLs. Bare store domains also work.
2. Set Maximum products and both spending limits. The default returns 10 products; larger catalogues require a higher product limit and budget.
3. Start the Actor and open Products and coverage. Filter recordType to product for exports.
4. For monitoring, set snapshotKey and allow the entire requested scope to finish. Reuse the same URLs and snapshot key on later runs.

### Input

| Field | Example | Notes |
|---|---|---|
| urls | \["https://shop.example.org"] | Store roots, /collections/example-collection, /products/example-product, or product feed URLs; at most 20 inputs. |
| maxResults | 10 | 1–10,000 unique products across the run; variants do not consume extra products. |
| includeDescription | true | Include cleaned source text. Set false for smaller exports. |
| snapshotKey | catalogue-monitor | Optional private comparison namespace. Both runs must finish the same scope with confirmed currencies. |
| maxChargeUsd | 0.02 | Application spending cap, including the start charge. The lower of this and Apify Maximum cost per run applies. |
| Aliases | url, domains, startUrls, store, stores, productUrls | URL lists or a single URL. query, queries and keywords are also accepted when their values are URLs; keyword search is not provided. |

### Output

Each result is one row in the run's dataset (download it as JSON, CSV, Excel, XML or HTML, or read it through the API). An example row (values shortened):

```json
{
  "verdict": "Available to buy; from 129 USD; 1 variant.",
  "recordType": "product",
  "resultId": "product-example",
  "store": "shop.example.org",
  "productId": "8677428199574",
  "title": "Example desk organizer",
  "url": "https://shop.example.org/products/example-desk-organizer",
  "vendor": "Example Maker",
  "productType": null,
  "priceMin": 129.0,
  "priceMax": 129.0,
  "currency": "USD",
  "available": true,
  "variantCount": 1,
  "variants": [
    {
      "id": "46495421268118",
      "title": "Default Title",
      "sku": null,
      "price": 129.0,
      "compareAtPrice": null,
      "available": true,
      "options": [
        "Default Title"
      ],
      "grams": null
    }
  ],
  "createdAt": "2026-07-20T16:56:25-04:00",
  "publishedAt": "2026-10-07T11:16:05-04:00",
  "updatedAt": "2026-10-25T13:32:52-04:00",
  "collections": [],
  "collectionMembershipComplete": false,
  "changes": {
    "state": "disabled",
    "fields": []
  },
  "snapshotComplete": true,
  "status": "ok",
  "sourceUrl": "https://shop.example.org/products/example-desk-organizer.js",
  "observedAt": "2026-10-25T17:32:50Z"
}
```

This example comes from a real signed-out product run on 25 October 2026. Names, handles and site addresses have been replaced; the source description and images are omitted. The price, availability, variant count and timestamps are the returned values. SUMMARY in the run’s key-value store records coverage, limits and charged events.

### Pricing

- **Product: $0.000016** per unique delivered product, including every listed variant.
- **Catalog page: $0.00002** per successfully parsed response that delivers at least one new product, up to 250 products per feed page. An individual product lookup also counts as one page; its currency-check response adds no fee.
- Empty, duplicate-only, blocked and failed responses have no product or page fee. Store summaries, input notes and removal notes are free.
- Apify’s **$0.00005 start charge counts towards Maximum cost per run** and the application cap.
- The same price on every Apify plan. There is no AI charge, variant charge, login requirement or API key to supply.
- Launch price. It may rise later; Apify emails every user 14 days before any price increase takes effect, and a rise can happen at most once a month.

What typical jobs cost at the list price:

| Job | Cost |
|---|---|
| 1 product from 1 page, including start | $0.000037 |
| 10 products from 1 page, including start | $0.00023 |
| 1,000 products from 4 pages, including start | $0.01608 |
| 10,000 products from 40 pages, including start | $0.1608 |

The budget must cover a new page and at least one product before the Actor requests that page. With the start charge, a $0.000232 cap cannot buy a product; $0.000037 can buy one, and $0.00023 can buy ten from one page. Set both limits high enough for a complete monitoring run. Page counts can be higher across multiple stores or sparse collections.

### Tips

- For a complete catalogue, increase maxResults and maxChargeUsd together. Check snapshotComplete and the free store-summary rows before treating an export as exhaustive.
- Use a collection URL to narrow the catalogue. Product URLs return all listed variants, including sold-out options where the public response includes them.
- Use the same snapshot key and URLs on a schedule. A capped, blocked or malformed run preserves the previous complete baseline and does not report removals.
- Export JSON to retain nested variants, options and changes. CSV keeps one product per row.

### Use it through the API

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("zaiq/shopify-products-scraper").call(run_input={"urls": ["https://shop.example.org"], "maxResults": 10, "maxChargeUsd": 0.02})
for row in client.dataset(run.default_dataset_id).iterate_items():
    print(row)
```

**JavaScript**

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('zaiq/shopify-products-scraper').call({"urls": ["https://shop.example.org"], "maxResults": 10, "maxChargeUsd": 0.02});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**HTTP (one call, results back)**

```bash
curl -X POST 'https://api.apify.com/v2/acts/zaiq~shopify-products-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>' \
  -H 'Content-Type: application/json' \
  -d '{"urls": ["https://shop.example.org"], "maxResults": 10, "maxChargeUsd": 0.02}'
```

### Integrations and schedules

- **Schedules:** run it every hour, day or week from the Apify Console (Schedules) and keep a history of results.
- **Make, Zapier, n8n, Google Sheets, Slack, Airtable:** connect it through Apify's integrations, or send each finished run to a **webhook**.
- **Datasets:** results stay in the run's dataset; export them or read them by API whenever you need them.

### Use it with AI agents (MCP)

Add Apify's MCP server with this Actor already pinned (`https://mcp.apify.com?tools=zaiq/shopify-products-scraper`) to Claude, ChatGPT, Cursor, VS Code or any MCP client. The agent can find this Actor and run it for you: ask it for "export this public store’s products with variants, prices and availability". AI agents can also pay for runs directly through Apify's agentic payments.

### Limits

- Reads public Shopify JSON endpoints. A password wall, bot check, robots restriction or disabled feed produces a free note; no login or challenge solving is used.
- Up to 10,000 unique products per run and 20 inputs. The source-request ceiling is 150 requests per store host; a response may contain up to 24 MB of decoded data. Hitting a limit marks coverage incomplete. A product larger than the 8 MB dataset-row limit is skipped with a note in SUMMARY; its variants are never silently truncated.
- Availability means the variant can be bought according to the public feed. Exact inventory, sales, checkout, private Admin API data and unpublished products are not available.
- Collection membership covers only the collection scopes supplied. The Actor does not enumerate every collection a store has.
- Store feeds use their published base-currency evidence. Individual product amounts are divided by 100 and checked against public product JSON when available. Unverified or locale-specific currency stays null.
- A catalogue can change while it is being read. Repeated pages, conflicting products, malformed records or a known count mismatch disable complete-snapshot comparison. These endpoints do not provide an atomic database snapshot.
- Snapshot changes are compared only after two complete runs with the same scope and confirmed currency. A removal means absent from that scope, not necessarily deleted from the entire store. Avoid overlapping scheduled runs using the same snapshot key.
- The Actor follows redirects within the store domain and its www alias. Supply a destination store explicitly if a shop has moved to another domain.

### FAQ

**Does one variant cost one product?**

No. One product includes all variants returned by the source.

**Does it get the whole catalogue?**

It pages through the requested public scope until the source ends or an output, budget or source limit is reached. Check the free coverage summary. The run supports up to 10,000 products.

**Why is currency null?**

The source did not establish the currency for these amounts. The Actor does not assume that a dollar sign means USD.

**Why is a collection empty?**

The public endpoint returned no products. The collection may be empty, unavailable or hidden; no product or page fee is charged.

**Are monitoring runs charged only for changed products?**

No. Each delivered current product is charged because it was checked. Comparison and removal notes add no fee.

**Where is the monitoring baseline stored?**

In a private named key-value store associated with your account and snapshot key. A partial run leaves the previous complete baseline in place.

**What happens after a restart?**

The Actor uses stored input/source data and existing result IDs to resume delivery, and reconciles the delivered products and pages against the run’s charged-event totals.

### Related Actors from Zaiq

- [amazon-product-scraper](https://apify.com/zaiq/amazon-product-scraper): Amazon product exports
- [walmart-scraper](https://apify.com/zaiq/walmart-scraper): Walmart product data

### Support

Questions, a site that changed, or a field you need? Open an issue on this Actor's **Issues** tab: we answer there, usually within a day.

***

Also found as: shopify products scraper, shopify catalogue export, shopify variants, shopify price monitoring, shopify stock status, shopify collection scraper.

# Actor input Schema

## `urls` (type: `array`):

Up to 20 public store domains, collection links, product links or feed URLs. Empty input uses the working sample.

## `maxResults` (type: `integer`):

Maximum unique products across all inputs, including every listed variant. Increase the spending limit for full catalogues.

## `includeDescription` (type: `boolean`):

Include cleaned source text. No generated text is added.

## `snapshotKey` (type: `string`):

Optional private monitoring namespace. Reuse this value and exactly the same scope. Only complete, currency-confirmed snapshots are compared; capped or failed runs preserve the baseline.

## `maxChargeUsd` (type: `number`):

Application cap, including any platform startup charge. The lower of this and Apify Maximum cost per run applies. One product plus its page is $0.000232; with the $0.00005 start charge it is $0.000037.

## Actor input object example

```json
{
  "urls": [
    "https://www.deathwishcoffee.com"
  ],
  "maxResults": 10,
  "includeDescription": true,
  "snapshotKey": "",
  "maxChargeUsd": 0.02
}
```

# Actor output Schema

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

Dataset: the results.

## `summary` (type: `string`):

What each input returned, and notes.

# 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 = {
    "urls": [
        "https://www.deathwishcoffee.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zaiq/shopify-products-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 = { "urls": ["https://www.deathwishcoffee.com"] }

# Run the Actor and wait for it to finish
run = client.actor("zaiq/shopify-products-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 '{
  "urls": [
    "https://www.deathwishcoffee.com"
  ]
}' |
apify call zaiq/shopify-products-scraper --silent --output-dataset

```

## MCP server setup

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