# eBay Review Scraper (`scraper-engine/ebay-review-scraper`) Actor

🛒 eBay Reviews Scraper (ebay-review-scraper) pulls real buyer feedback by item ID or URL. Advanced filters: rating, date, keywords & locale. ⚙️ Sentiment-ready data, pagination, CSV/JSON exports. 🚀 Ideal for market research, QA, and competitor analysis.

- **URL**: https://apify.com/scraper-engine/ebay-review-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.99 / 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.

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

## 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

### eBay Review Scraper

The eBay Review Scraper is a fast, reliable eBay product review extractor that turns public item pages into structured ratings and reviews data you can analyze and export. It solves the manual copy-paste problem by collecting on-page feedback and paginated seller reviews at scale — ideal for market research, QA, and competitor analysis. Built for marketers, developers, data analysts, and researchers, this eBay feedback scraper delivers sentiment-ready data you can export eBay reviews to CSV or JSON and plug into your workflow.

### What data / output can you get?

Below are the exact fields the actor saves to the Apify dataset as each review is found. The first row per product includes ProductDetails for context; subsequent rows repeat Url without ProductDetails.

| Data type | Description | Example value |
| --- | --- | --- |
| Url | Product URL from JSON-LD offers.url | https://www.ebay.com/itm/364771787371 |
| ProductDetails.productTitle | Product name from JSON-LD Product | Wireless Noise-Cancelling Headphones |
| ProductDetails.productPrice | Price with currency from JSON-LD offers | USD 199.99 |
| ProductDetails.sellerUsername | Seller username (from JSON-LD or HTML fallback) | best_seller_store |
| ProductDetails.productImages | Array of product image URLs from JSON-LD image | ["https://i.ebayimg.com/images/g/abc/s-l1600.jpg"] |
| ReviewerName | Buyer username extracted from page or JSON payload | john*** (123) |
| IsVerifiedPurchase | “Verified purchase” flag when present | Verified purchase |
| ReviewRatingType | Rating label (positive/neutral/negative) | Positive feedback rating |
| ReviewComment | Review text/comment | Great quality and fast shipping! |
| ReviewDateRange | Relative time range shown with the review | Past 6 months |
| ReviewImageCount | Count of buyer images (string) | 2 |
| ReviewImageUrl | Comma-separated image URLs when available | https://i.ebayimg.com/...1.jpg,https://i.ebayimg.com/...2.jpg |

Notes:
- ProductDetails appears on the first row per item when reviews exist. Following rows for the same item include Url plus the review fields only.
- If no reviews are found, one row is returned with ProductDetails and empty review fields set to "" (and ReviewImageCount "0").
- Export results from the Apify dataset to CSV or JSON directly in the console.

### Key features

- 🔄 Robust proxy ladder & resilience  
  Starts without a proxy, then automatically falls back to Apify datacenter proxy on blocks, and finally to residential proxy with up to three rotated residential attempts. Once residential works, subsequent requests use residential only (sticky) for consistent performance.

- 🧠 Chrome TLS impersonation for reliability  
  Uses curl_cffi with Chrome TLS impersonation (chrome120) to improve compatibility with eBay’s infrastructure and reduce challenge pages.

- 📦 Batch scraping at scale  
  Feed multiple product links via ebayProductUrls (accepts plain strings or requestListSources objects with url). The actor also reads legacy urls/startUrls fields if present.

- 🎚️ Precision filters for better signal  
  Control sortReviewsBy (RELEVANCE or TIME), ratingType (All ratings, POSITIVE, NEUTRAL, NEGATIVE), withPhotosOnly (true/false), and cap volume with maxReviewsPerUrl.

- ⚡ Live dataset output  
  Each review row is streamed to the Apify dataset as soon as it’s extracted, so you can monitor progress and start analysis early.

- 🧩 Developer friendly (Python-based)  
  Built with the Apify Python SDK. Ideal if you want an eBay review scraper Python workflow or to integrate results into data pipelines and ML sentiment analysis.

- 🌍 Multi-marketplace fallbacks  
  Automatically tries equivalent item links on ebay.com, ebay.co.uk, and ebay.de when needed, increasing the chance of reaching the listing.

- 🧾 Clean exports for BI tools  
  Export eBay reviews to CSV or JSON for spreadsheets, dashboards, or downstream pipelines. Great for teams seeking an eBay reviews API scraper approach without browser extensions.

### How to use eBay Review Scraper - step by step

1) Sign in to Apify  
   Create or log in to your Apify account to run the actor in the cloud.

2) Open the actor and prepare input  
   Go to the eBay Review Scraper and open the input form.

3) Add your products  
   Paste one or more eBay item links into ebayProductUrls. You can add:
   - Plain strings like "https://www.ebay.com/itm/364771787371"
   - Or request list rows like { "url": "https://www.ebay.com/itm/364771787371" }

4) Configure sorting and filters  
   - sortReviewsBy: Choose RELEVANCE or TIME  
   - ratingType: Choose All ratings, POSITIVE, NEUTRAL, or NEGATIVE  
   - withPhotosOnly: Toggle on to keep only reviews with buyer photos  
   - maxReviewsPerUrl: Set 0 for unlimited, or any positive cap

5) Optional: Proxy configuration  
   Leave proxyConfiguration as default (useApifyProxy true) for the best success rate. The actor will escalate from direct to datacenter to residential proxies automatically when necessary.

6) Start the run  
   Click Start. The actor loads the item page and the seller’s feedback pages, then streams results to the dataset in real time.

7) Monitor progress  
   Watch the run logs. You’ll see notes about connection strategy and rows added like “Output table +1”.

8) Download results  
   Open the Dataset tab and export to CSV or JSON. Use these files for analysis, dashboards, or to power downstream applications.

Pro Tip: Use maxReviewsPerUrl = 0 to collect full histories for deep sentiment analysis, or set a small cap for quick benchmarking across many listings. Combine with withPhotosOnly to build a high-signal dataset of image-backed reviews.

### Use cases

| Use case name | Description |
| --- | --- |
| Market research + trend analysis | Aggregate ratings and comments to identify product strengths/weaknesses and category trends using this eBay product review extractor. |
| QA and product validation | Filter by withPhotosOnly to review real-world buyer images and spot recurring quality issues faster. |
| Competitor analysis | Benchmark review volume, sentiment, and verification signals across competing listings with the eBay ratings and reviews scraper. |
| Seller vetting & risk checks | Extract seller feedback patterns to assess trust before sourcing or partnerships using an eBay seller feedback scraper approach. |
| NLP sentiment pipeline (Python) | Feed structured reviews to your Python models for sentiment, topic modeling, and keyphrase extraction. |
| Buyer voice analytics | Group comments by themes (shipping, packaging, support) to inform product and CX improvements. |
| Data journalism & academic research | Collect longitudinal feedback snapshots to study pricing, satisfaction, and geographic differences over time. |
| Automation workflows | Export to CSV/JSON and connect to data warehouses, reporting tools, or orchestration systems as an eBay review scraping tool. |

### Why choose eBay Review Scraper?

- 🎯 Precision-first extraction: Pulls on-page HTML feedback and paginated mweb_profile JSON, giving you structured and consistent review rows.
- 🧱 Built for scale and stability: Proxy fallback ladder (direct → datacenter → residential with retries, then sticky) keeps runs moving despite intermittent blocks.
- 🔧 Developer-ready: Implemented with the Apify Python SDK; perfect if you prefer a code-centric eBay reviews pipeline or eBay review scraper Python integration.
- 🧪 Clean, analytics-ready fields: Sentiment-ready outputs including rating labels, verification flags, and image counts.
- 💾 Easy exports: Export eBay reviews to CSV or JSON straight from the dataset — no custom tooling required.
- 🔐 Public data only: No login or cookies required — safer and simpler than brittle browser extensions or an eBay review scraper Chrome extension.
- 🔄 Bulk-friendly: Accepts many item links in one run so you can scrape eBay product reviews at scale.

In short: a production-ready eBay review scraping tool that’s more reliable and scalable than ad hoc scripts or extensions.

### Is it legal / ethical to use eBay Review Scraper?

Yes — when done responsibly. This actor collects data from public eBay pages only and does not access private or authenticated content.

Guidelines:
- Use publicly available item pages and seller feedback only.
- Do not attempt to bypass access controls or collect private data.
- Comply with eBay’s terms and applicable laws in your jurisdiction (e.g., data protection rules).
- Use the results for legitimate research, analytics, and QA — not for spam or misuse.
- Consult your legal team for edge cases or specific compliance needs.

### Input parameters & output format

#### Example JSON input
```json
{
  "ebayProductUrls": [
    { "url": "https://www.ebay.com/itm/364771787371" }
  ],
  "sortReviewsBy": "RELEVANCE",
  "ratingType": "All ratings",
  "withPhotosOnly": false,
  "maxReviewsPerUrl": 0,
  "proxyConfiguration": { "useApifyProxy": true }
}
````

Parameter reference:

- ebayProductUrls (array, required): Paste one or more eBay item links. Accepts plain strings or requestListSources objects with url. Default: (none)
- sortReviewsBy (string): How to order reviews. Allowed values: RELEVANCE, TIME. Default: RELEVANCE
- ratingType (string): Filter by sentiment. Allowed values: All ratings, POSITIVE, NEUTRAL, NEGATIVE. Default: All ratings
- withPhotosOnly (boolean): Keep only reviews that include buyer photos when true. Default: false
- maxReviewsPerUrl (integer): Cap the number of reviews per link; use 0 for unlimited. Default: 0
- proxyConfiguration (object): Optional Apify Proxy settings. Leave as default for best balance; prefill uses { "useApifyProxy": true }. Default: (none specified)

Notes:

- The actor also reads legacy fields if present: urls and startUrls for input, sortBy/Sort\_by for sorting, and maxReviews/max\_reviews for limits.

#### Example JSON output

First row (includes ProductDetails):

```json
{
  "Url": "https://www.ebay.com/itm/364771787371",
  "ProductDetails": {
    "productTitle": "Wireless Noise-Cancelling Headphones",
    "productPrice": "USD 199.99",
    "sellerUsername": "best_seller_store",
    "productImages": [
      "https://i.ebayimg.com/images/g/abc/s-l1600.jpg"
    ]
    },
  "ReviewerName": "john*** (123)",
  "IsVerifiedPurchase": "Verified purchase",
  "ReviewRatingType": "Positive feedback rating",
  "ReviewComment": "Great quality and fast shipping!",
  "ReviewDateRange": "Past 6 months",
  "ReviewImageCount": "2",
  "ReviewImageUrl": "https://i.ebayimg.com/00/s1.jpg,https://i.ebayimg.com/00/s2.jpg"
}
```

Subsequent rows (Url + review fields only):

```json
{
  "Url": "https://www.ebay.com/itm/364771787371",
  "ReviewerName": "buyer*** (56)",
  "IsVerifiedPurchase": "",
  "ReviewRatingType": "Neutral feedback rating",
  "ReviewComment": "Item works but packaging was damaged.",
  "ReviewDateRange": "Past 6 months",
  "ReviewImageCount": "0",
  "ReviewImageUrl": ""
}
```

Edge case — when no reviews are found, one row is still returned with ProductDetails and empty review fields:

```json
{
  "Url": "https://www.ebay.com/itm/364771787371",
  "ProductDetails": {
    "productTitle": "Wireless Noise-Cancelling Headphones",
    "productPrice": "USD 199.99",
    "sellerUsername": "best_seller_store",
    "productImages": [
      "https://i.ebayimg.com/images/g/abc/s-l1600.jpg"
    ]
  },
  "ReviewerName": "",
  "IsVerifiedPurchase": "",
  "ReviewRatingType": "",
  "ReviewComment": "",
  "ReviewDateRange": "",
  "ReviewImageCount": "0",
  "ReviewImageUrl": ""
}
```

### FAQ

#### Do I need to log in or provide cookies to scrape eBay reviews?

No. The actor works on public eBay pages only and does not require login or authenticated cookies. It collects data from item pages and the public seller feedback endpoint.

#### Can it handle multiple eBay listings in one run?

Yes. You can add many item links to ebayProductUrls, and the actor will process them in a single job. It also reads legacy urls/startUrls if present.

#### How are reviews sorted and filtered?

Set sortReviewsBy to RELEVANCE or TIME. Use ratingType to keep All ratings or filter to POSITIVE, NEUTRAL, or NEGATIVE. Toggle withPhotosOnly to restrict results to reviews with buyer images. You can also limit volume with maxReviewsPerUrl.

#### Does it follow seller feedback pagination?

Yes. In addition to on-page HTML, it fetches the seller feedback pages via the mweb\_profile JSON endpoint, handling multiple pages automatically.

#### How does it deal with blocks or challenge pages?

It starts without a proxy, falls back to Apify datacenter proxy on blocks, and then to residential proxy with up to three rotated attempts. After a successful residential attempt, subsequent URLs use residential (sticky) for greater stability.

#### Which eBay domains are supported?

The actor attempts the user-provided URL first and can try equivalent item URLs on ebay.com, ebay.co.uk, and ebay.de for the same item ID to improve reachability.

#### How can I export the data?

Open the run’s Dataset and export to CSV or JSON. This makes it easy to move data into spreadsheets, BI tools, or pipelines for further analysis.

#### Is this suitable for Python-based pipelines or APIs?

Yes. The actor is built with the Apify Python SDK and streams structured rows to the Apify dataset, making it a good fit for Python workflows and eBay reviews API scraper use cases where you programmatically fetch the dataset.

### Closing thoughts

The eBay Review Scraper is built to reliably scrape eBay product reviews and seller feedback at scale. With resilient fetching, precise filters, and clean exports, it helps marketers, developers, analysts, and researchers turn public eBay feedback into actionable insights. Run it on Apify, export eBay reviews to CSV/JSON, or integrate the dataset into your Python pipelines. Start extracting smarter, sentiment-ready eBay ratings and reviews today.

# Actor input Schema

## `ebayProductUrls` (type: `array`):

Paste one or more **eBay item links** (the pages where you see the product). Add as many as you need — perfect for batch research or building a comparison sheet.

## `sortReviewsBy` (type: `string`):

Choose what matters most: **most relevant** feedback first, or **newest** comments at the top.

## `ratingType` (type: `string`):

Focus on **all feedback** or zoom in on **positive**, **neutral**, or **negative** experiences — ideal when you only want a specific mood of reviews.

## `withPhotosOnly` (type: `boolean`):

Toggle **on** to keep reviews that include buyer photos — great when you want visual proof or richer social proof.

## `maxReviewsPerUrl` (type: `integer`):

Cap how many reviews to collect **per link**. Use **0** for no limit — handy for quick samples or full deep-dives.

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

Optional Apify Proxy can help **when pages are harder to reach** from certain networks. Leave as default for the best balance, or adjust if your organization requires it.

## Actor input object example

```json
{
  "ebayProductUrls": [
    {
      "url": "https://www.ebay.com/itm/364771787371"
    },
    {
      "url": "https://www.ebay.co.uk/itm/194488920284"
    }
  ],
  "sortReviewsBy": "RELEVANCE",
  "ratingType": "All ratings",
  "withPhotosOnly": false,
  "maxReviewsPerUrl": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "ebayProductUrls": [
        {
            "url": "https://www.ebay.com/itm/364771787371"
        },
        {
            "url": "https://www.ebay.co.uk/itm/194488920284"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/ebay-review-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 = {
    "ebayProductUrls": [
        { "url": "https://www.ebay.com/itm/364771787371" },
        { "url": "https://www.ebay.co.uk/itm/194488920284" },
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/ebay-review-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 '{
  "ebayProductUrls": [
    {
      "url": "https://www.ebay.com/itm/364771787371"
    },
    {
      "url": "https://www.ebay.co.uk/itm/194488920284"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scraper-engine/ebay-review-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "eBay Review Scraper",
        "description": "🛒 eBay Reviews Scraper (ebay-review-scraper) pulls real buyer feedback by item ID or URL. Advanced filters: rating, date, keywords & locale. ⚙️ Sentiment-ready data, pagination, CSV/JSON exports. 🚀 Ideal for market research, QA, and competitor analysis.",
        "version": "1.0",
        "x-build-id": "JdA4hHbwJfWGnc7q8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~ebay-review-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-ebay-review-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/scraper-engine~ebay-review-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-ebay-review-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/scraper-engine~ebay-review-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-ebay-review-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",
                "required": [
                    "ebayProductUrls"
                ],
                "properties": {
                    "ebayProductUrls": {
                        "title": "🔗 eBay product URLs",
                        "type": "array",
                        "description": "Paste one or more **eBay item links** (the pages where you see the product). Add as many as you need — perfect for batch research or building a comparison sheet.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "sortReviewsBy": {
                        "title": "📊 Sort reviews by",
                        "enum": [
                            "RELEVANCE",
                            "TIME"
                        ],
                        "type": "string",
                        "description": "Choose what matters most: **most relevant** feedback first, or **newest** comments at the top.",
                        "default": "RELEVANCE"
                    },
                    "ratingType": {
                        "title": "⭐ Rating type",
                        "enum": [
                            "All ratings",
                            "POSITIVE",
                            "NEUTRAL",
                            "NEGATIVE"
                        ],
                        "type": "string",
                        "description": "Focus on **all feedback** or zoom in on **positive**, **neutral**, or **negative** experiences — ideal when you only want a specific mood of reviews.",
                        "default": "All ratings"
                    },
                    "withPhotosOnly": {
                        "title": "📷 With photos only",
                        "type": "boolean",
                        "description": "Toggle **on** to keep reviews that include buyer photos — great when you want visual proof or richer social proof.",
                        "default": false
                    },
                    "maxReviewsPerUrl": {
                        "title": "🔢 Max reviews per product",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Cap how many reviews to collect **per link**. Use **0** for no limit — handy for quick samples or full deep-dives.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy can help **when pages are harder to reach** from certain networks. Leave as default for the best balance, or adjust if your organization requires it."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
