# Ecwid Product Catalog Extractor & Monitor (`clintsa/ecwid-product-catalog-extractor`) Actor

Extract every public Ecwid storefront product with stable IDs, prices, SKUs, categories, image URLs, stock status and product URLs.

- **URL**: https://apify.com/clintsa/ecwid-product-catalog-extractor.md
- **Developed by:** [Andy Besos](https://apify.com/clintsa) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 product records

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

Turn a public Ecwid storefront into a clean, row-per-product catalog snapshot. Ecwid Product Catalog Extractor & Monitor discovers the public storefront ID, walks every visible category and product page, and returns product IDs, names, prices, SKUs, categories, image URLs, stock status, and canonical product URLs.

Paste a storefront URL and receive data ready for CSV, JSON, Excel, or an automated workflow. You do not need an Ecwid account, an Ecwid Admin API key, browser automation, or a proxy for normally reachable public storefronts.

### Why use this Ecwid product catalog extractor?

- Get one normalized product record per publicly visible product, not a technology label or a storefront summary. `storefrontId` and `productId` make records stable for joins and repeated collection.
- Capture the fields competitive-intelligence workflows need: current `price`, default-variation `sku`, leaf `categories`, main `imageUrl`, `inStock`, and `productUrl`.
- Start from the URL people actually share. The Actor accepts an embedded Ecwid store page, an Instant Site catalog URL, a normal domain with an Ecwid widget, or a numeric Ecwid store ID.
- Export a complete current catalog by setting `maxProducts` to `0`. The Actor follows public category pagination and deduplicates products that appear in more than one category.
- Monitor scheduled snapshots. Keep the same `monitorId` to receive `new`, `updated`, `unchanged`, and one-time `removed` product events, including the exact `changedFields` for an update.
- Use the results anywhere Apify Dataset exports are supported, including JSON, CSV, Excel, XML, RSS, REST integrations, schedules, webhooks, Make, and Zapier.

The Actor uses public storefront requests with retries for temporary upstream errors. Each storefront is isolated: a bad URL is logged without discarding successful catalog snapshots from other URLs in the same run.

### Pricing

This Actor uses pay per event: **$0.001 per run plus $0.0008 per product record** written to the default Dataset.

| Product records | Actor event price |
| ---: | ---: |
| 1 | $0.0018 |
| 100 | $0.0810 |
| 1,000 | $0.8010 |
| 10,000 | $8.0010 |

The exact formula is **$0.001 per run + $0.0008 per product record**. Prices above cover the Actor's chargeable run and product-record events; standard Apify charges for data retention or downloads may apply. In the 31 August 2026 comparison of the live Ecwid-specific Store results, the closest product scraper documented a $0.01 custom event per product; this Actor's compact snapshot costs less per exported product while adding a scheduled change feed.

### How to use this Actor

Enter a public page that contains the Ecwid catalog. Accepted examples include a merchant storefront such as `https://ourlittlecraft.co.uk/`, a merchant catalog route such as `https://ourlittlecraft.co.uk/shop/`, an Ecwid Instant Site URL such as `https://example.company.site/products/`, a normal storefront domain, or a numeric store ID such as `44430351`. The Actor removes query strings and fragments before monitoring, so campaign parameters do not create a second snapshot namespace.

#### Quick start: preview one product

```json
{
  "storefrontUrls": ["https://ourlittlecraft.co.uk/"],
  "maxProducts": 1
}
```

This is also the prefilled example. It exports one product quickly, while still collecting the full visible catalog before creating the monitoring snapshot. Use it to confirm that a storefront is reachable and its product shape fits your workflow.

#### Full catalog snapshot

```json
{
  "storefrontUrls": ["https://ourlittlecraft.co.uk/"],
  "maxProducts": 0
}
```

Set `maxProducts` to `0` to export every product that the public storefront currently exposes. For a batch of supplier or competitor stores, add more URLs to the same array; every record retains its own storefront URL and storefront ID.

```json
{
  "storefrontUrls": [
    "https://supplier-one.example/catalog/",
    "https://supplier-two.example/shop/"
  ],
  "maxProducts": 0,
  "requestDelayMillis": 1000
}
```

### Monitor new, updated, and removed products

Every successful run saves a full product snapshot in a named store. Schedule the Actor with the same storefront URLs and `monitorId` to turn catalog collection into an actionable product-change feed.

```json
{
  "storefrontUrls": ["https://ourlittlecraft.co.uk/"],
  "monitorId": "supplier-watchlist",
  "onlyChangesSince": "2026-08-01T00:00:00.000Z",
  "maxProducts": 0
}
```

The first run establishes the baseline and labels its records `new`. Later successful runs compare the complete catalog before applying the output limit.

| `changeType` | Meaning |
| --- | --- |
| `new` | A product did not exist in the prior successful snapshot. |
| `updated` | A monitored product field changed; `changedFields` lists it. |
| `unchanged` | The product is still public and its monitored fields match. |
| `removed` | A previously public product disappeared; this event is emitted once. |

Set `onlyChangesSince` to suppress unchanged products and deliver only a focused change feed. A failed collection never overwrites the prior snapshot, so a temporary storefront outage does not manufacture removals.

### API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/Clintsa~ecwid-product-catalog-extractor/run-sync-get-dataset-items" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "storefrontUrls": ["https://ourlittlecraft.co.uk/"],
    "maxProducts": 10
  }'
```

For large catalog snapshots, start the Actor asynchronously and read the default Dataset after it succeeds.

### Input options

| Field | Type | What it controls |
| --- | --- | --- |
| `storefrontUrls` | string array | Required public Ecwid storefront or catalog URLs. |
| `maxProducts` | integer | Products exported per storefront; `0` means every visible product. |
| `monitorId` | string | Persistent namespace used for product change tracking. |
| `onlyChangesSince` | ISO timestamp | Returns only changes detected since that timestamp. |
| `requestDelayMillis` | integer | Optional delay between storefronts in a batch. |
| `useApifyProxy` | boolean | Enables Apify Proxy only as a network fallback. |
| `proxyConfiguration` | object | Optional proxy settings when the fallback is enabled. |

### Output

Each Dataset item is one normalized public product, plus its monitoring fields:

```json
{
  "storefrontUrl": "https://ourlittlecraft.co.uk/shop/",
  "storefrontId": "44430351",
  "productId": "721812262",
  "name": "YarnArt Stylish Alpaca - 7703",
  "price": 6.36,
  "currency": "GBP",
  "sku": "YASA7703",
  "categories": ["Lovely Yarn", "SALE!"],
  "imageUrl": "https://cdn.example.com/product.jpg",
  "inStock": true,
  "productUrl": "https://ourlittlecraft.co.uk/shop/YarnArt-Stylish-Alpaca-7703-p721812262",
  "changeType": "new",
  "changeDetectedAt": "2026-08-31T10:00:00.000Z"
}
```

The run also writes a `SUMMARY` record with requested, successful, and failed storefront counts, the exported product count, change totals, proxy usage, and completion time.

### Use cases

- Monitor a dropshipping supplier's Ecwid catalog for new products, price changes, and removals.
- Compare competitors' live SKU, category, image, and stock signals across multiple Ecwid storefronts.
- Feed a market-research database that already normalizes Shopify and WooCommerce catalogs.
- Create a brand-protection watchlist around public product names, images, and canonical product pages.
- Build a scheduled procurement or merchandising alert from price and availability changes.

### FAQ

#### Do I need an Ecwid account or API key?

No. This Actor reads only public storefront pages and their public storefront data endpoints. It does not use the OAuth-protected Ecwid Admin API.

#### Can I extract every product from an Ecwid store?

Yes, set `maxProducts` to `0`. Output completeness is limited to products that the merchant makes publicly visible in its storefront; unpublished, private, or login-only products are not returned.

#### Does this work with an Ecwid store embedded in WordPress or another website?

Yes. Use the page that contains the Ecwid product browser, such as a site's `/shop/` page. The Actor identifies the embedded store ID from the public page.

#### Which price and stock values are returned?

`price` is the current public default-variation price supplied by the storefront, including a storefront discount where that endpoint supplies it. `inStock` describes whether that default variation is publicly marked sold out. Variant-level inventory quantities are not part of this compact snapshot.

#### Can I monitor a catalog every day?

Yes. Create a schedule, preserve the same `monitorId`, and use the same normalized storefront URLs. The first completed run is the baseline; later runs provide the catalog change feed.

#### Why did a storefront URL fail?

The page may not contain an Ecwid catalog, may require sign-in, may block the request, or may be temporarily unavailable. Check the run log and try the exact public catalog page; enable Apify Proxy only if direct access is rejected.

### Limitations and responsible use

- Only publicly available product data is returned. The Actor does not bypass login walls, payment gates, or access controls.
- A successful snapshot shows what the storefront exposed at collection time; it does not prove ownership, authorization, or an item's actual sell-through.
- A product's categories, price, image, and availability can differ by region, customer group, selected variation, or storefront settings. The output represents the public default storefront response.
- Respect applicable laws, each merchant's terms, robots rules, and legitimate privacy and intellectual-property obligations when collecting or using data.

### Support

Report an issue or request through the Issues tab on this Actor's page. Include the run ID, the storefront URL, and the time of the run so the public storefront response can be investigated.

# Actor input Schema

## `storefrontUrls` (type: `array`):

Required. Paste public Ecwid storefront or catalog URLs. The Actor discovers the Ecwid store ID from each storefront and normalizes the URL. A numeric Ecwid store ID is also accepted.

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

Limit products exported for each storefront. Set to 0 to export every publicly visible product. The complete catalog is snapshotted before this output limit is applied, so monitoring remains accurate.

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

Persistent namespace for change tracking. Keep the same value for the same storefront URLs. Use another value for an independent monitor or schedule.

## `onlyChangesSince` (type: `string`):

Optional ISO 8601 timestamp such as 2026-08-01T00:00:00.000Z. When set, the dataset contains only new, updated, or removed products detected since that time. The first run creates the baseline.

## `requestDelayMillis` (type: `integer`):

Optional delay between storefronts. Usually unnecessary because the Actor already retries temporary upstream errors with backoff.

## `useApifyProxy` (type: `boolean`):

Use Apify Proxy only as a fallback for a storefront that rejects the direct request. Public Ecwid storefront endpoints normally work without a proxy.

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

Optional proxy configuration used only when Use Apify Proxy is enabled.

## Actor input object example

```json
{
  "storefrontUrls": [
    "https://ourlittlecraft.co.uk/"
  ],
  "maxProducts": 1,
  "monitorId": "default",
  "requestDelayMillis": 0,
  "useApifyProxy": false
}
```

# Actor output Schema

## `results` (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 = {
    "storefrontUrls": [
        "https://ourlittlecraft.co.uk/"
    ],
    "maxProducts": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("clintsa/ecwid-product-catalog-extractor").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 = {
    "storefrontUrls": ["https://ourlittlecraft.co.uk/"],
    "maxProducts": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("clintsa/ecwid-product-catalog-extractor").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 '{
  "storefrontUrls": [
    "https://ourlittlecraft.co.uk/"
  ],
  "maxProducts": 1
}' |
apify call clintsa/ecwid-product-catalog-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,clintsa/ecwid-product-catalog-extractor"
        }
    }
}

```

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/t0Yni6a4Y9zzzfzMj/builds/936SkjQzrisTc4uUN/openapi.json