# Shopify Product Scraper & Search: 290+ European Stores (`clearfeed-data/shopify-product-search-europe`) Actor

Search products across 290+ European brands' Shopify stores by keyword, country and category, or track any Shopify store. Prices, discounts, stock, new products and price drops in one clean schema.

- **URL**: https://apify.com/clearfeed-data/shopify-product-search-europe.md
- **Developed by:** [Clearfeed Data](https://apify.com/clearfeed-data) (community)
- **Categories:** E-commerce, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 product returneds

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

### What does Shopify Product Search: European Stores do?

It searches **products across 290+ European brands' own Shopify stores** (18 countries, 349,000 products) in one run, or reads **any Shopify store you choose** in full. You get prices, discounts, stock, brand, type, tags and images in one clean schema, with a built-in **price and new-product monitor**.

- **Search by keyword across Europe**: "linen shirt" in every French and Italian fashion store, "protein bar" in every German food store.
- **Track competitors**: paste their Shopify store URLs and get their whole catalog, then only new products, price drops and restocks on each scheduled run.
- **No login, no browser, no personal data**: it reads the public storefront data every Shopify store publishes.

### Why use it?

| You want to | Do this |
|---|---|
| Spot trending products and new launches in a niche | Keywords + country + category, `newWithinDays: 14` |
| Monitor competitors' prices and stock | Add their stores, turn on **Only new or changed products**, schedule daily |
| Find discounts across many shops | `onSaleOnly: true` or `minDiscountPercent: 30` |
| Build a product database or feed an AI agent | Full catalog mode, export as JSON, CSV or Excel |
| Check which stores sell a brand | Keyword = the brand name |

### How it works

1. **Pick stores.** Use the built-in directory of European Shopify stores (filter by store country, category and countries they ship to), add your own store URLs, or both.
2. **Pick products.** Keywords (whole-word, accents ignored), excluded words, price range, on sale, in stock, published recently.
3. **Run.** Each store's public catalog is read and matched against your filters: the 1,000 newest products of each directory store, and the whole catalog of your own stores. A full scan of the directory takes about 2 to 3 minutes.

### Monitoring: new products, price drops, back in stock

Turn on **Only new or changed products**. The Actor remembers each product's price and stock between runs (per **Monitor name**) and returns only:

- `new`: products it has not seen before
- `price_drop`: cheaper than last run (`previousPrice` shows the old price)
- `back_in_stock`: was sold out, now available
- `price_increase`, `out_of_stock`: optional

The first run returns everything, as a baseline. Then schedule the Actor (daily is typical) and connect it to email, Slack, Google Sheets or a webhook with Apify integrations.

### Input example

```json
{
  "keywords": ["linen shirt"],
  "countries": ["FR", "IT"],
  "categories": ["fashion"],
  "availableOnly": true
}
```

Competitor monitor:

```json
{
  "stores": ["https://www.polene-paris.com", "snocks.com"],
  "onlyChanges": true,
  "monitorName": "my-competitors"
}
```

### Output example

```json
{
  "id": "snocks.com:6081549467845",
  "storeDomain": "snocks.com",
  "storeName": "SNOCKS",
  "storeCountry": "DE",
  "storeCategory": "fashion",
  "productId": "6081549467845",
  "title": "Business Socken | Schwarz",
  "url": "https://snocks.com/products/business-socken-leichte-lange-socken",
  "vendor": "Snocks",
  "productType": "Socken",
  "tags": ["socken", "unisex"],
  "price": 29.99,
  "priceMax": 29.99,
  "compareAtPrice": null,
  "discountPercent": null,
  "onSale": false,
  "currency": "EUR",
  "available": true,
  "imageUrl": "https://cdn.shopify.com/s/files/1/0048/8285/8054/products/Business-Titelbild.jpg",
  "variantCount": 4,
  "createdAt": "2021-01-12T09:10:00Z",
  "publishedAt": "2021-01-12T09:10:00Z",
  "updatedAt": "2026-10-24T11:06:35Z",
  "changeType": "price_drop",
  "previousPrice": 34.99,
  "scrapedAt": "2026-10-24T12:00:00Z"
}
```

With **Include variants** you also get each size/color with its SKU, price, compare-at price and stock. With **Include product description** you get the description as plain text.

A run summary (stores scanned, stores blocked, changes detected) is saved as `RUN_SUMMARY` in the key-value store.

### How much does it cost?

You pay per product returned: **$1.50 per 1,000 products**, plus a tiny start fee. Monitoring runs only charge for new or changed products, so a daily competitor check usually costs cents. Set **Maximum products** or a maximum cost per run to stay in control.

### Tips and limits

- Prices are in each store's own currency (`currency` field).
- A few big stores block automated access to their public catalog. They are listed in the run summary; turning on the Apify proxy often helps.
- The directory is refreshed regularly. Missing a store? Add it under **Your own stores**.
- Need older products from a big directory store? Raise **Maximum products per store**, or add the store under **Your own stores** to read its whole catalog.

### Is it legal?

It reads only public product data that Shopify stores publish for every visitor (catalog, prices, stock). No personal data is collected. Check the terms of the sites you monitor for your use case.

### Other Actors by Clearfeed Data

- [European Jobs API: Personio, Teamtailor, Recruitee, Greenhouse](https://apify.com/clearfeed-data/eu-company-jobs-feed): fresh jobs from 490+ European companies' career sites
- [European Startup Funding Rounds (Crunchbase Alternative)](https://apify.com/clearfeed-data/european-startup-funding-rounds): every European startup funding round as data
- [Google News Scraper & Monitor (Multi-Country)](https://apify.com/clearfeed-data/google-news-monitor): Google News in 60+ countries with real URLs and only-new alerts
- [App Store & Google Play Reviews Scraper (Multi-Country)](https://apify.com/clearfeed-data/app-store-google-play-reviews): iOS and Android reviews in 60+ countries with only-new alerts

# Actor input Schema

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

Find products matching any of these words (title, type, brand and tags; case and accents ignored). Leave empty to read whole catalogs.

## `useDirectory` (type: `boolean`):

Scan every store in the built-in directory (European brands' own Shopify shops, refreshed regularly). If you leave this unset, it is on when you give no store URLs below and off when you do.

## `countries` (type: `array`):

Only directory stores based in these countries. Leave empty for all of Europe.

## `categories` (type: `array`):

Only directory stores selling mainly in these categories. Leave empty for all.

## `shipsTo` (type: `array`):

Only directory stores that deliver to at least one of these countries (ISO codes, e.g. FR, DE).

## `stores` (type: `array`):

Any Shopify store, e.g. https://www.polene-paris.com or snocks.com. Your stores are read in full (whole catalog), so this is the way to track competitors.

## `excludeKeywords` (type: `array`):

Skip products whose title contains any of these words, e.g. 'gift card', 'sample'.

## `minPrice` (type: `integer`):

In the store's currency.

## `maxPrice` (type: `integer`):

In the store's currency.

## `onSaleOnly` (type: `boolean`):

Only products with a crossed-out 'compare at' price.

## `minDiscountPercent` (type: `integer`):

Only products discounted by at least this percentage.

## `availableOnly` (type: `boolean`):

Skip products that are sold out in every size and color.

## `skipZeroPrice` (type: `boolean`):

Products at 0 are usually free samples, gifts or items not sold in the store's main market.

## `newWithinDays` (type: `integer`):

Only products published recently. Works when catalogs are read (your own stores, or searches without keywords); search-box results have no dates and are kept.

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

Remember every product between runs and return only what changed: new products, price drops, back in stock. Schedule the Actor daily to get a change feed. The first run returns everything (it has nothing to compare with).

## `changeTypes` (type: `array`):

Used with monitoring.

## `monitorName` (type: `string`):

Runs with the same name share their memory. Use a different name for each saved search or competitor list.

## `scanMode` (type: `string`):

Full catalog (default): read each store's catalog and match keywords locally. Directory stores: the 1,000 newest products each; your own stores: everything. Search box: ask each store's own search (up to 10 best matches per keyword per store); Shopify often slows it down, so use it only for a few stores.

## `strictKeywordMatch` (type: `boolean`):

Used with the search box: store search boxes sometimes return loose matches. Keep this on to drop them.

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

Only when catalogs are read.

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

Plain text, HTML removed.

## `maxProducts` (type: `integer`):

Stop after this many products. 0 means no limit.

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

0 means no limit for your own stores and the 1,000 newest products for directory stores.

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

Higher is faster, but Shopify slows down IPs that send too many requests. 10 is a safe default.

## `proxyConfiguration` (type: `object`):

Leave off: shared proxy IPs are often slowed down by Shopify. Turn it on only if many of your own stores come back blocked.

## Actor input object example

```json
{
  "keywords": [
    "linen shirt",
    "candle"
  ],
  "onSaleOnly": false,
  "availableOnly": false,
  "skipZeroPrice": true,
  "onlyChanges": false,
  "changeTypes": [
    "new",
    "price_drop",
    "back_in_stock"
  ],
  "monitorName": "default",
  "scanMode": "catalog",
  "strictKeywordMatch": true,
  "includeVariants": false,
  "includeDescription": false,
  "maxProducts": 0,
  "maxProductsPerStore": 0,
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All products returned by this run, one row per product.

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

Stores scanned, stores blocked, products matched and returned, changes detected.

# 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 = {
    "keywords": [
        "linen shirt",
        "candle"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("clearfeed-data/shopify-product-search-europe").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 = {
    "keywords": [
        "linen shirt",
        "candle",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("clearfeed-data/shopify-product-search-europe").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 '{
  "keywords": [
    "linen shirt",
    "candle"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call clearfeed-data/shopify-product-search-europe --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,clearfeed-data/shopify-product-search-europe"
        }
    }
}
```

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/eZuzayJvsCSdAuflY/builds/yF4EnQ8QfhklbEijE/openapi.json