# Shopify Products Scraper (`pintostudio/shopify-products-scraper`) Actor

Scrape any Shopify store's full product catalog in seconds - titles, prices, variants, images, tags and descriptions - via the store's own public product feed. No login or proxy needed. Use it as a Task, call the REST/MCP API, or plug it into an AI agent.

- **URL**: https://apify.com/pintostudio/shopify-products-scraper.md
- **Developed by:** [Pinto Studio](https://apify.com/pintostudio) (community)
- **Categories:** E-commerce, Integrations, Real estate
- **Stats:** 34 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.70 / 1,000 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 Products Scraper

Scrape the full product catalog of any Shopify store in seconds - titles, prices, variants, images, tags and descriptions - straight from the store's own public product feed. No login, API key or proxy required. Use it as a one-off Actor run, a ready-made Task, a REST API, or a tool for AI agents via the Apify MCP server.

### What does Shopify Products Scraper do?

Give it a store's URL (or bare domain) and it returns every product on that page of the catalog, with the fields that matter for commerce, research and monitoring:

- **Title, Handle, Url** - the product name, slug and direct link to its page.
- **Vendor, ProductType, Tags** - brand, category and tagging.
- **Price, CompareAtPrice, Available** - current price, list price and stock status.
- **ImageUrl, ImagesCount, VariantsCount** - the main image and how many images/variants exist.
- **PublishedAt, CreatedAt, UpdatedAt, BodyHtml** - timestamps and the full HTML description.
- **Variants, Images, Options** - the complete raw arrays for every size, color and image.

### Why use this instead of scraping the storefront by hand?

Every Shopify store exposes its catalog at a standard, public `/products.json` endpoint - this Actor calls that feed directly instead of rendering pages or fighting anti-bot walls, so it's fast, reliable and works the same way on any Shopify store. Results come back as one row per product, ready to feed into a spreadsheet, a pricing dashboard, or an AI agent's research pipeline.

### Input parameters

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `url` | string | Yes | The URL (or bare domain) of the Shopify store, e.g. `https://alpineskin.com` or just `alpineskin.com`. |
| `limit` | integer | No (default `50`) | Maximum number of products to return in one page (1-250). |
| `page` | integer | No (default `1`) | The page of results to fetch. Combine with `limit` to page through a store's full catalog. |

### Example input

```json
{
  "url": "https://alpineskin.com",
  "limit": 50,
  "page": 1
}
```

### Example output (dataset item)

```json
{
  "Id": 1234567890,
  "Title": "Vitamin C Serum",
  "Handle": "vitamin-c-serum",
  "Url": "https://alpineskin.com/products/vitamin-c-serum",
  "Vendor": "Alpine Skin",
  "ProductType": "Serum",
  "Tags": "bestseller, vitamin-c",
  "Price": "34.00",
  "CompareAtPrice": "42.00",
  "Available": true,
  "ImageUrl": "https://cdn.shopify.com/s/files/1/.../vitamin-c-serum.jpg",
  "ImagesCount": 4,
  "VariantsCount": 1,
  "PublishedAt": "2023-02-14T10:00:00-05:00",
  "CreatedAt": "2023-02-10T08:30:00-05:00",
  "UpdatedAt": "2026-08-01T12:00:00-05:00"
}
```

Every run also writes a run summary to the key-value store under the `OUTPUT` key, and each dataset item follows the published [dataset schema](https://docs.apify.com/platform/actors/development/actor-definition/dataset-schema), so results render as a clean table (with product images) in Apify Console and in any tool that reads Apify's Actor output schema.

### Ready-made Tasks

This Actor ships with pre-configured [Apify Tasks](https://docs.apify.com/platform/actors/running/tasks) you can run immediately or trigger via the API without writing any input JSON yourself:

- **Alpine Skin Products** - the default example: up to 50 products from alpineskin.com.
- **Gymshark Full Catalog Page 1** - up to 100 products from gymshark.com.
- **Allbirds Products Sample** - a quick 20-product sample from allbirds.com.
- **Kylie Cosmetics Products Page 2** - demonstrates pagination: page 2 of kyliecosmetics.com's catalog.

### Run it with the Apify API (curl)

```bash
curl "https://api.apify.com/v2/acts/pintostudio~shopify-products-scraper/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"url": "alpineskin.com", "limit": 50, "page": 1}'
```

### Live HTTP API (Standby mode)

This Actor also runs as an always-on web server ([Standby mode](https://docs.apify.com/platform/actors/running/standby)), so you can call it like a normal REST API without starting a new run each time:

```bash
curl "https://pintostudio--shopify-products-scraper.apify.actor/products?url=alpineskin.com&limit=50&page=1"
```

The endpoint, parameters and response shape are fully described by the Actor's published [OpenAPI schema](https://docs.apify.com/platform/actors/development/actor-definition/web-server-schema), so any OpenAPI-aware client or code generator can consume it directly.

### Use it from AI agents (MCP)

Shopify Products Scraper can be called by Claude, ChatGPT and other MCP-compatible agents through the [Apify MCP Server](https://docs.apify.com/platform/integrations/mcp), so an agent can pull a live product catalog as one of its tools instead of guessing from stale training data:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--actors", "pintostudio/shopify-products-scraper"],
      "env": {
        "APIFY_TOKEN": "YOUR_TOKEN"
      }
    }
  }
}
```

### Frequently asked questions

#### Does this work on any Shopify store, or only specific ones?

It works on any store built on Shopify that has not disabled its public product feed - just pass the store's URL or domain. Most Shopify stores expose this feed by default.

#### Where does the data come from? Is this against Shopify's terms?

The Actor reads the store's own public `/products.json` feed - the same catalog data Shopify serves to shoppers and to legitimate apps. No login, private API key or protected page is accessed.

#### Can I get a store's entire catalog, not just one page?

Yes. Set `limit` to the page size (up to 250) and increment `page` on successive runs (or Standby calls) to page through the whole catalog, the same way the "Kylie Cosmetics Products Page 2" task demonstrates.

#### Why is `Price` a plain number instead of showing a currency?

Shopify's public product feed returns prices without a currency code attached. Check the store's storefront directly (or its locale) to confirm which currency that price is in.

#### Can I call this without starting a new Actor run each time?

Yes. The Actor supports [Standby mode](https://docs.apify.com/platform/actors/running/standby), which keeps an HTTP server warm so `GET /products` requests are answered immediately, the same way you'd call any REST API.

#### Can AI agents use this Actor as a tool?

Yes. It is compatible with the [Apify MCP Server](https://docs.apify.com/platform/integrations/mcp), so agents built with Claude, the OpenAI Agents SDK, LangChain or similar frameworks can pull live product data directly instead of relying on outdated training data.

#### What happens if a store has no products or blocks the request?

The run still succeeds; it returns as many products as the feed provides (which may be zero for an empty or fully private catalog) rather than failing the whole run.

# Actor input Schema

## `url` (type: `string`):

The URL (or bare domain) of the Shopify store you want to scrape products from.

## `limit` (type: `integer`):

Maximum number of products to retrieve in one page (Shopify allows up to 250).

## `page` (type: `integer`):

The page of results to fetch (1-based). Combine with 'limit' to page through a store's full catalog.

## Actor input object example

```json
{
  "url": "https://alpineskin.com",
  "limit": 50,
  "page": 1
}
```

# Actor output Schema

## `products` (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 = {
    "url": "https://alpineskin.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("pintostudio/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 = { "url": "https://alpineskin.com" }

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

```

## MCP server setup

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