# E-commerce Scraper Pro: Multi Marketplace Product Intelligence (`scrapemint/ecommerce-scraper`) Actor

Scrape products from 14+ marketplaces (Amazon, Walmart, Target, eBay, Etsy, AliExpress, Best Buy, IKEA, Zalando, ASOS, Shopify). Pricing, stock, variants, images, ratings, AI summaries. Auto detects retailer. JSON-LD fallback covers any storefront. Pay per row.

- **URL**: https://apify.com/scrapemint/ecommerce-scraper.md
- **Developed by:** [Kennedy Mutisya](https://apify.com/scrapemint) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## E-commerce Scraper Pro: Multi Marketplace Product Intelligence

Scrape products across Amazon, Walmart, Target, eBay, Etsy, AliExpress, Best Buy, Costco, Wayfair, Home Depot, IKEA, Zalando, ASOS, plus any Shopify, WooCommerce, BigCommerce, Magento, or Salesforce Commerce storefront. Each row ships pricing, stock, ratings, variants, images, specs, shipping, seller, and optional AI generated pros and cons. Auto detects the retailer. JSON-LD primary parser covers any storefront with Schema.org Product data. Pay per row.

**Built for** price intelligence teams tracking competitor catalogs, dropshippers sourcing winning products, brand managers watching MAP violations across resellers, BI teams piping retail catalogs into a warehouse, content teams powering shopping guides with structured data, lead gen platforms enriching company records with retailer signals, and AI builders training product recommenders on a clean cross marketplace dataset.

**Keywords this actor ranks for:** ecommerce scraper, product scraper, amazon scraper, walmart scraper, target scraper, ebay scraper, etsy scraper, aliexpress scraper, best buy scraper, ikea scraper, shopify scraper, woocommerce scraper, bigcommerce scraper, product data api, ecommerce data extractor, jsonld product scraper, retail price tracker, MAP monitoring, product catalog to JSON, product catalog to CSV.

---

### Why this actor

| Other product scrapers | **This actor** |
|---|---|
| One marketplace only | Fourteen built in marketplaces plus a JSON-LD fallback that covers any Schema.org storefront |
| Title and price only | Full enrichment: variants, specs, images, shipping, seller, breadcrumbs, ratings histogram |
| Returns broken price strings | Prices normalized to `{ value, currency }` from JSON-LD or meta tags |
| No deduplication | Per product ID dedupe across runs, persisted in a key value store |
| Hard coded selectors that break monthly | JSON-LD primary path with selector fallbacks for fields not in structured data |
| No AI layer | Optional GPT generated pros, cons, target audience, and value rating per row |
| Single category at a time | Mix product URLs, category URLs, and keyword search across 18 marketplace endpoints in one run |
| No bot evasion | Apify residential proxy, Chrome fingerprinting, session pool with cookie persistence |

---

### How it works

```mermaid
flowchart LR
    A[Product URLs<br/>Category URLs<br/>Keyword + marketplaces] --> B[URL parser<br/>route to handler]
    B --> C[Listing crawl<br/>extract product cards]
    B --> D[Detail page<br/>Playwright or Cheerio]
    C --> D
    D --> E[JSON-LD parser<br/>+ DOM selectors]
    E --> F[Pricing variants images<br/>ratings specs shipping]
    F --> G{AI summary?}
    G -->|yes| H[OpenAI<br/>pros cons fit]
    G -->|no| I[Skip]
    H --> J[One row per product]
    I --> J
    J --> K[(JSON CSV API)]
````

Detail pages render with Playwright behind rotating residential proxy and browser fingerprinting. JSON-LD `Product` blocks are the primary source for title, price, brand, SKU, GTIN, rating, and review count. DOM selectors fill in fields not in structured data (variants, specs tables, shipping, Q\&A, ratings histogram). Cheerio mode is available for static storefronts (Shopify, WooCommerce, BigCommerce) when speed matters more than coverage.

***

### What you get per row

```mermaid
flowchart LR
    R[Product row] --> R1[Identity<br/>productId marketplace url]
    R --> R2[Title brand SKU GTIN]
    R --> R3[Price + originalPrice<br/>currency normalized]
    R --> R4[Availability<br/>in stock out of stock preorder]
    R --> R5[Rating<br/>stars reviewCount histogram questions]
    R --> R6[Description + bullets]
    R --> R7[Specs + variants<br/>images shipping seller]
    R --> R8[AI summary<br/>pros cons best for value rating]
```

Toggle `includeAdditionalProperties` for the rich enrichment fields. Toggle `aiSummaryDataPoints` for GPT generated buyer insights.

***

### Quick start

**Track a basket of Amazon, Walmart, and Target products**

```json
{
  "productUrls": [
    "https://www.amazon.com/dp/B0CHX1W1XY",
    "https://www.walmart.com/ip/Apple-AirPods-Pro-2nd-Gen/1810913013",
    "https://www.target.com/p/-/A-87852397"
  ],
  "extractImages": true,
  "extractVariants": true,
  "extractRatingHistogram": true
}
```

**Crawl an entire Best Buy category**

```json
{
  "categoryUrls": [
    "https://www.bestbuy.com/site/laptops/all-laptops/pcmcat138500050001.c"
  ],
  "totalMaxProducts": 100,
  "concurrency": 4
}
```

**Keyword search across multiple marketplaces in one run**

```json
{
  "keyword": "wireless earbuds",
  "marketplaces": ["amazon_us", "walmart_us", "target_us", "bestbuy_us"],
  "totalMaxProducts": 200
}
```

**Shopify or BigCommerce storefront with the cheerio fast path**

```json
{
  "scrapeMode": "cheerio",
  "categoryUrls": [
    "https://www.gymshark.com/collections/all-mens"
  ],
  "totalMaxProducts": 250
}
```

**Add AI summaries for buyer insights**

```json
{
  "productUrls": [
    "https://www.amazon.com/dp/B0CHX1W1XY",
    "https://www.amazon.com/dp/B0BDHWDR12"
  ],
  "aiSummaryDataPoints": ["pros", "cons", "best_for", "avoid_if", "value_rating"],
  "aiSummaryCustomPrompt": "Focus on long term durability and warranty terms."
}
```

The AI summary path requires an `OPENAI_API_KEY` environment variable on the actor run.

***

### Sample output

```json
{
  "productId": "B0CHX1W1XY",
  "marketplace": "amazon",
  "url": "https://www.amazon.com/dp/B0CHX1W1XY",
  "title": "Apple AirPods Pro (2nd Generation) Wireless Earbuds with USB-C",
  "brand": "Apple",
  "sku": "MTJV3AM/A",
  "gtin": "194253397717",
  "productType": "Product",
  "category": "Electronics",
  "breadcrumbs": ["Electronics", "Headphones", "Earbud Headphones"],
  "price": { "value": 189.99, "currency": "USD" },
  "originalPrice": { "value": 249.0, "currency": "USD" },
  "availability": "in_stock",
  "rating": {
    "stars": 4.7,
    "reviewCount": 84231,
    "histogram": { "5": 81, "4": 11, "3": 4, "2": 1, "1": 3 },
    "questionsCount": 1247
  },
  "description": "Active Noise Cancellation reduces unwanted background noise...",
  "bullets": [
    "RICHER AUDIO EXPERIENCE - Custom high excursion driver",
    "PERSONALIZED SPATIAL AUDIO with dynamic head tracking",
    "ACTIVE NOISE CANCELLATION reduces unwanted background noise"
  ],
  "specs": {
    "connectivity technology": "Wireless",
    "battery life": "Up to 6 hours",
    "form factor": "In Ear"
  },
  "variants": [
    { "value": "USB-C", "sku": "MTJV3AM/A" },
    { "value": "Lightning", "sku": "MQD83AM/A" }
  ],
  "images": [
    "https://m.media-amazon.com/images/I/61SUj2aKoEL.jpg",
    "https://m.media-amazon.com/images/I/71zny7BTRlL.jpg"
  ],
  "shipping": {
    "text": "FREE delivery Tomorrow",
    "freeShipping": true,
    "storePickup": false
  },
  "seller": "Amazon.com",
  "aiSummary": {
    "pros": [
      "Class leading active noise cancellation",
      "Rich, balanced sound with strong bass",
      "Excellent integration with Apple ecosystem",
      "USB-C charging case with MagSafe"
    ],
    "cons": [
      "Premium price vs competitors",
      "Limited customization on Android",
      "Ear tips can dislodge during workouts"
    ],
    "best_for": [
      "Apple ecosystem users",
      "Frequent travelers",
      "Podcast and audiobook listeners"
    ],
    "avoid_if": [
      "You use Android primarily",
      "You need an over ear form factor",
      "Budget under $150"
    ],
    "value_rating": {
      "score": 8,
      "reasoning": "Premium price justified by ANC quality and ecosystem integration."
    }
  },
  "scrapedAt": "2026-04-28T10:00:00.000Z"
}
```

***

### Who uses this

| Role | Use case |
|---|---|
| Price intelligence team | Track competitor catalogs daily across Amazon, Walmart, Target. One row per product per snapshot. |
| Dropshipper / reseller | Source winning products from AliExpress, scrape demand signals from Amazon and eBay. |
| Brand manager | MAP monitoring across reseller channels. Catch unauthorized discounting. |
| BI / data analyst | Pipe retail catalogs into Snowflake, BigQuery, or Postgres. Each row API ready. |
| Content team | Power shopping guides with structured product data: specs, ratings, images. |
| Lead gen platform | Enrich company records with retailer presence and product portfolio signals. |
| AI builder | Train product recommenders, search relevance models, or shopping assistants on a clean dataset. |
| Investor / analyst | Monitor SKU level demand at retail chains as a leading indicator. |

***

### Input reference

| Field | Type | What it does |
|---|---|---|
| `scrapeMode` | enum | auto, playwright, or cheerio. Auto picks per URL. |
| `productUrls` | string\[] | Direct product URLs across any supported marketplace or generic Schema.org storefront. |
| `categoryUrls` | string\[] | Category, search, brand, or seller URLs. The actor walks the listing, queues each product. |
| `keyword` | string | Search term applied across selected marketplaces. |
| `marketplaces` | string\[] | Which marketplaces to run the keyword search on. Eighteen endpoints supported. |
| `includeAdditionalProperties` | boolean | Variants, specs, ratings histogram, Q\&A, shipping. Off keeps rows lean. |
| `aiSummaryDataPoints` | string\[] | pros, cons, best\_for, avoid\_if, value\_rating, sentiment\_breakdown, feature\_highlights, comparison\_notes, buyer\_questions, fit\_recommendation. |
| `aiSummaryCustomPrompt` | string | Optional extra instruction passed to the summarizer. |
| `totalMaxProducts` | integer | Hard cap on rows pushed per run. 0 means unlimited. |
| `currency` | enum | Output currency normalization. Defaults to original. |
| `extractImages` | boolean | Pull primary plus gallery image URLs at original resolution. |
| `maxImagesPerProduct` | integer | Cap on image URLs per row. |
| `extractVariants` | boolean | Variant matrix with value and SKU. |
| `extractRatingHistogram` | boolean | Five star to one star percentage split. |
| `extractQuestionsCount` | boolean | Answered questions count where exposed. |
| `extractShippingInfo` | boolean | Free shipping flag, delivery estimate, store pickup. |
| `dedupe` | boolean | Skip product IDs from previous runs. |
| `concurrency` | integer | Parallel pages. Three to five is safe. |
| `proxyConfiguration` | object | Apify proxy. Residential is required for Amazon, Walmart, Target, AliExpress. |

***

### API call

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/YOUR_USER~ecommerce-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keyword": "standing desk",
    "marketplaces": ["amazon_us", "walmart_us", "wayfair_us"],
    "totalMaxProducts": 60,
    "extractVariants": true,
    "extractImages": true
  }'
```

***

### Pricing

The first few products per run are free so you can validate output before paying. After that, one charge per product row. Variants, specs, images, ratings histogram, and shipping info are all included at no extra cost. AI summary calls bill against your own OpenAI key.

***

### FAQ

#### What marketplaces are auto detected?

Amazon (US, UK, DE, FR, JP, IN), Walmart, Target, Best Buy, Costco, Wayfair, Home Depot, eBay, Etsy, AliExpress, IKEA, Zalando, ASOS. Any URL with a Schema.org `Product` JSON-LD block also works (Shopify, WooCommerce, BigCommerce, Magento, Salesforce Commerce, Squarespace, Wix).

#### How does the JSON-LD fallback work?

Most modern storefronts ship a `<script type="application/ld+json">` block with a `Product` schema. The actor parses every JSON-LD block on the page, picks the first `Product` (or `@graph` member), and maps name, brand, SKU, GTIN, image, description, offers, and aggregateRating directly. This is why coverage is so wide without per retailer code.

#### Why does Amazon block scrapers?

Amazon uses CAPTCHA, request rate analysis, and TLS fingerprinting. The actor uses fingerprinted Chrome with Apify residential proxy and per session cookie persistence. Most retries resolve within two attempts.

#### Cheerio versus Playwright?

Cheerio is raw HTTP, ten times faster, but only works on server rendered pages (Shopify, WooCommerce, most boutique storefronts). Playwright renders the page in a real Chromium and handles every retailer including JS heavy ones (Amazon, Walmart, Target). Use auto unless you have a preference.

#### Does it scrape reviews?

This actor focuses on product data with summary review fields (count, stars, histogram). For full review text with author and timestamps, use the related Amazon Review Intelligence actor.

#### Can I get only the price field?

Yes. Set `includeAdditionalProperties` false and `extractImages` false. The row stays lean: title, brand, price, availability, rating, url.

#### Does the AI summary work without an OpenAI key?

No. Set `OPENAI_API_KEY` as an environment variable on the actor run. Without it, AI fields are skipped and the rest of the row ships normally. Default model is `gpt-4o-mini`. Override with `OPENAI_MODEL` env if needed.

#### Can I scrape product variants with their own prices?

Yes. Toggle `extractVariants` and the row ships an array with each color, size, or style and its SKU. Per variant pricing is captured when the marketplace exposes it on the parent product page.

#### How accurate is the price field?

Prices come from JSON-LD `offers.price` first, then meta tags, then DOM selectors. Currency comes from `offers.priceCurrency`, then `meta[product:price:currency]`, then symbol detection. Sale price lands in `price`, list price in `originalPrice` when both are present.

#### Is ecommerce scraping legal?

This actor reads HTML any anonymous web visitor can see. Respect each retailer's terms and rate limit sensibly. Do not redistribute product images, descriptions, or reviews you have no lawful basis to publish.

***

### Related actors

- **Amazon Product Scraper**. Same shape, Amazon only, with deeper Amazon specific fields (BSR, A+ content, sponsored signals).
- **Amazon Review Intelligence**. Every review with author, rating, helpful votes, verified purchase, and timestamps.
- **Trustpilot Brand Reputation**. Cross brand reputation tracking with review intelligence.
- **Google Reviews Intelligence**. Local business reviews with sentiment.
- **Zillow Home Price Scraper**. Same shape applied to real estate listings.
- **Website Content Crawler**. Generic content crawl when you need raw HTML or text instead of structured product data.

# Actor input Schema

## `scrapeMode` (type: `string`):

Auto picks the fastest path per URL: Cheerio for static HTML pages, Playwright for JS heavy retailers (Amazon, Walmart, Target, AliExpress). Force one mode if you have a preference.

## `productUrls` (type: `array`):

Direct product page URLs. Mix any of the supported marketplaces (Amazon, Walmart, Target, eBay, Etsy, AliExpress, Best Buy, Costco, Wayfair, Home Depot, IKEA, Zalando, ASOS, Shopify). Unknown retailers fall back to JSON-LD.

## `categoryUrls` (type: `array`):

Category, search results, brand, or seller store URLs. The actor walks the listing, queues each product, and respects totalMaxProducts.

## `keyword` (type: `string`):

Search term applied across each selected marketplace. Pair with marketplaces below.

## `marketplaces` (type: `array`):

Which marketplaces to run the keyword search on. Independent searches per marketplace, results merged into one dataset.

## `includeAdditionalProperties` (type: `boolean`):

Pull extras when present: variant matrix, ratings histogram, Q\&A counts, shipping options, return policy summary, eco labels, certifications, dimensions and weight. Off keeps rows lean.

## `aiSummaryDataPoints` (type: `array`):

Generate per product AI summaries for the chosen aspects. Requires an OpenAI API key (set in run env). Skip for raw data only.

## `aiSummaryCustomPrompt` (type: `string`):

Optional extra instruction passed to the AI summarizer. Example: 'Only mention long term durability and warranty terms'.

## `totalMaxProducts` (type: `integer`):

Hard cap on rows pushed per run. 0 means unlimited.

## `searchEngine` (type: `string`):

When categoryUrls is empty and keyword is set on a marketplace without a built in search, fall back to a search engine to find product URLs. Use 'none' to disable.

## `searchEngineCountry` (type: `string`):

Country gl param. Affects which retailers Google or Bing surface.

## `searchEngineLanguage` (type: `string`):

Language hl param.

## `currency` (type: `string`):

Normalize all prices to this currency in the row. Conversion uses the most recent rate at scrape time.

## `extractImages` (type: `boolean`):

Pull primary plus gallery image URLs at original resolution.

## `maxImagesPerProduct` (type: `integer`):

Cap on image URLs returned. Set 0 for all.

## `extractVariants` (type: `boolean`):

When the product ships in sizes, colors, or styles, return every variant with its own price, stock, and SKU.

## `extractRatingHistogram` (type: `boolean`):

Pull the percentage split across 5, 4, 3, 2, 1 star reviews when the marketplace exposes it.

## `extractQuestionsCount` (type: `boolean`):

Pull the answered questions count when present (Amazon, Walmart, Best Buy).

## `extractShippingInfo` (type: `boolean`):

Free shipping flag, delivery estimate text, in store pickup options where applicable.

## `dedupe` (type: `boolean`):

Skip product IDs already pushed in previous runs. Turn off to refresh stale rows.

## `concurrency` (type: `integer`):

Number of pages processed in parallel. Three to five is safe across retailers.

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

Apify proxy. Residential is required for Amazon, Walmart, Target, AliExpress. Datacenter is fine for Shopify and most other retailers.

## Actor input object example

```json
{
  "scrapeMode": "auto",
  "productUrls": [],
  "categoryUrls": [],
  "keyword": "",
  "marketplaces": [],
  "includeAdditionalProperties": true,
  "aiSummaryDataPoints": [],
  "aiSummaryCustomPrompt": "",
  "totalMaxProducts": 25,
  "searchEngine": "none",
  "searchEngineCountry": "US",
  "searchEngineLanguage": "en",
  "currency": "original",
  "extractImages": true,
  "maxImagesPerProduct": 12,
  "extractVariants": true,
  "extractRatingHistogram": false,
  "extractQuestionsCount": false,
  "extractShippingInfo": true,
  "dedupe": true,
  "concurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/ecommerce-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 = { "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    } }

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/ecommerce-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapemint/ecommerce-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapemint/ecommerce-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "E-commerce Scraper Pro: Multi Marketplace Product Intelligence",
        "description": "Scrape products from 14+ marketplaces (Amazon, Walmart, Target, eBay, Etsy, AliExpress, Best Buy, IKEA, Zalando, ASOS, Shopify). Pricing, stock, variants, images, ratings, AI summaries. Auto detects retailer. JSON-LD fallback covers any storefront. Pay per row.",
        "version": "0.1",
        "x-build-id": "FHpnJQI9IrJoxkRry"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~ecommerce-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-ecommerce-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapemint~ecommerce-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-ecommerce-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapemint~ecommerce-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-ecommerce-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "scrapeMode": {
                        "title": "Scrape mode",
                        "enum": [
                            "auto",
                            "playwright",
                            "cheerio"
                        ],
                        "type": "string",
                        "description": "Auto picks the fastest path per URL: Cheerio for static HTML pages, Playwright for JS heavy retailers (Amazon, Walmart, Target, AliExpress). Force one mode if you have a preference.",
                        "default": "auto"
                    },
                    "productUrls": {
                        "title": "Product detail URLs",
                        "type": "array",
                        "description": "Direct product page URLs. Mix any of the supported marketplaces (Amazon, Walmart, Target, eBay, Etsy, AliExpress, Best Buy, Costco, Wayfair, Home Depot, IKEA, Zalando, ASOS, Shopify). Unknown retailers fall back to JSON-LD.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryUrls": {
                        "title": "Category listing URLs",
                        "type": "array",
                        "description": "Category, search results, brand, or seller store URLs. The actor walks the listing, queues each product, and respects totalMaxProducts.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "keyword": {
                        "title": "Keyword for search",
                        "type": "string",
                        "description": "Search term applied across each selected marketplace. Pair with marketplaces below.",
                        "default": ""
                    },
                    "marketplaces": {
                        "title": "Marketplaces for keyword search",
                        "type": "array",
                        "description": "Which marketplaces to run the keyword search on. Independent searches per marketplace, results merged into one dataset.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "amazon_us",
                                "amazon_uk",
                                "amazon_de",
                                "amazon_fr",
                                "amazon_jp",
                                "amazon_in",
                                "walmart_us",
                                "target_us",
                                "bestbuy_us",
                                "costco_us",
                                "wayfair_us",
                                "homedepot_us",
                                "ebay_us",
                                "etsy_us",
                                "aliexpress",
                                "ikea_us",
                                "zalando_de",
                                "asos_uk"
                            ],
                            "enumTitles": [
                                "Amazon (US)",
                                "Amazon (UK)",
                                "Amazon (DE)",
                                "Amazon (FR)",
                                "Amazon (JP)",
                                "Amazon (IN)",
                                "Walmart (US)",
                                "Target (US)",
                                "Best Buy (US)",
                                "Costco (US)",
                                "Wayfair (US)",
                                "Home Depot (US)",
                                "eBay (US)",
                                "Etsy (US)",
                                "AliExpress (Global)",
                                "IKEA (US)",
                                "Zalando (DE)",
                                "ASOS (UK)"
                            ]
                        },
                        "default": []
                    },
                    "includeAdditionalProperties": {
                        "title": "Include additional properties",
                        "type": "boolean",
                        "description": "Pull extras when present: variant matrix, ratings histogram, Q&A counts, shipping options, return policy summary, eco labels, certifications, dimensions and weight. Off keeps rows lean.",
                        "default": true
                    },
                    "aiSummaryDataPoints": {
                        "title": "AI summary - data points",
                        "type": "array",
                        "description": "Generate per product AI summaries for the chosen aspects. Requires an OpenAI API key (set in run env). Skip for raw data only.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "pros",
                                "cons",
                                "best_for",
                                "avoid_if",
                                "value_rating",
                                "sentiment_breakdown",
                                "feature_highlights",
                                "comparison_notes",
                                "buyer_questions",
                                "fit_recommendation"
                            ],
                            "enumTitles": [
                                "Pros (top positives)",
                                "Cons (top negatives)",
                                "Best for (target audience)",
                                "Avoid if (warning signals)",
                                "Value rating (price vs quality)",
                                "Sentiment breakdown (positive / neutral / negative)",
                                "Feature highlights (top features)",
                                "Comparison notes (vs alternatives)",
                                "Buyer questions (FAQs)",
                                "Fit recommendation (sizing or compatibility)"
                            ]
                        },
                        "default": []
                    },
                    "aiSummaryCustomPrompt": {
                        "title": "AI summary - custom prompt",
                        "type": "string",
                        "description": "Optional extra instruction passed to the AI summarizer. Example: 'Only mention long term durability and warranty terms'.",
                        "default": ""
                    },
                    "totalMaxProducts": {
                        "title": "Total maximum products",
                        "minimum": 0,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Hard cap on rows pushed per run. 0 means unlimited.",
                        "default": 25
                    },
                    "searchEngine": {
                        "title": "Search engine",
                        "enum": [
                            "none",
                            "google_shopping",
                            "bing_shopping",
                            "duckduckgo"
                        ],
                        "type": "string",
                        "description": "When categoryUrls is empty and keyword is set on a marketplace without a built in search, fall back to a search engine to find product URLs. Use 'none' to disable.",
                        "default": "none"
                    },
                    "searchEngineCountry": {
                        "title": "Search engine country",
                        "enum": [
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "DE",
                            "FR",
                            "IT",
                            "ES",
                            "NL",
                            "JP",
                            "IN",
                            "BR",
                            "MX"
                        ],
                        "type": "string",
                        "description": "Country gl param. Affects which retailers Google or Bing surface.",
                        "default": "US"
                    },
                    "searchEngineLanguage": {
                        "title": "Search engine language",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "nl",
                            "ja",
                            "hi"
                        ],
                        "type": "string",
                        "description": "Language hl param.",
                        "default": "en"
                    },
                    "currency": {
                        "title": "Output currency",
                        "enum": [
                            "original",
                            "USD",
                            "EUR",
                            "GBP",
                            "CAD",
                            "AUD",
                            "JPY",
                            "INR",
                            "BRL",
                            "MXN",
                            "AED",
                            "SGD"
                        ],
                        "type": "string",
                        "description": "Normalize all prices to this currency in the row. Conversion uses the most recent rate at scrape time.",
                        "default": "original"
                    },
                    "extractImages": {
                        "title": "Extract image URLs",
                        "type": "boolean",
                        "description": "Pull primary plus gallery image URLs at original resolution.",
                        "default": true
                    },
                    "maxImagesPerProduct": {
                        "title": "Max images per product",
                        "minimum": 0,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Cap on image URLs returned. Set 0 for all.",
                        "default": 12
                    },
                    "extractVariants": {
                        "title": "Extract variant matrix",
                        "type": "boolean",
                        "description": "When the product ships in sizes, colors, or styles, return every variant with its own price, stock, and SKU.",
                        "default": true
                    },
                    "extractRatingHistogram": {
                        "title": "Extract rating histogram",
                        "type": "boolean",
                        "description": "Pull the percentage split across 5, 4, 3, 2, 1 star reviews when the marketplace exposes it.",
                        "default": false
                    },
                    "extractQuestionsCount": {
                        "title": "Extract questions count",
                        "type": "boolean",
                        "description": "Pull the answered questions count when present (Amazon, Walmart, Best Buy).",
                        "default": false
                    },
                    "extractShippingInfo": {
                        "title": "Extract shipping info",
                        "type": "boolean",
                        "description": "Free shipping flag, delivery estimate text, in store pickup options where applicable.",
                        "default": true
                    },
                    "dedupe": {
                        "title": "Deduplicate across runs",
                        "type": "boolean",
                        "description": "Skip product IDs already pushed in previous runs. Turn off to refresh stale rows.",
                        "default": true
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Number of pages processed in parallel. Three to five is safe across retailers.",
                        "default": 4
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy. Residential is required for Amazon, Walmart, Target, AliExpress. Datacenter is fine for Shopify and most other retailers.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```