# Shopify Products Scraper: Prices, Variants, Stock & Launches (`vncntlabs/shopify-products-scraper`) Actor

Scrape every product from any Shopify store or collection: price, compare-at price and discount, stock, variants, sizes and colors, tags, images and launch dates. Plus a free store summary with price range, top product types and what launched in the last 30 days.

- **URL**: https://apify.com/vncntlabs/shopify-products-scraper.md
- **Developed by:** [VNCNT Labs](https://apify.com/vncntlabs) (community)
- **Categories:** E-commerce, MCP servers, Lead generation
- **Stats:** 1 total users, 0 monthly users, 0.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.

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 & New Launches

Put in one or more Shopify store URLs and get **every product in the catalog as one clean row**: title, URL, **price and compare-at price, discount %, stock status, variants and options (sizes, colors), product type, tags, vendor, main image and the date it was published**. Each store also gets a free summary row with its name, currency, country, product count, median price, share on sale, top product types and tags, and how many products it launched in the last 7 and 30 days.

Filter by keyword, "published in the last N days", on sale or in stock, and sort newest first or by discount, so you can see **what a competitor just launched or put on sale** without reading their whole catalog. No API key, no login, no proxy. $0.50 per 1,000 products.

Built for:

- **Print-on-demand, merch and Etsy sellers**: see which designs, niches and price points the bigger Shopify stores in your niche are launching right now.
- **Dropshippers and store owners**: track a competitor's prices, discounts and stock, and spot new products the week they go live.
- **eBay and Amazon resellers**: pull a brand's full catalog with SKUs and compare-at prices to find gaps and margins.
- **Developers and AI agents**: one call returns clean JSON for a price monitor, a product database or a market report.

### What you get

| Row (`type`) | What's in it | Charged |
|---|---|---|
| `product` | `store`, `title`, `url`, `handle`, `productId`, `vendor`, `productType`, `tags`, `currency`, `price` (lowest variant), `priceMax`, `compareAtPrice`, `discountPercent`, `onSale`, `available`, `variantsCount`, `availableVariants`, `options` (e.g. Size: S, M, L), `imageUrl`, `imagesCount`, `publishedAt`, `createdAt`, `updatedAt`, `daysSincePublished`. Optional: `variants` (title, SKU, price, compare-at price, stock, options) and `description` (plain text) | `product` |
| `store` | `status`, `storeName`, `currency`, `country`, `myshopifyDomain`, `productsScanned`, `catalogComplete`, `productsDelivered`, `priceMin`, `priceMax`, `priceMedian`, `onSaleShare`, `inStockShare`, `publishedLast7Days`, `publishedLast30Days`, `newestPublishedAt`, `topProductTypes`, `topTags`, `topVendors`, plus a `note` or `error` | free |
| `skipped` | inputs that weren't valid or weren't scraped, with the reason | free |

Store stats cover every product that was read, before your filters, so you get the shape of the catalog even when you only ask for a few rows.

### Input examples

Whole catalogs of two stores (up to 1,000 products each):

```json
{ "startUrls": [{ "url": "https://kith.com" }, { "url": "https://www.allbirds.com" }], "maxProductsPerStore": 1000 }
```

What a store launched in the last 30 days, newest first:

```json
{ "startUrls": [{ "url": "https://fashionnova.com" }], "publishedWithinDays": 30, "sortBy": "newest", "maxProductsPerStore": 100 }
```

Hoodies and sweatshirts on sale, biggest discount first, with every size and SKU:

```json
{ "startUrls": [{ "url": "https://fashionnova.com" }], "keywords": ["hoodie", "sweatshirt"], "onlyOnSale": true,
  "sortBy": "discount", "includeVariants": true, "maxProductsPerStore": 50 }
```

One collection only:

```json
{ "startUrls": [{ "url": "https://www.allbirds.com/collections/mens" }], "maxProductsPerStore": 200 }
```

**Tips**

- **Max products per store** is your cost cap: 100 products = $0.05, 1,000 = $0.50, plus the $0.005 run start.
- With filters on, the Actor reads up to 4x your limit (at least 1,000 products, at most 10,000) to find matches, and you only pay for the rows that match.
- `sortBy` works on the products that were read. Shopify's feed lists the newest published products first, so "newest" on a big store is accurate for recent launches.
- Store URL, custom domain or `name.myshopify.com` all work. Up to 50 stores per run.
- Some stores block automated requests or are password-protected. Those get a store row with the reason and cost nothing.

### Output examples

A product row:

```json
{
  "type": "product", "store": "fashionnova.com",
  "title": "Skye Spaghetti Strap Sweater Mini Dress - Bronze",
  "url": "https://fashionnova.com/products/skye-spaghetti-strap-sweater-mini-dress-fncolorname-bronze",
  "vendor": "Fashion Nova", "productType": "Dresses", "tags": ["category:Dresses", "color_fam:Brown", "Plus"],
  "currency": "USD", "price": 5, "priceMax": 5, "compareAtPrice": 49.99, "discountPercent": 90, "onSale": true,
  "available": true, "variantsCount": 8, "availableVariants": 8,
  "options": { "Size": ["XS", "S", "M", "L", "XL", "1X", "2X", "3X"] },
  "imagesCount": 6, "publishedAt": "2026-10-28T23:17:49Z", "daysSincePublished": 1
}
```

A store summary row:

```json
{
  "type": "store", "store": "www.allbirds.com", "status": "ok", "storeName": "Allbirds", "currency": "USD",
  "country": "US", "myshopifyDomain": "weareallbirds.myshopify.com", "productsScanned": 356, "catalogComplete": true,
  "priceMin": 0.8, "priceMax": 165, "priceMedian": 110, "onSaleShare": 0.042, "inStockShare": 0.98,
  "publishedLast7Days": 0, "publishedLast30Days": 0, "newestPublishedAt": "2026-09-25T23:58:13Z",
  "topProductTypes": [{ "name": "Shoes", "count": 344 }, { "name": "Apparel", "count": 3 }]
}
```

The dataset has two views, **Products** and **Stores**. Export to CSV, Excel or JSON, or send results to Google Sheets, Slack or email with Apify integrations. Schedule a daily run to keep a price and launch history.

### Pricing (pay per event)

| Event | Price | When it is charged |
|---|---|---|
| Actor start | $0.005 | once per run |
| `product` | $0.0005 | one product row delivered |

So 100 products cost $0.055, and 3 stores with 1,000 products each cost $1.505.

You are not charged for:

- store summary rows, products that don't match your filters, and stores that are blocked, password-protected, rate-limited, empty or not on Shopify;
- skipped inputs, and anything beyond your run's maximum charge. The run stops at your maximum charge and says so in the store row.

**Apify free plan:** 3 stores and 100 products per store per run. Any paid Apify plan unlocks 50 stores and 10,000 products per store.

### Use from AI agents (MCP)

AI assistants such as Claude, ChatGPT and Cursor can run this Actor through [Apify's MCP server](https://docs.apify.com/platform/integrations/mcp) (`https://mcp.apify.com`). The agent can look up the Actor, read its input schema, run it and read the results. Runs use your own Apify account and are charged at the prices on this page.

- **Actor name:** `vncntlabs/shopify-products-scraper`
- **Server URL with only this tool:** `https://mcp.apify.com?tools=vncntlabs/shopify-products-scraper`. The default `https://mcp.apify.com` also works; the agent can then search Apify Store and call the Actor by name.
- **Claude** (desktop app or claude.ai): Settings > Connectors > Add custom connector, paste the server URL, then sign in to Apify.
- **ChatGPT:** turn on Developer mode, then Settings > Apps & Connectors > Create, paste the server URL and choose OAuth.
- **Cursor:** run `/add-plugin apify` in Cursor chat and connect the Apify MCP server under Cursor Settings > Tools & MCPs, or add the server to `mcp.json`:

```json
{ "mcpServers": { "apify": { "url": "https://mcp.apify.com?tools=vncntlabs/shopify-products-scraper" } } }
```

Example prompt: *"Use the Apify Actor vncntlabs/shopify-products-scraper to get the products competitor.com published in the last 30 days, then group them by product type and price range."*

To cap the cost of an agent's run, it can pass `maxTotalChargeUsd` in the run options.

### FAQ

**Where does the data come from?** From each store's public Shopify product feed (`/products.json`), the same data shown on the store's own product pages. No login and no private data.

**How do I know a site runs on Shopify?** Just put it in. If it isn't Shopify, the store row says `not-shopify` and you pay nothing.

**Does it show sales numbers or inventory counts?** No. Shopify doesn't publish those. You get in stock or out of stock per variant, plus prices, discounts and launch dates.

**Why did a store stop before the end?** Big stores sometimes start limiting requests partway through. The store row says how many products were read and why it stopped, and you're only charged for rows you got.

**Related tools:** [Amazon Product Scraper](https://apify.com/vncntlabs/amazon-product-scraper) for Amazon listings, [Google Shopping Scraper](https://apify.com/vncntlabs/google-shopping-scraper) to compare prices across stores, and [Keyword Search Volume](https://apify.com/vncntlabs/keyword-search-volume) to check demand for a product idea.

Questions or a field you'd like added? Email hello@vncntlabs.com.

Not affiliated with Shopify.

# Actor input Schema

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

Up to 50 Shopify stores. Use the store's home page (https://example.com) for the whole catalog, or a collection URL (https://example.com/collections/t-shirts) for one collection. Stores that aren't on Shopify, are password protected or block the request are reported and not charged.

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

Products to return from each store. You pay $0.0005 per product row ($0.50 per 1,000). The store's feed lists the most recently published products first.

## `keywords` (type: `array`):

Keep products whose title, tags, product type, vendor or handle contain any of these words, for example hoodie or halloween. With a filter on, the Actor reads up to 4x your max products (at least 1,000, at most 10,000) to find matches.

## `publishedWithinDays` (type: `integer`):

Good for spotting a competitor's new launches. 0 means any date.

## `onlyOnSale` (type: `boolean`):

Keep products where at least one variant has a compare-at price above its price.

## `onlyInStock` (type: `boolean`):

Keep products with at least one available variant.

## `sortBy` (type: `string`):

Sorting applies to the products read from each store.

## `includeVariants` (type: `boolean`):

Adds a variants list to each product: title, SKU, price, compare-at price, stock and option values. Same price per product.

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

Adds the description as plain text (up to 1,000 characters). Same price per product.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://kith.com"
    },
    {
      "url": "https://www.allbirds.com"
    }
  ],
  "maxProductsPerStore": 20,
  "publishedWithinDays": 0,
  "onlyOnSale": false,
  "onlyInStock": false,
  "sortBy": "store",
  "includeVariants": false,
  "includeDescription": false
}
```

# Actor output Schema

## `products` (type: `string`):

No description

## `stores` (type: `string`):

No description

## `all` (type: `string`):

No description

## `summary` (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 = {
    "startUrls": [
        {
            "url": "https://kith.com"
        },
        {
            "url": "https://www.allbirds.com"
        }
    ],
    "maxProductsPerStore": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("vncntlabs/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 = {
    "startUrls": [
        { "url": "https://kith.com" },
        { "url": "https://www.allbirds.com" },
    ],
    "maxProductsPerStore": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("vncntlabs/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 '{
  "startUrls": [
    {
      "url": "https://kith.com"
    },
    {
      "url": "https://www.allbirds.com"
    }
  ],
  "maxProductsPerStore": 20
}' |
apify call vncntlabs/shopify-products-scraper --silent --output-dataset

```

## MCP server setup

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