# Shopify Store Products: Prices, Variants and Stock (`tan-solutions/shopify-products`) Actor

Get every product of the Shopify stores you name: prices, compare-at prices, variants, SKUs, stock, tags and images from the public catalogue. Pay per product, all variants included; failed stores are free. Obeys robots.txt, 1 request per second per store.

- **URL**: https://apify.com/tan-solutions/shopify-products.md
- **Developed by:** [Tan Solutions](https://apify.com/tan-solutions) (community)
- **Categories:** E-commerce, Lead generation, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 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.
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?

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 Products: Prices, Variants and Stock

Get the full public product catalogue of the Shopify stores you name: titles, prices and compare-at prices, variants
and SKUs, stock flags, vendors, product types, tags, options and images. One clean row per product (or per variant),
ready for price monitoring, competitor research, catalogue imports and AI agents.

### Quick API and schedule example

Run it from code, then put the same call on a schedule (Apify Console > Schedules) for daily price monitoring:

```bash
curl -X POST "https://api.apify.com/v2/acts/tan-solutions~shopify-products/run-sync-get-dataset-items?token=$APIFY_TOKEN"   -H "Content-Type: application/json"   -d '{"startUrls": ["allbirds.com"], "outputMode": "product", "maxProductsPerStore": 100}'
```

### What it does

- Reads each store's public catalogue (`/products.json`, the feed Shopify publishes for every store), page by page,
  1 request at a time per store and 1 second apart.
- Give it store home pages or bare domains for all products, or collection pages (`/collections/<handle>`) for one
  collection. Several collections of one store are read once and de-duplicated.
- Rows are typed and the same for every store: prices as numbers, min/max over all variants, `available` = at least
  one variant in stock.
- A store or URL that cannot be read gets one free `store` row that says why (`not_shopify`, `password_protected`,
  `collection_not_found`, `robots_disallowed`, `blocked`, `rate_limited`, `error`, `invalid_input`), with the number
  of products delivered before it stopped. The run's status message sums it up.

### Who it is for

- E-commerce teams and brands that watch competitors' prices, discounts and stock.
- Agencies, analysts and lead-generation teams that need the full catalogue of a list of stores.
- Developers and AI agents that want clean, typed product data from one API call.

### Quick start

1. Add stores in **Stores or collections**, one per line: `allbirds.com`, `https://kith.com` or a collection page
   like `https://store.com/collections/sale`.
2. Click **Start**. A store with a few hundred products takes under a minute.
3. Open the **Output** tab: one row per product. Download it as JSON, CSV or Excel, or read it through the API.

Left empty, the Actor reads beardbrand.com as a quick demo.

### Input

| Field (Console name) | What it does | Default |
| --- | --- | --- |
| `startUrls` (Stores or collections) | Store home pages, domains or collection URLs (at most 25 different stores) | beardbrand.com (example) |
| `outputMode` (One row per) | `product` (variants inside each row) or `variant` (one row per variant) | `product` |
| `includeImages` (Include all images) | Add the list of every image URL; off keeps only the main image | off |
| `maxProductsPerStore` (Max products per store) | Products read per store, 1 to 25,000 | 5,000 |
| `maxItems` (Max rows per run) | Rows per run across all stores (in variant mode a row is a variant) | 100,000 |
| `maxConcurrency` (Stores in parallel) | Stores read at once, 1 to 5 (each store still gets 1 request per second) | 3 |
| `timeoutSecs` (Request timeout) | Per request, 5 to 120 | 30 |
| `monitorId` (Monitor ID) | Turns on price and stock change tracking: use the same ID on every run | empty (off) |
| `onlyChanges` (Only changed products) | With a Monitor ID: list only new, changed and removed products | on |

```json
{
  "startUrls": ["allbirds.com", "https://kith.com/collections/footwear"],
  "outputMode": "product",
  "maxProductsPerStore": 1000
}
```

#### Track price and stock changes

Give a Monitor ID (for example `my-shops`) and run the Actor on a schedule with the same ID. Each row then gets
`change` (`new`, `price_up`, `price_down`, `availability` or `removed`), `previousPrice` and `previousAvailable`
(`true` or `false`, like `available`), compared with the last finished run of that ID. The first run lists every product as
`new`. With "Only changed products" on (the default), unchanged products are left out and cost nothing; turn it off
to get every product with `change: "unchanged"` as well. A product counts as `removed` only when its store or
collection was read to the end; a run cut short by your limits or a store error never reports removals. Product
mode compares the lowest price of each product; variant mode compares each variant. Keep one output mode per
Monitor ID. Without a Monitor ID the rows are exactly as described below, with no change fields.

### Output example

One dataset item per product (or variant), plus one `store` row per stopped store. Views: Overview, Variants,
Stores (stopped or skipped). A real row from a test run on deathwishcoffee.com (13 Nov 2026), trimmed to 2 of its 5
variants and 3 SKUs:

```json
{
  "recordType": "product", "status": "ok",
  "storeUrl": "https://deathwishcoffee.com", "storeDomain": "deathwishcoffee.com", "collection": null,
  "productId": 7347711901751,
  "productUrl": "https://deathwishcoffee.com/products/daily-grind-womens-corduroy-workwear-jacket",
  "title": "Daily Grind Women's Corduroy Workwear Jacket", "handle": "daily-grind-womens-corduroy-workwear-jacket",
  "vendor": "Sportiqe", "productType": "Apparel", "tags": ["Apparel", "Men", "Merch", "Sale"],
  "options": [{ "name": "Size", "values": ["S", "M", "L", "XL", "2XL"] }], "available": true,
  "priceMin": 65, "priceMax": 65, "compareAtPriceMin": 90, "compareAtPriceMax": 90, "variantCount": 5,
  "variants": [
    { "variantId": 41900193808439, "title": "S", "sku": "UJKINS02", "price": 65, "compareAtPrice": 90, "available": true, "selectedOptions": { "Size": "S" } },
    { "variantId": 41900193841207, "title": "M", "sku": "UJKINS03", "price": 65, "compareAtPrice": 90, "available": true, "selectedOptions": { "Size": "M" } }
  ],
  "skus": ["UJKINS02", "UJKINS03", "UJKINS04"],
  "imageUrl": "https://cdn.shopify.com/s/files/1/0271/7209/files/DeathWishCoffee_October2025_Product_WomensJacket_Front_Web.jpg?v=1761234563",
  "images": null,
  "createdAt": "2025-09-29T11:53:46-04:00", "updatedAt": "2026-11-13T10:27:49-05:00", "publishedAt": "2026-08-31T15:18:53-04:00",
  "error": null, "scrapedAt": "2026-11-13T15:27:50.148Z"
}
```

In `variant` mode each row carries `variantId`, `variantTitle`, `sku`, `price`, `compareAtPrice`, `variantAvailable`,
`selectedOptions`, `grams` and `requiresShipping` with the product fields repeated. Store rows carry
`productsDelivered` and `error` with a code and a plain message.

### Pricing

You pay per product delivered (the `product` event), with all its variants included. In variant mode a product is
charged once, on its first variant row; its other variant rows are free. A product that shows up twice in one run
(for example in two collections of the same store) is charged once. With a Monitor ID, each new, changed or removed
product is charged the same way; unchanged products left out by "Only changed products" are free.

| Apify plan | Price per 1,000 products |
| --- | --- |
| Free | $0.80 |
| Bronze | $0.70 |
| Silver | $0.60 |
| Gold | $0.50 |

Free rows: every `store` row (`not_shopify`, `password_protected`, `collection_not_found`, `robots_disallowed`,
`blocked`, `rate_limited`, `error`, `invalid_input`), products past your "Max products per store" or "Max rows per
run" settings, and rows over the size limit. If your spending limit is reached, the run stops cleanly and tells you
so. The run's SUMMARY record (key-value store) counts the products charged in `productsCharged`. Apify's standard
Actor start event is charged when a run starts, at the platform's default price.

### Limits

- Speed: one store reads one page of up to 250 products at a time, at most 1 request per second. Large stores
  answer a page in 10 to 30 seconds, so 1,000 products take about 1 to 2 minutes per store (measured on kith.com:
  2,500 products in 174 s). Stores in parallel (up to 5) add up.
- At most 25 different stores per run and 25,000 products per store (default 5,000). The Actor never discovers stores
  by itself: it reads only the stores and collections you name.
- Public catalogue only. No login, no cookies, no passwords, no carts, checkouts, accounts, orders or customer data.
  Password-protected stores are reported as `password_protected` and left alone.
- It obeys robots.txt (the `TanForgeBot` token, then `*`) and reads at most 1 request per second per store.
- It stops a store at the first block (403 or a bot wall: `blocked`) and after one polite retry on 429 Too Many
  Requests (`rate_limited`). It does not use proxies, rotate addresses or hide who it is.
- It identifies itself as `Mozilla/5.0 (compatible; TanForgeBot/1.0; +https://apify.com/tan-solutions)`. Store owners
  can allow or block it in robots.txt with the `TanForgeBot` token.
- Product descriptions (`body_html`) are not collected.
- In variant mode "Max rows per run" counts variant rows, so the last product can be cut short; it is charged once.
- With a Monitor ID, a store that ignores page numbers (it returns the same products on every page) never reports
  `removed` products, because the Actor cannot tell that it read the whole catalogue.

### FAQ

**Does it work for every Shopify store?** For every store that keeps its public catalogue on. A store that turned it
off, or a site that is not on Shopify, gets a free `not_shopify` row.

**How fresh is the data?** It is read live at run time; `scrapedAt` says when.

**Can I track price changes?** Yes: give a Monitor ID and schedule the Actor (see "Track price and stock changes").

**What does variant mode cost?** The same as product mode: you pay per product, never per variant row.

**Can I call it from an AI agent?** Yes, through the Apify API, SDKs or MCP: pass `startUrls`, read the dataset items.

### Related tools by Tan Solutions

- [URL to Markdown](https://apify.com/tan-solutions/url-to-markdown): turn any web page into clean Markdown for AI and search.
- [SEO Audit](https://apify.com/tan-solutions/seo-audit): check a page or site for SEO problems.
- [Domain Intel](https://apify.com/tan-solutions/domain-intel): DNS, tech and contact signals for a list of domains.
- [Document to Markdown](https://apify.com/tan-solutions/document-to-markdown): turn PDFs and office files into Markdown.

### Your responsibilities

You are responsible for the stores you submit and for lawful use of the data you get back (the store's terms, database
and copyright rights, and competition law). The Actor reads only public catalogue data, obeys robots.txt, does not log
in and stops at blocks. It is provided without warranty; liability is capped at the fees you paid in the last 12
months. Questions and issues are answered within 14 days through the Actor's Issues tab.

Not affiliated with or endorsed by Shopify. All product names belong to their owners.

Made by Tan Solutions.

# Actor input Schema

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

One per line: a Shopify store domain such as allbirds.com or its home page (all products), or a collection page such as https://store.com/collections/sale (that collection only). Bare domains get https://. At most 25 different stores per run; the Actor never discovers stores by itself. Left out: the example store beardbrand.com.

## `outputMode` (type: `string`):

Product gives one row per product with its variants inside. Variant gives one row per variant (size, colour) with the product fields repeated.

## `includeImages` (type: `boolean`):

Add the list of every product image URL (images). Off keeps only the main image (imageUrl).

## `maxProductsPerStore` (type: `integer`):

Products past this number are not read (and not charged). Hard limit 25,000 per store.

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

The run stops cleanly after this many rows across all stores.

## `maxConcurrency` (type: `integer`):

How many stores are read at once. Each store still gets 1 request at a time, 1 second apart.

## `timeoutSecs` (type: `integer`):

Per request, from request to full body.

## `monitorId` (type: `string`):

Optional. Give the same ID on every run (for example my-shops) and each row gets change: new, price_up, price_down, availability or removed, compared with the last run of this ID. Letters, digits and -, up to 40 characters. Left empty: plain product rows, no comparison.

## `onlyChanges` (type: `boolean`):

With a Monitor ID: list only new, changed and removed products; unchanged ones are left out and not charged. Off lists every product with change: unchanged. Ignored without a Monitor ID.

## Actor input object example

```json
{
  "startUrls": [
    "https://beardbrand.com"
  ],
  "outputMode": "product",
  "includeImages": false,
  "maxProductsPerStore": 5000,
  "maxItems": 100000,
  "maxConcurrency": 3,
  "timeoutSecs": 30,
  "onlyChanges": true
}
```

# Actor output Schema

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

One item per product: title, vendor, price range, stock and links.

## `variants` (type: `string`):

Each product's variants with price, SKU and stock.

# 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": [
        "https://beardbrand.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tan-solutions/shopify-products").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": ["https://beardbrand.com"] }

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

```

## MCP server setup

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

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/uJs5ByU5U1WpQqNgv/builds/kTqEfQge4QkVCKLqb/openapi.json
