# Newegg Product Scraper — $3/1K · Prices, Stock & Sellers (`apivault_labs/newegg-product-scraper`) Actor

Collect supported Newegg product URLs with returned prices, stock and available PC-part specifications. Bulk export: JSON, CSV, Excel and API. PPE: $3/1K products; start fee extra.

- **URL**: https://apify.com/apivault_labs/newegg-product-scraper.md
- **Developed by:** [Apivault Labs](https://apify.com/apivault_labs) (community)
- **Categories:** E-commerce, Developer tools
- **Features:** Limited permissions
- **Stats:** 5 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 product scrapeds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Newegg Product Scraper — Prices, Stock & PC Parts

Collect structured product snapshots from **Newegg.com US** using product URLs or Item IDs. Get displayed prices, brand and manufacturer model, ratings, review counts, seller, shipping text, availability and images when the source supplies them. Export JSON, CSV or Excel, or use the results in an API, n8n, Make or MCP workflow.

Each delivered product must have a matching item identifier, a useful title and product facts. Empty extractions, challenge pages and unrelated products do not become paid Dataset results. Missing optional fields stay blank.

### Quick start

```json
{
  "productUrls": ["N82E16820232869"],
  "maxProducts": 1,
  "maxConcurrency": 1,
  "timeout": 180
}
```

Start the Actor, open the Dataset and check `SUMMARY.delivered`. A complete run with errors may contain fewer products than requested. An empty `productUrls: []` produces no products; omitting `productUrls` uses the sample item above and may incur a result charge.

### Supported product inputs

- Bare item identifiers such as `N82E16820232869`.
- Product URLs such as `https://www.newegg.com/p/N82E16820232869`.
- Descriptive product URLs ending in `/p/ITEM_ID`.
- Legacy `Product/Product.aspx?Item=ITEM_ID` links.
- Explicit marketplace offer IDs in `item` / `Item` parameters are treated as their own item, rather than silently replaced by the primary seller.

Tracking parameters are removed. Exact canonical duplicates are processed once per run. Up to 1,000 input entries are accepted; `maxProducts` defaults to 100 unique valid products and can be set from 1–1,000. This is a supported bound, not a measured throughput guarantee.

Search, category and review-page URLs are not supported. This Actor does not discover a full catalog, paginate searches, return full review text or return a full technical-specifications table. `model` and `description` may contain product specifications, but they are not a normalized spec database. Newegg.ca and other storefronts are excluded.

### Field selection

All existing field toggles default to `true`:

| Toggle | Output |
|---|---|
| `extractTitle` | `title` |
| `extractPrice` | `price` |
| `extractOriginalPrice` | `originalPrice` |
| `extractRating` | `rating` |
| `extractReviewsCount` | `reviewsCount` |
| `extractBrand` / `extractModel` | `brand` / `model` |
| `extractCategory` / `extractAvailability` | `category` / `availability` |
| `extractSeller` / `extractShipping` | `seller` / `shipping` |
| `extractDescription` / `extractImage` | `description` / `imageUrl` |

Disabled fields are omitted. Identity and useful-product checks still run when title extraction is disabled. Selecting no useful available fields produces `NO_SELECTED_DATA`, not a paid row containing only IDs.

`maxConcurrency` accepts 1–8 (default 3). `timeout` accepts 60–300 seconds per product (default 180). Start with a small batch; throttling and source availability can increase runtime.

### Results and freshness

An illustrative product row:

```json
{
  "success": true,
  "productUrl": "https://www.newegg.com/p/N82E16820232869",
  "inputUrl": "https://www.newegg.com/p/N82E16820232869",
  "itemId": "N82E16820232869",
  "title": "G.SKILL Trident Z Neo DDR4 Desktop Memory",
  "price": "$186.95",
  "brand": "G.SKILL",
  "model": "F4-3600C16D-16GTZNC",
  "availability": "",
  "observedAt": "2026-10-11T19:00:00+00:00",
  "identityValidated": true,
  "freshnessVerified": false
}
```

The sample price and time are examples, not a current offer. `observedAt` records collection time; it does not prove when Newegg or an upstream page snapshot was updated. **Live price and inventory freshness are not independently verified.** Recheck the product and checkout before making purchasing or inventory decisions.

Prices, review counts, rating, seller and shipping are displayed strings, not normalized numeric amounts or final landed costs. Taxes, destination, condition, seller, coupons and selected offer can change pricing. Blank availability is unknown and must not be treated as in stock. No source-only missing field is filled with a guessed value. Collection may use automatic Apify residential proxy access in the US; this follows the platform usage pricing described below.

Results retain input order among successfully delivered items. Errors are stored separately:

| Record | Purpose |
|---|---|
| Dataset | Useful identity-matched products; paid result event per row |
| `SUMMARY` | Requested, delivered, failed, duplicate and capped counts; completion status |
| `ERRORS` | Safe error codes, input indices, canonical product URLs when valid and retryability |
| `RETRY_INPUT` | Retryable product URLs; completed products are not repeated |

These records are written on normal completed runs. Invalid top-level input writes `SUMMARY` and `ERRORS`; `RETRY_INPUT` is not guaranteed in that case. A run with no delivered products and errors is marked `FAILED`. Partial success delivers useful rows and records errors; an explicit empty array completes with zero rows.

### Pricing

**$0.003 per delivered product — $3 per 1,000 products.** The Actor-start event is $0.00005 per allocated GB, with a minimum of one event. At 256 MB, a run delivering one product costs $0.00305 in events.

Invalid, empty, mismatched and failed product extractions do not create paid product results. The start event still applies even when no products are delivered. Repeating a product in a new run creates a new paid snapshot.

Platform usage is now paid separately under the configuration active since **October18,2026 at19:32UTC**, with product and start rates unchanged. See the [Pricing tab](https://apify.com/apivault_labs/newegg-product-scraper/pricing) for the tariff applying to your run.

### API and automation

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/apivault_labs~newegg-product-scraper/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"productUrls":["N82E16820232869"],"maxProducts":1}'
```

Wait for the returned run to finish, then read its default Dataset and `SUMMARY`. In n8n or Make, use the Apify Run Actor action, map your product list to `productUrls`, then collect Dataset items. Save `itemId`, `model`, `price` and `observedAt` in your own sheet or database for comparisons across runs. History storage, price-change alerts and cross-store SKU matching are not built into this Actor.

### MCP and AI agents

Connect an MCP-compatible client to Apify's hosted server with this Actor selected:

```text
https://mcp.apify.com?tools=t0oWsDLob7QOPxcCh
```

Authenticate with your Apify account using OAuth or a private Bearer token configuration. An agent can use this instruction:

> Collect these Newegg product URLs with apivault_labs/newegg-product-scraper. Limit the batch to 5 products, wait for completion, read the Dataset and SUMMARY, and report errors separately. Return itemId, title, model, displayed price, seller and availability. State that freshnessVerified is false and blank stock is unknown.

Use `productUrls`, not `searchQuery`, `startUrls` or another Actor's category inputs. Read the Dataset for product rows and the Output links for summary/errors. A successful container status does not establish that every requested product was delivered.

### Limits and troubleshooting

- Product pages can be blocked or unavailable. A normal HTTP status with a challenge page is not a product result.
- `PRODUCT_IDENTITY_UNVERIFIED`: the extracted item could not be matched; no paid row is returned.
- `PRODUCT_NO_DATA`: no useful product data was available; it may be an unavailable item or a blocked response.
- `SOURCE_TIMEOUT` / `SOURCE_UNAVAILABLE`: retry only entries in `RETRY_INPUT`.
- `INVALID_PRODUCT_URL`: use an exact Newegg.com product link or item ID. Arbitrary websites, private networks, credentialed URLs and unexpected ports are rejected before collection.
- Field coverage depends on the source. This Actor is not a guarantee of current prices, checkout availability, full specification coverage or complete review collection.

Use the Actor's Issues tab for support with a run ID and a public product example. Keep tokens and private URLs out of issue reports. Respect Newegg's terms and applicable rights when collecting or reusing product data.

### Build a reviewed Newegg product comparison

Use this Newegg product scraper when you already know the exact US Item IDs or
product URLs to inspect. It supports a bounded parts shortlist, displayed-price
research or a product-data handoff to a spreadsheet. It is not a catalog search
engine or a guarantee that an observed offer is available at checkout.

| Goal | Starting input | Quality check |
| --- | --- | --- |
| Known PC part lookup | One exact Item ID | identityValidated, title and selected product facts |
| Compare a small shortlist | A few canonical product inputs | Model, seller, condition and price context |
| Prepare a narrow export | Field toggles | Useful selected fields rather than only identity |
| Repeat an observation | Store snapshots externally | observedAt is collection time, freshnessVerified remains false |

#### Inspect one known memory product

```json
{
  "productUrls": [
    "N82E16820232869"
  ],
  "maxProducts": 1,
  "maxConcurrency": 1,
  "timeout": 180
}
```

Check itemId, identityValidated and useful fields before adding more products. A successful observation does not independently establish live inventory or the final order price.

#### Collect a smaller model-and-price export

```json
{
  "productUrls": [
    "N82E16820232869"
  ],
  "maxProducts": 1,
  "maxConcurrency": 1,
  "extractDescription": false,
  "extractImage": false,
  "extractRating": false,
  "extractReviewsCount": false
}
```

This removes optional content fields from the output. It keeps the same per-product rate and the same identity/useful-data checks; a smaller payload is not a cheaper product event.

#### Deduplicate an Item ID and its canonical URL

```json
{
  "productUrls": [
    "N82E16820232869",
    "https://www.newegg.com/p/N82E16820232869"
  ],
  "maxProducts": 1,
  "maxConcurrency": 1
}
```

Alternate canonical forms of the same item are processed once in this run. Marketplace offer parameters can identify a different offer and should not be discarded when reconciling prices.

#### Retain seller and shipping context for manual review

```json
{
  "productUrls": [
    "https://www.newegg.com/p/N82E16820232869"
  ],
  "maxProducts": 1,
  "maxConcurrency": 1,
  "extractSeller": true,
  "extractShipping": true,
  "extractAvailability": true,
  "extractDescription": false
}
```

Blank stock or shipping text is unknown. Destination, seller, tax, coupons and checkout conditions can change the actual purchase cost; the Actor does not calculate landed cost.

### Use product snapshots without overstating freshness

A parts comparison should retain itemId, model, seller, productUrl and observedAt
alongside displayed price text. Different sellers, refurbished conditions or
marketplace offers can make similarly titled products unsuitable for a direct
price comparison. Do not silently strip offer identity or treat every matching
model string as an identical purchasable offer.

Prices, rating and review counts are displayed strings. Parse them carefully in
your own workflow if a numeric analysis is needed, and retain the original text.
Missing availability is not 'in stock'; freshnessVerified false means collection
time is not proof of a current checkout observation. If using repeated snapshots,
store and compare them externally; this Actor has no built-in price-history
ledger, alerts or cross-store SKU matching.

Current pricing is $0.003 per useful product ($3 per1,000), plus startup
$0.00005 per allocated GB, minimum one event. Platform usage is now separately
paid under the configuration active since October18. Three product results
would cost $0.009 in result events before startup and resources. Duplicates,
identity mismatches and extraction errors do not become product events. A
retry of a previously delivered product is a new snapshot and can be charged.

SUMMARY explains delivered, failed, duplicate and capped counts. ERRORS provides
safe error codes, and RETRY_INPUT helps target transient failures without
repeating successful products. Read those outputs after the same run completes;
a completed container status is not proof that every requested item was found.
Use smaller batches while reviewing a new input format, and respect a recorded
source denial rather than treating it as an empty product catalog.

JSON retains product observations for an API workflow; CSV/Excel are convenient
for selected part, price and seller columns. Use the verified n8n/Python paths
below or authenticated MCP with the same productUrls input. Neither MCP discovery
nor a field selector adds unsupported category search, full review text or a
complete technical-specification table.

**Does the Actor find the cheapest PC part automatically?** No. You supply the
known product inputs and review returned offers; it does not search the whole
store or normalize all purchase conditions.

**Can a blank field be filled from the product title?** Keep source gaps explicit.
A guessed availability, rating or price is not a verified extracted observation.

### n8n and developer integrations

Use this Actor in your automation or application with the existing community integrations below. An Apify account and API token are required; Actor and platform charges follow the [current pricing](https://apify.com/apivault_labs/newegg-product-scraper/pricing).

- **n8n community node:** [n8n-nodes-apivault-newegg](https://www.npmjs.com/package/n8n-nodes-apivault-newegg). Install package name `n8n-nodes-apivault-newegg` in a self-hosted n8n instance that permits community packages.
- **Python client and examples:** [GitHub](https://github.com/apivault-labs/apivault-labs/tree/main/python-clients/apivault-newegg-product-scraper).
- **n8n source and usage:** [GitHub](https://github.com/apivault-labs/apivault-labs/tree/main/community-nodes/n8n-nodes-apivault-newegg).

These are community packages. Publication on npm does not establish n8n verification or availability in n8n Cloud. Review the linked package README for supported inputs and setup.

# Changelog

This Actor's version history is a separate document: https://apify.com/apivault_labs/newegg-product-scraper/changelog.md

# Actor input Schema

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

Public Newegg.com US product URLs or Item IDs. Canonical duplicates are skipped; an explicit item/Item offer parameter is preserved as its own item. Tracking parameters are removed. Up to 1,000 inputs; maxProducts bounds collection. Empty array gives no products; omitted input uses the shown sample product.

## `extractTitle` (type: `boolean`):

Extract product name / title

## `extractPrice` (type: `boolean`):

Extract current price

## `extractOriginalPrice` (type: `boolean`):

Extract original price before discount

## `extractRating` (type: `boolean`):

Displayed rating text when available; not full reviews or a guarantee of a five-egg value.

## `extractReviewsCount` (type: `boolean`):

Extract number of reviews

## `extractBrand` (type: `boolean`):

Extract brand name

## `extractModel` (type: `boolean`):

Manufacturer model number when displayed. A full technical-specifications table is not returned.

## `extractCategory` (type: `boolean`):

Extract category / breadcrumb

## `extractAvailability` (type: `boolean`):

Displayed availability when available. Blank is unknown, not in stock. Recheck live stock before purchasing.

## `extractSeller` (type: `boolean`):

Seller / merchant name (Newegg or third-party marketplace)

## `extractShipping` (type: `boolean`):

Displayed shipping text when available. Region, seller and checkout can change final shipping charges.

## `extractDescription` (type: `boolean`):

Extract product description

## `extractImage` (type: `boolean`):

Extract main product image URL

## `maxConcurrency` (type: `integer`):

Parallel product scrapes (recommended: 2-3)

## `timeout` (type: `integer`):

Total collection budget per product, including the public page attempt and extraction. Errors are saved without paid product rows.

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

Maximum unique valid products to collect after canonical deduplication. Additional inputs are counted as capped in SUMMARY.

## Actor input object example

```json
{
  "productUrls": [
    "N82E16820232869"
  ],
  "extractTitle": true,
  "extractPrice": true,
  "extractOriginalPrice": true,
  "extractRating": true,
  "extractReviewsCount": true,
  "extractBrand": true,
  "extractModel": true,
  "extractCategory": true,
  "extractAvailability": true,
  "extractSeller": true,
  "extractShipping": true,
  "extractDescription": true,
  "extractImage": true,
  "maxConcurrency": 3,
  "timeout": 180,
  "maxProducts": 100
}
```

# Actor output Schema

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

No description

## `summary` (type: `string`):

No description

## `errors` (type: `string`):

No description

## `retryInput` (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": [
        "N82E16820232869"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("apivault_labs/newegg-product-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": ["N82E16820232869"] }

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

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

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

```

## CLI example

```bash
echo '{
  "productUrls": [
    "N82E16820232869"
  ]
}' |
apify call apivault_labs/newegg-product-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apivault_labs/newegg-product-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/t0oWsDLob7QOPxcCh/builds/2ZEdqlyKzCMEEB3Rh/openapi.json