# Newegg Product Reviews Scraper (`automation-lab/newegg-product-reviews-scraper`) Actor

🛒 Extract recent public Newegg customer reviews, verified-purchase signals, helpful votes, media, vendor replies, and full product rating summaries.

- **URL**: https://apify.com/automation-lab/newegg-product-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Newegg Product Reviews Scraper

Collect public Newegg customer reviews from product URLs or item numbers and turn them into structured records for analysis, monitoring, and export.

Newegg Product Reviews Scraper extracts the review details that teams normally copy by hand: star rating, review date, title, full text, pros, cons, reviewer, verified-purchase marker, helpful votes, images, vendor replies, and product rating summaries.

Use it to track new customer feedback across a SKU list, investigate recurring product defects, compare brand reputation, or feed review data into sentiment and quality workflows.

- 🛒 Input Newegg product URLs or item numbers.
- ⭐ Filter the current public batch by rating and review date.
- ✅ Identify verified purchases and helpful feedback.
- 🖼️ Capture review media links and vendor responses when present.
- 📊 Export clean review rows as JSON, CSV, Excel, XML, or RSS.
- ⏰ Schedule recurring runs to monitor newly surfaced reviews.

### What does Newegg Product Reviews Scraper do?

The Actor loads each public Newegg product page over HTTP and reads the structured product and review state embedded in the page.

For every matching review, it creates one dataset row with customer feedback and product context.

It also adds the product's average rating, total rating count, text-review count, and one-to-five-star distribution to each row. That makes every exported record useful without a separate join.

The current Newegg page exposes a recent review batch. On the observed product, that batch contained eight complete reviews while summary metadata described the full rating history. The Actor is designed for recent-review extraction and recurring monitoring; it does not claim complete historical pagination.

### Who is it for?

#### Consumer electronics brands

Monitor how buyers describe quality, installation, reliability, noise, fit, performance, and defects across your Newegg catalog.

#### Marketplace sellers

Track recent complaints, verified-purchase feedback, helpfulness, and vendor replies for the SKUs you sell or compete against.

#### Product researchers

Create comparable review datasets across GPUs, components, laptops, appliances, and other Newegg categories.

#### Reputation and quality teams

Schedule collection, detect low-rating reviews, and route the feedback into issue trackers, dashboards, or sentiment models.

#### Data teams and developers

Use the API, webhooks, datasets, and integrations instead of maintaining a custom Newegg parser.

### Why use this Newegg review extractor?

- 🚀 **Fast HTTP workflow:** no browser is required for normal product pages.
- 🧩 **Structured fields:** reviews are normalized into stable columns.
- 🔍 **Useful filters:** choose a rating range and inclusive date boundaries.
- 🛡️ **Closed input scope:** non-Newegg URLs and malformed values are rejected.
- 🔁 **Batch support:** process up to 50 unique products in one run.
- 💾 **Ready exports:** download JSON, CSV, Excel, XML, or RSS immediately.
- 🔌 **Automation friendly:** call it through API, MCP, schedules, or webhooks.
- ⚙️ **Resilient access:** a US residential proxy is used by default after direct and datacenter routes proved challenge-prone.

### What Newegg review data can I extract?

| Field group | Example fields |
|---|---|
| Review identity | `reviewId`, `reviewedAt`, `sourceUrl` |
| Product identity | `productItemNumber`, `productCode`, `productUrl`, `productName` |
| Product context | `brand`, `category` |
| Rating summary | `productAverageRating`, `productTotalRatings`, `productTextReviewCount` |
| Rating distribution | `fiveStarCount` through `oneStarCount` |
| Customer feedback | `rating`, `title`, `text`, `pros`, `cons` |
| Reviewer | `reviewer`, `verifiedPurchase`, `badges` |
| Helpfulness | `helpfulVotes`, `unhelpfulVotes`, `totalVotes` |
| Media | `mediaUrls`, `videoUrl` |
| Seller follow-up | `vendorResponse`, `vendorResponseAt` |
| Audit | `scrapedAt` |

Optional source values are omitted when Newegg does not publish them for a review.

### How to scrape Newegg product reviews

1. Open the Actor input page.
2. Add one or more public Newegg product URLs under **Newegg product URLs**.
3. Alternatively, enter item numbers such as `N82E16814932777`.
4. Choose the maximum review rows to save per product.
5. Optionally set a minimum and maximum rating.
6. Optionally choose inclusive review dates.
7. Select newest, oldest, or most-helpful ordering for the available batch.
8. Click **Start**.
9. Open the dataset and export the results in your preferred format.

For a recurring monitor, save the configuration as a task and attach a schedule.

### Input parameters

#### `productUrls`

A list of public HTTPS Newegg product URLs. Both canonical `/p/<item-number>` pages and product URLs carrying an `Item` query parameter are normalized.

#### `itemNumbers`

A list of Newegg item numbers. Use this when you already keep SKUs in a spreadsheet or database.

#### `maxReviewsPerProduct`

The maximum matching records saved from each product's current embedded review batch. The prefill is five for a quick first run.

#### `minRating` and `maxRating`

Inclusive one-to-five-star boundaries. For complaint monitoring, use `minRating: 1` and `maxRating: 3`.

#### `reviewedAfter` and `reviewedBefore`

Optional inclusive date boundaries in `YYYY-MM-DD` format.

#### `sort`

Order the available review batch by `newest`, `oldest`, or `helpful`.

#### `proxyConfiguration`

Optional Apify Proxy or custom proxy settings. The default is a US residential proxy because Newegg challenged repeated direct and datacenter requests during validation.

### Example input

```json
{
  "productUrls": [
    { "url": "https://www.newegg.com/p/N82E16814932777" }
  ],
  "maxReviewsPerProduct": 8,
  "minRating": 1,
  "maxRating": 5,
  "sort": "newest"
}
````

You can mix URLs and item numbers. Duplicate products are processed once.

### Example output

```json
{
  "reviewId": "12442198",
  "productItemNumber": "N82E16814932777",
  "productUrl": "https://www.newegg.com/p/N82E16814932777",
  "productName": "GIGABYTE WindForce GeForce RTX 5070 12GB GDDR7 Graphics Card",
  "brand": "GIGABYTE",
  "category": "GPUs / Video Graphics Cards",
  "productAverageRating": 4.3,
  "productTotalRatings": 137,
  "rating": 5,
  "reviewedAt": "2025-03-16T22:06:46.490Z",
  "title": "Pleasantly Surprised",
  "pros": "Small form factor, quiet, power efficient, stays cool",
  "cons": "Not a con but it is more for a non-RGB build",
  "reviewer": "Gary S.",
  "verifiedPurchase": true,
  "helpfulVotes": 12,
  "totalVotes": 13,
  "mediaUrls": [
    "https://c1.neweggimages.com/itemreivewimages/reviewimg800/example.jpg"
  ],
  "scrapedAt": "2026-07-17T17:30:00.000Z"
}
```

The actual `text` field contains the full public review body.

### How much does it cost to scrape Newegg reviews?

This Actor uses pay-per-event pricing:

- a small one-time Actor start charge;
- one review event for each dataset row saved.

The exact review price depends on your Apify subscription tier:

| Plan tier | Price per saved review |
|---|---:|
| Free | $0.0022497 |
| Bronze | $0.0019562 |
| Silver | $0.0015259 |
| Gold | $0.0011737 |
| Platinum | $0.00078249 |
| Diamond | $0.00054774 |

The one-time start charge is $0.005. You never pay a review event for records filtered out before they are saved.

A five-review first run costs about $0.01625 on Free or $0.01478 on Bronze. Residential proxy and platform costs are included.

### Tips for reliable review monitoring

- 🎯 Start with one known product before adding a large SKU list.
- 📅 Use a schedule and deduplicate downstream by `reviewId`.
- ⭐ Route one-to-three-star reviews into a defect or support workflow.
- 🧾 Keep `productItemNumber` as the stable SKU join key.
- 🔄 Monitor on a cadence because Newegg exposes a recent public batch.
- 🌐 Keep the default US residential proxy unless you have verified a cheaper custom route in your environment.
- 📉 Avoid dates far in the past when your goal is current-batch monitoring.

### Integrations and automation workflows

#### Google Sheets review tracker

Use the Google Sheets integration to append review rows, then deduplicate on `reviewId` and build rating charts by SKU.

#### Slack or email complaint alerts

Trigger a webhook after each scheduled run. Filter rows where `rating <= 2` and send the review title, text, product URL, and verified-purchase status to the owner.

#### Product quality dashboard

Load dataset exports into BigQuery, Snowflake, PostgreSQL, or a BI tool. Group `pros` and `cons` by `productItemNumber` and time period.

#### Sentiment and defect classification

Pass `title`, `text`, `pros`, and `cons` to an LLM workflow. Store categories such as packaging, fan noise, compatibility, reliability, support, or performance.

#### Apify webhooks

Attach a webhook to notify an API endpoint when a run succeeds or fails.

### Use with the Apify API in JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/newegg-product-reviews-scraper').call({
  itemNumbers: ['N82E16814932777'],
  maxReviewsPerProduct: 8,
  maxRating: 3,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use with the Apify API in Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/newegg-product-reviews-scraper").call(
    run_input={
        "itemNumbers": ["N82E16814932777"],
        "maxReviewsPerProduct": 8,
        "sort": "newest",
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~newegg-product-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "itemNumbers": ["N82E16814932777"],
    "maxReviewsPerProduct": 8,
    "minRating": 1,
    "maxRating": 5
  }'
```

The run response includes IDs for logs, the dataset, and the key-value store.

### Use Newegg review scraping with MCP

Connect the Actor to Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/newegg-product-reviews-scraper"
```

For Claude Desktop, Cursor, or VS Code, add this server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/newegg-product-reviews-scraper"
    }
  }
}
```

Example prompts:

- “Scrape the recent public reviews for Newegg item N82E16814932777.”
- “Extract only one-to-three-star reviews for these Newegg SKUs.”
- “Find recurring cons in the returned Newegg product reviews.”
- “Compare verified-purchase complaints across these two item numbers.”

### Data quality and limitations

Newegg product pages currently embed a recent public review batch plus broader rating-summary counts.

The number of returned rows can therefore be smaller than `productTotalRatings` or `productTextReviewCount`. Those summary fields describe the product's broader public rating history, not the batch size.

Date and rating filters apply to the fetched batch. A valid product may produce zero rows if no current review matches the filters.

Newegg may change its public HTML or challenge some networks. The Actor uses realistic headers, rotating proxy sessions, retries, and configurable proxy settings, but no scraper can guarantee uninterrupted access to a third-party site.

### Is it legal to scrape Newegg reviews?

The Actor extracts information displayed on public Newegg product pages and does not require a customer account.

Your use must still comply with applicable laws, Newegg's terms, intellectual-property rules, privacy requirements, and your contractual obligations.

Avoid using public reviewer names to profile individuals. Collect only what you need, protect exported data, respect deletion obligations, and obtain legal advice for regulated or high-risk use cases.

### Troubleshooting

#### Why did a product return no reviews?

Check whether the page is a live public Newegg product, then remove narrow date or rating filters. A valid page can have no matching rows in its current public batch.

#### Why is the result count lower than the product rating count?

`productTotalRatings` is a summary of broader rating history. The page embeds only a recent review batch, which is the extraction surface used by this Actor.

#### Why did the run fail with a challenge or missing state?

Retry with Apify Proxy enabled and a US country setting. Also verify that the item number still resolves in a normal browser.

#### Can I enter a Newegg search or category URL?

No. This Actor intentionally accepts product pages and item numbers only. Search and category URLs fail closed rather than returning unrelated records.

#### How do I avoid duplicate alerts?

Store seen `reviewId` values in your downstream database, sheet, or automation. Scheduled runs can then alert only on unseen IDs.

### FAQ

#### Does the Actor require a Newegg account?

No. It reads public product and review data anonymously.

#### Can it process multiple products?

Yes. A run supports up to 50 unique product URLs or item numbers.

#### Does it extract complete historical review pagination?

No. The current release extracts the recent public review batch embedded in each product page and reports full summary counts separately.

#### Are verified purchases included?

Yes. `verifiedPurchase` combines Newegg's public purchase markers.

#### Are images and vendor replies included?

Yes, when those values are present in the public review object.

#### Can I export to CSV or Excel?

Yes. Open the dataset after a run and choose JSON, CSV, Excel, XML, or RSS.

#### Can I schedule it?

Yes. Save the input as an Apify task and add a daily, weekly, or custom schedule.

### Related scrapers

Build a wider retail-review workflow with these automation-lab Actors:

- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper)
- [Walmart Product Reviews Scraper](https://apify.com/automation-lab/walmart-product-reviews-scraper)
- [Best Buy Reviews Scraper](https://apify.com/automation-lab/best-buy-reviews-scraper)
- [Home Depot Product Reviews Scraper](https://apify.com/automation-lab/home-depot-product-reviews-scraper)
- [Steam Game Reviews Scraper](https://apify.com/automation-lab/steam-game-reviews-scraper)

Use the stable item, product, review ID, rating, date, and text fields to normalize review intelligence across sources.

# Actor input Schema

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

Add public newegg.com product URLs. Product and item-query URL variants are normalized automatically.

## `itemNumbers` (type: `array`):

Enter item numbers such as N82E16814932777 instead of full URLs.

## `maxReviewsPerProduct` (type: `integer`):

Maximum matching reviews saved for each product from Newegg's public embedded review batch.

## `minRating` (type: `integer`):

Keep reviews at or above this rating.

## `maxRating` (type: `integer`):

Keep reviews at or below this rating.

## `reviewedAfter` (type: `string`):

Optional inclusive review-date boundary in YYYY-MM-DD format.

## `reviewedBefore` (type: `string`):

Optional inclusive review-date boundary in YYYY-MM-DD format.

## `sort` (type: `string`):

Order the reviews available on each public product page.

## `includeRelatedProducts` (type: `boolean`):

Include reviews Newegg groups from related item numbers. Keep disabled for exact-SKU monitoring.

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

Override the default US residential Apify Proxy with your own supported Apify or custom proxy settings.

## Actor input object example

```json
{
  "productUrls": [
    {
      "url": "https://www.newegg.com/p/N82E16814932777"
    }
  ],
  "itemNumbers": [],
  "maxReviewsPerProduct": 5,
  "minRating": 1,
  "maxRating": 5,
  "sort": "newest",
  "includeRelatedProducts": false
}
```

# Actor output Schema

## `reviews` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "productUrls": [
        {
            "url": "https://www.newegg.com/p/N82E16814932777"
        }
    ],
    "maxReviewsPerProduct": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/newegg-product-reviews-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 = {
    "productUrls": [{ "url": "https://www.newegg.com/p/N82E16814932777" }],
    "maxReviewsPerProduct": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/newegg-product-reviews-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 '{
  "productUrls": [
    {
      "url": "https://www.newegg.com/p/N82E16814932777"
    }
  ],
  "maxReviewsPerProduct": 5
}' |
apify call automation-lab/newegg-product-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Newegg Product Reviews Scraper",
        "description": "🛒 Extract recent public Newegg customer reviews, verified-purchase signals, helpful votes, media, vendor replies, and full product rating summaries.",
        "version": "0.1",
        "x-build-id": "L8djz6hmU8xkWC6Nu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~newegg-product-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-newegg-product-reviews-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/automation-lab~newegg-product-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-newegg-product-reviews-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/automation-lab~newegg-product-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-newegg-product-reviews-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": {
                    "productUrls": {
                        "title": "Newegg product URLs",
                        "type": "array",
                        "description": "Add public newegg.com product URLs. Product and item-query URL variants are normalized automatically.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "itemNumbers": {
                        "title": "Newegg item numbers",
                        "type": "array",
                        "description": "Enter item numbers such as N82E16814932777 instead of full URLs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerProduct": {
                        "title": "Maximum reviews per product",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum matching reviews saved for each product from Newegg's public embedded review batch.",
                        "default": 8
                    },
                    "minRating": {
                        "title": "Minimum star rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Keep reviews at or above this rating.",
                        "default": 1
                    },
                    "maxRating": {
                        "title": "Maximum star rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Keep reviews at or below this rating.",
                        "default": 5
                    },
                    "reviewedAfter": {
                        "title": "Reviewed on or after",
                        "type": "string",
                        "description": "Optional inclusive review-date boundary in YYYY-MM-DD format."
                    },
                    "reviewedBefore": {
                        "title": "Reviewed on or before",
                        "type": "string",
                        "description": "Optional inclusive review-date boundary in YYYY-MM-DD format."
                    },
                    "sort": {
                        "title": "Review order",
                        "enum": [
                            "newest",
                            "oldest",
                            "helpful"
                        ],
                        "type": "string",
                        "description": "Order the reviews available on each public product page.",
                        "default": "newest"
                    },
                    "includeRelatedProducts": {
                        "title": "Include related product variants",
                        "type": "boolean",
                        "description": "Include reviews Newegg groups from related item numbers. Keep disabled for exact-SKU monitoring.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Override the default US residential Apify Proxy with your own supported Apify or custom proxy settings."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```