# E commerce Scraping Tool Api (`insights_data/e-commerce-scraping-tool-api`) Actor

Scrape product data from Shopify, WooCommerce and any schema.org store. Get prices, discounts, live stock, variants, GTIN, ratings, images and seller info as JSON. Paste a store, category or product URL, add keywords, filter in stock or on sale. No API key or login.

- **URL**: https://apify.com/insights_data/e-commerce-scraping-tool-api.md
- **Developed by:** [Insights Data](https://apify.com/insights_data) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

### 🛒 What is E commerce Scraping Tool Api?

**E commerce Scraping Tool Api** helps e-commerce managers, brands, dropshippers and pricing teams run competitor price monitoring, stock tracking and ecommerce market research on Shopify, WooCommerce and other stores that publish schema.org product data. Paste a store, category or product link, click **Start**, and get each product's price, discount, stock status, variants, SKU, GTIN, rating, images and seller as a clean table, with no coding.

It is an ecommerce scraping tool for people who need product data in a spreadsheet or an app, not a coding project. The Apify Free plan's $5 monthly credit covers small test runs, and Free-plan runs work exactly like paid runs.

- 👀 **Competitor price monitoring:** see the current price, the original price and the discount of every product in a competitor's store or category.
- 📦 **Stock tracking:** check which products and variants are in stock, out of stock, on backorder or on preorder.
- 🔥 **Sale tracking:** keep only discounted products with the "On sale only" filter, with the discount % worked out for you.
- ⚖️ **Minimum advertised price monitoring:** brands can scrape their resellers' stores and compare each `price` with their own minimum price (for resellers on Shopify, WooCommerce or schema.org stores without bot protection).
- 🧭 **Dropshipping product research:** pull whole catalogs or keyword searches with prices, variants, images, ratings and review counts.
- 🗂️ **Product assortment analysis:** compare categories, brands, tags and price ranges across stores for ecommerce competitor analysis.

#### What can E commerce Scraping Tool Api do?

- 🌐 **Works on three store types:** it recognizes Shopify stores, WooCommerce stores and other stores that publish schema.org product data (standard product details that many stores add to their pages for search engines), and picks the right way to read each one. Stores with bot protection return no products, so results depend on the store.
- 🔗 **Starts from a store, category or product link:** a store home page gives the catalog, a collection or category page gives that category, and a product page gives one product.
- 🔍 **Searches inside each store:** add keywords and get only the products whose name, brand, type or URL name contain every word.
- 🎯 **Filters results:** all products, only in-stock products, or only products on sale.
- 🎨 **Returns variant data:** options such as size and color, each with its own price, SKU, GTIN, availability and stock count where the store shows them.
- ⚡ **Saves products as it goes:** each product appears in the dataset as soon as it is ready, so you can watch results while the run is going.
- 💾 **Exports anywhere:** download JSON, CSV, Excel, XML or HTML, or use the API, schedules, webhooks and integrations of the Apify platform.

***

### 📊 What data can E commerce Scraping Tool Api extract?

Each product is one dataset row with up to 30 fields. This makes it a practical ecommerce data scraper for pricing, stock and catalog work. As an ecommerce product scraper it returns the same fields for every store type, so rows from different stores fit in one table.

| Field | What it contains |
|---|---|
| 🔗 `url` | Product page URL |
| 🛍️ `name` | Product name |
| 🏭 `brand` | Brand or vendor |
| 🆔 `product_id`, `sku`, `mpn` | Store product ID, SKU (the store's own item code), MPN (the manufacturer's part number) |
| 🔖 `gtin` | GTIN: the number under the barcode (EAN, UPC or ISBN) |
| 🗂️ `category`, `tags` | Product category or breadcrumb, product tags |
| 📝 `description` | Product description as plain text |
| 🏷️ `price`, `currency`, `price_min`, `price_max` | Current selling price, ISO currency code, lowest and highest variant price |
| 🔥 `original_price`, `discount_pct`, `on_sale` | Price before discount, discount in % (one decimal), sale flag |
| 📦 `availability`, `stock_quantity` | `in_stock`, `out_of_stock`, `backorder` or `preorder`; total stock units when the store shows counts |
| ♻️ `condition` | `new`, `used`, `refurbished` or `damaged` |
| ⭐ `rating`, `review_count` | Average customer rating and number of reviews |
| 🎨 `variants` | List of variants with `title`, `sku`, `gtin`, `price`, `original_price`, `available`, `stock_quantity` and `options` |
| 📸 `images` | Product image URLs |
| 👤 `seller` | Seller name |
| 🚚 `shipping` | Shipping `cost`, `currency`, `country`, `days_min` and `days_max` |
| 📅 `published_at`, `updated_at` | Publication and last update date (Shopify) |
| 🌐 `platform`, `store` | `shopify`, `woocommerce` or `generic`; store hostname without "www." |

For Shopify and WooCommerce stores, `original_price` is only filled when it is higher than `price`. For other stores, it is the list price exactly as the product page shows it, so it can also be equal to `price`. `on_sale` is `true` only when `original_price` is higher than `price`, `false` otherwise, and empty when the price is unknown. `discount_pct` is only filled when the product is on sale.

#### Which fields does each store type fill?

Stores publish different data, so some fields stay empty (`null`) on some stores. This is what to expect:

| Field group | Shopify scraper | WooCommerce scraper | Other stores |
|---|---|---|---|
| 🛍️ Name, brand, category, price, currency, availability, SKU, images | Yes | Yes | When the product page publishes them |
| 🗂️ Tags | Yes | Yes | No |
| 📅 `published_at`, `updated_at` | Yes | No | No |
| 🎨 Variants | Yes | Only with extra details on | When the product page publishes them |
| 📦 `stock_quantity` | Only when the store shows stock counts | Only when the store shows a low-stock count or a count for every variant | No |
| 🔖 GTIN | When the store publishes it | No | When the product page publishes it |
| ⭐ Rating and review count | With extra details on, when the product page shows them | Yes, when the store shows them | When the product page publishes them |
| 🚚 Seller, shipping, condition, MPN | With extra details on, when the product page shows them | No | When the product page publishes them |

> **Note:** many stores hide exact stock counts, so `stock_quantity` is often empty even when `availability` is filled.

#### What data can't E commerce Scraping Tool Api extract?

- 🚫 Price history: each run is a snapshot of today's prices. Schedule runs and compare them to build your own history (see the schedule recipe below).
- 🚫 Review texts: you get the rating and the number of reviews, not the reviews themselves. For Flipkart review texts, use [Flipkart Reviews Scraper](https://apify.com/insights_data/flipkart-reviews-scraper).
- 🚫 Stores with bot protection or a CAPTCHA page. They are reported as blocked and return no products.
- 🚫 Stores that build their pages with JavaScript only and publish no schema.org product data.
- 🚫 Data behind a login. The Actor reads public pages only, so no login is needed.
- 🚫 Big marketplaces. For Amazon, use [Amazon Product Scraper](https://apify.com/insights_data/amazon-product-scraper).

***

### 🚀 How to scrape ecommerce website products in 5 steps

E commerce Scraping Tool Api is designed for an easy start, even if you have never extracted data from the web before. It works as a Shopify store scraper, a WooCommerce scraper and a reader for other schema.org stores, all from one form.

1. [Create a free Apify account](https://console.apify.com/sign-up) with your email.
2. Open [E commerce Scraping Tool Api](https://apify.com/insights_data/e-commerce-scraping-tool-api) and click **Try for free**.
3. In **Store, category or product URLs**, paste a store home page, a category page or a product page. The form starts with an example category link and **Max products per URL** set to 10, which is a good first test.
4. Click **Start**. Products appear in the **Output** tab while the run is going.
5. Download your data in JSON, CSV, Excel, XML or HTML.

For your first run, keep the prefilled example and just click **Start**: it is a small test run of 10 products, so you see the output and the cost before you scrape your own stores.

***

### 💲 E-commerce scraping tool pricing: how much does it cost?

E commerce Scraping Tool Api uses **pay-per-event** pricing. You only pay a result charge for products that are saved to your dataset. Your bill has three parts:

1. 💲 **Results:** one charge per product saved. The price depends on your Apify plan (table below).
2. ▶️ **Start fee:** $0.00005 per run at the default 1 GB of memory. It is charged per GB of run memory, so it goes up only if you raise the memory.
3. ⚙️ **Platform usage:** the compute and proxy resources the run uses, billed to your Apify account.

| Apify plan | Price per product | Price per 1,000 products |
|---|---|---|
| 💲 Free | $0.0015 | $1.50 |
| 💲 Starter | $0.00135 | $1.35 |
| 💲 Scale | $0.0012 | $1.20 |
| 💲 Business and higher | $0.001 | $1.00 |

The plan discount applies to the result price only. The start fee is the same on every plan, and platform usage is billed at your Apify plan's own rates.

**Examples (result charges and start fee):**

- The example input (10 products) on the Free plan: 10 × $0.0015 = $0.015, plus the $0.00005 start fee, plus platform usage.
- 1,000 products: $1.50 on Free, $1.35 on Starter, $1.20 on Scale, $1.00 on Business, plus the start fee and platform usage.

Platform usage depends on the store, the number of pages and whether extra details are on. To see your real cost, do a small test run (for example 10 products) and read the cost on the run page, then scale up.

What is billed: only products saved to the dataset. A link that is blocked, empty or not found adds no result charge. The same product found by two different keywords or two start links is saved twice and billed twice (see Tips).

See the [pricing tab](https://apify.com/insights_data/e-commerce-scraping-tool-api/pricing) for the live prices.

#### Is E commerce Scraping Tool Api free?

You can start for free. The [Apify Free plan](https://apify.com/pricing) gives you $5 in monthly credit, which pays for the result charges, the start fee and platform usage. Free-plan runs work the same as paid runs: there is no extra cap on the number of products.

#### How do I cap the cost of a run?

Set a **maximum charge limit** in the run options when you start a run. It caps the result charges, with platform usage on top. When the limit is reached, the Actor stops cleanly and keeps every product saved so far. You can also keep runs small with a low product limit per link.

***

### ⬇️ E-commerce scraping tool input

You only need one thing: at least one link in **Store, category or product URLs**. Everything else is optional and has a sensible default.

#### Settings most people change

| Setting (API name) | What it does | Default |
|---|---|---|
| 🔗 Store, category or product URLs (`startUrls`) | The links to scrape. Required. A bare domain like `shop.com` works too. | Example category link |
| 🔍 Search keywords (`searchTerms`) | Words to search for inside each store. Empty = the whole store or category. | Empty |
| 🎯 Result filter (`filter`) | All products, In stock only, or On sale only (`all`, `in_stock`, `on_sale`). | All products |
| 🔢 Max products per URL (`maxItems`) | Most products per link, or per link and keyword when you search. 0 = no limit of your own (the built-in caps in Tips still apply). | The form starts at 10. If you call the API without `maxItems`, it is 0 (no limit of your own). |
| 🧩 Fetch extra product details (`includeDetails`) | Extra data per product: stock counts, GTINs, ratings, shipping, and variants for WooCommerce. | On |
| 🛡️ Proxy configuration (`proxyConfiguration`) | Apify Proxy settings (a proxy sends requests through other IP addresses). The Actor manages its own Apify Proxy connection, so leave it as it is. | Apify Proxy on |

Here's an example that gets 10 products from a Shopify category with all extra details:

```json
{
  "startUrls": [
    "https://www.allbirds.com/collections/mens-sneakers"
  ],
  "maxItems": 10,
  "filter": "all",
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

See the [input tab](https://apify.com/insights_data/e-commerce-scraping-tool-api/input-schema) for the full description of every field.

#### Store, category or product URLs

The kind of page you paste sets the scope of the run:

- **Store home page:** the store's catalog on Shopify and WooCommerce stores; on other stores, the products the Actor can find from the home page. To scrape Shopify stores in full, paste the home page and set **Max products per URL** to 0.
- **Collection or category page:** only the products in that category.
- **Product page:** exactly one product. This is the quickest way to use it as a Shopify product scraper for a fixed list of products.

`https://` is added when it is missing, and duplicate links are removed.

- ✅ Good: `https://www.allbirds.com/collections/mens-sneakers`
- ❌ Bad: a marketplace search page behind bot protection

#### Search keywords

Each keyword runs as its own search in every store or category link. A product matches when **every word** appears in its name, brand, product type or URL name. Letter case and a simple plural "s" don't matter, so `wool runners` also finds "Wool Runner".

- ✅ Good: `wool runner`
- ❌ Bad: `cheap comfy running shoes for men` (every one of these words must match, so you get few or no products)

> ⚠️ Search keywords are ignored for product links, because a product link is already one product.

#### Max products per URL

The limit counts per link, and per link and keyword when you search. It counts products after the filter, so with **On sale only** you get up to 10 discounted products, not 10 products checked.

- ✅ Good: `10` for a quick test, `0` for the full catalog
- ❌ Bad: expecting 10 products in total from 3 links and 2 keywords (that run can return up to 60)

> ⚠️ With 0 the whole store or category is scraped and every product is billed. Use a maximum charge limit for big stores.

#### Fetch extra product details

On by default. It adds stock counts, GTINs, ratings, review counts, seller, shipping and condition for Shopify stores, and the variant list for WooCommerce stores. Turn it off when you only need listing data such as names and prices; the run is faster and the price per product stays the same. It has no effect on other stores.

#### Proxy configuration

Leave it as it is. The Actor manages its own Apify Proxy connection whether this switch is on or off, and the other proxy options or country you pick here are not applied. Proxy traffic is part of platform usage.

***

### ⬆️ E-commerce scraping tool output

Results are saved to a dataset (the table of results that belongs to each run). Open the run's **Output** tab to see them as a table, with four views:

- **Overview:** URL, product, brand, price, currency, on sale, discount %, availability, platform, store
- **Pricing:** price, currency, original price, discount %, on sale, lowest and highest variant price
- **Inventory:** availability, stock quantity, condition, platform, store
- **Details:** rating, reviews, category, tags, description

To download everything, go to **Storage → Datasets**, open the dataset, click **Export** and pick JSON, CSV, Excel, XML or HTML.

Run totals are saved as `RUN_SUMMARY` in the run's key-value store, a small file store that belongs to each run (open the run, then **Storage → Key-value stores → RUN_SUMMARY**): `totalItems`, `requests`, `failedRequests`, `durationSecs` and `status`. The status message at the top of the run page also says how many products were saved, or that a store blocked the run.

| `status` | What it means | What to do |
|---|---|---|
| 🟢 `ok` | Products were saved, and no link was blocked or failed. Some links may still have found nothing. | Nothing. Download or schedule the run. |
| 🟡 `partial` | Some links saved products while at least one was blocked or failed, or the run stopped before every link finished (then it can have 0 products). | Check which store is missing in the dataset (`store` field). Try another page of that store, or run it again later. |
| ⚪ `empty` | No products, and no link was blocked or failed: nothing matched the keywords or filter, or the pages had no products or don't exist. | Use fewer or shorter keywords, set **Result filter** to All products, or check that the link opens a store, category or product page. |
| 🔴 `blocked` | No products, and at least one store blocked automated access. | Try a different page of the same store, or try again later. Some stores can't be scraped. |
| ⛔ `failed` | No products, at least one link failed with an error (for example the store could not be reached), and none was blocked. | Check the links in a browser, then run again. If it keeps failing, open an issue with the link (see Support). |

#### JSON example

**Example row** for the input example above. It shows the format only: the values are an illustration, not a recorded run, and long values are shortened with "…". On a real run, fields such as `rating`, `stock_quantity` and `seller` are filled when the store's pages show them.

```json
{
  "url": "https://www.allbirds.com/products/mens-tree-runners",
  "name": "Men's Tree Runners",
  "brand": "Allbirds",
  "product_id": "1234567890",
  "sku": "TR-M-WHITE-10",
  "gtin": null,
  "mpn": null,
  "category": "Shoes",
  "tags": ["mens", "sneakers"],
  "description": "A breathable everyday sneaker…",
  "price": 98.0,
  "currency": "USD",
  "original_price": null,
  "discount_pct": null,
  "on_sale": false,
  "price_min": 98.0,
  "price_max": 98.0,
  "availability": "in_stock",
  "stock_quantity": null,
  "condition": null,
  "rating": null,
  "review_count": null,
  "variants": [
    {
      "title": "White / 10",
      "sku": "TR-M-WHITE-10",
      "gtin": null,
      "price": 98.0,
      "original_price": null,
      "available": true,
      "stock_quantity": null,
      "options": { "Color": "White", "Size": "10" }
    }
  ],
  "images": ["https://www.allbirds.com/cdn/shop/files/…"],
  "seller": null,
  "shipping": null,
  "published_at": "2024-01-15T10:00:00-08:00",
  "updated_at": "2026-11-01T09:30:00-07:00",
  "platform": "shopify",
  "store": "allbirds.com"
}
```

Fields such as `gtin`, `rating`, `stock_quantity` and `shipping` are filled when the store publishes them, and stay `null` otherwise.

***

### 💡 Tips and advanced usage

#### How many results can you scrape with E commerce Scraping Tool Api?

There is no fixed limit on the total number of products in a run. **Max products per URL** sets your own limit per link (0 = no limit of your own), and these built-in caps apply to every run:

- 💡 Each link (or link and keyword search) checks at most 50,000 products, then stops with what it found.
- 💡 For stores that are not Shopify or WooCommerce, at most 100 listing pages are read per start link.
- 💡 For WooCommerce, at most 100 variants per product are returned.

The real number depends on the store type, whether the store publishes product data, whether it has bot protection, and your keywords and filter. Start with a test run of 10 products.

#### How to get faster or cheaper results

- 💡 Keep the product limit small while you test, then raise it.
- 💡 Need only a product price scraper? Turn off **Fetch extra product details**. Runs on Shopify and WooCommerce stores get faster, and the price per product stays the same.
- 💡 Use **On sale only** or **In stock only** so you only pay for the products you need.
- 💡 Paste category pages instead of the home page when you only follow one part of a store.
- 💡 For big ecommerce product data scraping jobs, set a maximum charge limit in the run options.

#### Run it on a schedule: a daily competitor price check

This recipe turns the Actor into an ecommerce price scraper that runs by itself, for ecommerce price monitoring without manual work:

1. Fill the input with your competitors' category links, for example `https://www.allbirds.com/collections/mens-sneakers`, keep **Result filter** on All products and set **Max products per URL** to the size of the category (or 0).
2. Do a small test run first, then set a **maximum charge limit** in the task's run options, so a big category can't cost more than you planned.
3. Click **Save as new task** and give it a name such as "Competitor sneakers daily".
4. In Apify Console, open **Schedules**, create a schedule (for example every day at 7:00) and add the task. See [Apify schedules](https://docs.apify.com/platform/schedules).
5. Each run creates a new dataset. Compare runs by `url`: changes in `price`, `on_sale` and `availability` show price drops, new sales and stock-outs.

The Actor doesn't compare runs for you; each run is a fresh snapshot. Sending each run to Google Sheets (below) gives you a running log for competitor price tracking.

#### Known issues

- ⚠️ Stores with bot protection or CAPTCHA pages are reported as blocked and return no products. Try again later, or try a different page of the same store.
- ⚠️ Stores that show products only with JavaScript and publish no schema.org product data return no products.
- ⚠️ The same product can appear more than once when several keywords or several start links find it. Remove duplicates by `url` after the run.
- ⚠️ `stock_quantity` is often empty because many stores hide exact counts.

***

### 🔌 Integrations and API

#### Can I use E commerce Scraping Tool Api as an ecommerce scraper API?

Yes. The [Apify API](https://docs.apify.com/api/v2) lets you start runs, wait for them and fetch the products from any app. Use the `apify-client` [NPM package](https://apify.com/insights_data/e-commerce-scraping-tool-api/api/javascript) for Node.js or the `apify-client` [PyPI package](https://apify.com/insights_data/e-commerce-scraping-tool-api/api/python) for Python. The [API tab](https://apify.com/insights_data/e-commerce-scraping-tool-api/api) has ready-to-copy code. The Actor ID is `insights_data/e-commerce-scraping-tool-api`.

You can also call it as an ecommerce scraping API over plain HTTP, and read only one view of the results, for example `?view=pricing` on the dataset items endpoint.

#### Shopify scraper Python example

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run_input = {
    "startUrls": ["https://www.allbirds.com/collections/mens-sneakers"],
    "maxItems": 10,
    "filter": "all",
    "includeDetails": True,
    "proxyConfiguration": {"useApifyProxy": True},
}

run = client.actor("insights_data/e-commerce-scraping-tool-api").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item["price"], item["currency"], item["availability"])
```

#### Can I use it as a price monitoring API?

Yes. Save your competitor links as a task, start the task from your own code or a schedule, and read `price`, `original_price`, `on_sale` and `availability` from the dataset. Your system stores the history and sends the alerts.

#### Can I integrate E commerce Scraping Tool Api with other apps?

Yes. Connect it with almost any cloud service through [Apify integrations](https://apify.com/integrations): Make, Zapier, n8n, Slack, Google Sheets, Google Drive, Airbyte, GitHub, LangChain and more. Use [webhooks](https://docs.apify.com/integrations/webhooks) (a message Apify sends to another app when a run finishes) to start an action automatically. Two workflows that fit this Actor:

1. **Price log in Google Sheets:** add the Google Sheets integration to your scheduled task and append `name`, `price`, `original_price`, `on_sale`, `availability` and `store` after each run. Each run adds today's prices under yesterday's.
2. **Stock-out alerts in Slack:** add a webhook for "run succeeded" that starts a Make, Zapier or n8n scenario. The scenario reads the dataset, keeps rows where `availability` is `out_of_stock`, and posts them to a Slack channel. This turns the Actor into an out of stock tracker for the products you follow.

#### Can I use E commerce Scraping Tool Api with AI agents (MCP)?

Yes. MCP (Model Context Protocol) is a standard way for AI assistants to use tools. Connect it to Claude and other AI assistants through the Apify MCP server, then ask in plain words, for example "get the in-stock products from this store category". Open the [MCP tab](https://apify.com/insights_data/e-commerce-scraping-tool-api/api/mcp) for the setup steps.

***

### 🧰 Other ecommerce scrapers

These Actors from the same team cover marketplaces, product reviews and competitor ads:

- 🛒 [Amazon Product Scraper](https://apify.com/insights_data/amazon-product-scraper): Amazon products from URLs, keywords or ASINs across 23 marketplaces, with price, Buy Box seller, stock, rating, Best Sellers Rank and a monitor mode for price and stock changes.
- 🛒 [AliExpress Products Scraper](https://apify.com/insights_data/aliexpress-products-scraper): AliExpress products by keyword or category link, with price, discount, rating, sold count, shipping and delivery.
- 🛒 [Flipkart Product Scraper](https://apify.com/insights_data/flipkart-product-scraper): Flipkart products by keyword or category URL, with prices, discounts, ratings, specs, sellers and offers.
- 🛒 [Taobao 淘宝 & Tmall 天猫 Product Scraper - USD & Reviews](https://apify.com/insights_data/taobao-tmall-product-scraper): Taobao and Tmall products with English titles, CNY and USD prices, shop details and sample reviews.
- 💬 [Flipkart Reviews Scraper](https://apify.com/insights_data/flipkart-reviews-scraper): Flipkart product reviews, star ratings, photos and rating summaries.
- 📣 [Google Ads Transparency Center Scraper & API](https://apify.com/insights_data/google-ads-transparency-center-scraper-api): the ads a competitor brand or domain runs across Search, YouTube, Shopping, Maps and Play.

***

### ❓ FAQ

#### Is it legal to scrape ecommerce websites?

Scraping public product pages is generally legal, but you are responsible for how you use the data. Ecommerce data scraping of prices, stock and product details usually involves no personal data. Still, respect each store's terms of service and intellectual property such as product photos and descriptions, and only collect personal data (for example a seller's name) when you have a legitimate reason under laws like the GDPR. This is not legal advice; ask a lawyer if you are unsure.

#### How does E commerce Scraping Tool Api work?

It works like a person browsing the store, only faster. For each link it first checks what kind of store it is (Shopify, WooCommerce or other). Then it reads the catalog, category or product, keeps the products that match your keywords and filter, adds extra details if they are on, and saves each product as one row. At the end it writes the run summary. Because it reads the public pages of the store, this ecommerce web scraper needs no login and no API key.

#### Why scrape ecommerce data?

- **Pricing:** follow competitor prices and discounts without checking stores by hand.
- **Stock:** see when products or sizes sell out or come back.
- **Brand protection:** check resellers against your minimum advertised price.
- **Product research:** find products, price ranges and variants for dropshipping or sourcing.
- **Market research:** compare assortments, brands and categories across stores.
- **Catalog data:** collect SKU, GTIN, MPN, images and descriptions to build a product catalog or feed.

#### How to scrape Shopify store data?

Paste the store's home page, a collection page or a product page into the first field and click **Start**. The Actor recognizes Shopify stores by itself, so you don't need a separate product scraper for each store type. For Shopify competitor research, paste the collections you compete in and add keywords such as `wool runner` to focus on one product line.

#### Can I scrape WooCommerce products?

Yes. Paste a WooCommerce store, product category or product link, and the Actor works as a WooCommerce product scraper with name, brand, category, tags, description, prices, availability, SKU, images and rating. Keep extra details on to scrape WooCommerce products with their variants.

#### How do I export Shopify products to CSV?

Run the Actor on the store or collection, then go to **Storage → Datasets**, open the dataset, click **Export** and pick CSV (or Excel). Each product is one row.

#### How to scrape product data from a website without coding?

Use this Actor in Apify Console: paste the link, choose how many products you want, click **Start** and download the table. Product data extraction works on most Shopify and WooCommerce stores and on stores that publish schema.org product data on their product pages, unless the store has bot protection. Results depend on the store, so test with 10 products first.

#### Can I scrape prices from websites that don't use Shopify or WooCommerce?

Yes, when the store publishes schema.org product data on its product pages. Paste a product or category page; the `platform` field then shows `generic`. Stores that show prices only with JavaScript and publish no product data return no products.

#### How is a listing-only run different from a full-details run?

The only switch is **Fetch extra product details**. It changes what you get from Shopify and WooCommerce stores, not the price per product:

| What changes | Extra details on (default) | Extra details off |
|---|---|---|
| ⭐ Shopify rating, review count, seller, shipping, condition, MPN | When the product page shows them | Not collected |
| 🔖 Shopify stock counts and GTINs | When the store publishes them | Only when the store's listing includes them |
| 🎨 WooCommerce variants | Yes | Not collected |
| ⏱️ Speed | Slower | Faster |
| 💲 Price per product | Same | Same |

Other stores give the same data either way.

#### Why am I getting fewer results than expected?

- **Max products per URL** is set low (the form starts at 10).
- Your keywords are too narrow: every word must match. Try one or two words.
- The **In stock only** or **On sale only** filter removes products.
- The store blocked automated access (`status` is `blocked` or `partial` in `RUN_SUMMARY`), or it publishes no product data.
- Keywords were added to a product link, where they are ignored.

#### Who is E commerce Scraping Tool Api for?

E-commerce managers, pricing analysts, brand managers, dropshippers, market researchers and developers. An ecommerce data analyst can use it to feed a price dashboard: one scheduled task per competitor, exported to Google Sheets or a database.

***

### 📧 Support and feedback

Found a bug or have a feature request? Please create an issue on the [Issues tab](https://apify.com/insights_data/e-commerce-scraping-tool-api/issues/open). Include the store link and what you expected to see.

Need a **custom solution**, another store type, or more data? Contact us at hello.insights.data@gmail.com.

Built and maintained by [Insights Data](https://apify.com/insights_data).

# Actor input Schema

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

Links to scrape — a store home, a collection/category page, or a direct product URL. A bare domain like "shop.com" is accepted.

## `searchTerms` (type: `array`):

Keywords to search inside each store. A product matches when every word appears in its name, brand, type or handle. Leave empty to scrape the full store or category.

## `filter` (type: `string`):

Keep all products, only those in stock, or only discounted ones (original price above current price).

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

Maximum number of products to return per URL (per keyword when searching). Set to 0 for no limit.

## `includeDetails` (type: `boolean`):

Retrieve additional data per product: stock counts, GTINs, ratings, and shipping info. Recommended — disable only if you need raw listing data faster.

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

Proxy settings for the scraper. Apify Proxy is recommended for stores that rate-limit direct requests.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.allbirds.com/collections/mens-sneakers"
  ],
  "filter": "all",
  "maxItems": 10,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `pricing` (type: `string`):

No description

## `inventory` (type: `string`):

No description

## `details` (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": [
        "https://www.allbirds.com/collections/mens-sneakers"
    ],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("insights_data/e-commerce-scraping-tool-api").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://www.allbirds.com/collections/mens-sneakers"],
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("insights_data/e-commerce-scraping-tool-api").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://www.allbirds.com/collections/mens-sneakers"
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call insights_data/e-commerce-scraping-tool-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,insights_data/e-commerce-scraping-tool-api"
        }
    }
}
```

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/nXcvkIyyIwFcMwqyn/builds/3zCpwvf1xnPap4C1J/openapi.json