# Newegg Products Scraper (`fetch_cat/newegg-products-scraper`) Actor

Scrape Newegg search and category listings for product prices, ratings, reviews, sellers, stock text, promos, images, and URLs.

- **URL**: https://apify.com/fetch\_cat/newegg-products-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 90.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 result extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Products Scraper

Extract structured product data from public Newegg search, category, and product pages. Use it to monitor PC hardware prices, compare sellers, track stock and discounts, collect ratings, or build ecommerce intelligence feeds. Direct public requests are the default; bounded retries handle transient timeouts, 429, 5xx, and configured-proxy errors without changing routes automatically.

### At a glance

- Search by one or many keywords, scrape listing URLs, or provide direct product URLs and item IDs.
- Export numeric price, original price, discount, stock, condition, shipping, rating, review, seller, image, and URL fields.
- Optionally enrich listing results with product-page specifications.
- Filter saved rows by minimum and maximum parsed price.
- Deduplicate equivalent sources and product URLs before processing and charging.
- Inspect `RUN_SUMMARY` for retries, failed requests, detail fallbacks, filtered products, and saved products.

### Ready-to-run examples

- [Find RTX 4070 prices on Newegg](https://apify.com/fetch_cat/newegg-products-scraper/examples/find-rtx-4070-prices-on-newegg)
- [Compare gaming laptops by price](https://apify.com/fetch_cat/newegg-products-scraper/examples/compare-gaming-laptops-by-price)
- [Get a Newegg product by item ID](https://apify.com/fetch_cat/newegg-products-scraper/examples/get-newegg-product-by-item-id)
- [Extract Newegg product specifications](https://apify.com/fetch_cat/newegg-products-scraper/examples/extract-newegg-product-specifications)

### What can it do?

Newegg Products Scraper turns public Newegg listings and product pages into analysis-ready product records. It can combine keyword searches, listing URLs, direct product URLs, and item IDs in one deduplicated run.

#### Who is it for

- Ecommerce teams comparing Newegg pricing against other marketplaces
- Resellers and PC builders tracking component prices and availability
- Marketplace analysts watching ratings, review volume, and seller offers
- Data teams that need repeatable JSON, CSV, or Excel exports from Newegg listings

### What you can scrape

- Product titles and Newegg product URLs
- Item numbers / model hints
- Current and original price text
- Numeric price when visible
- Ratings and review counts
- Seller, shipper, availability, and promotion text
- Product images
- Category/breadcrumb context when available
- Optional product-page specification rows
- Numeric original price and discount percentage
- Normalized stock, condition, shipping cost, free-shipping, and ships-by-Newegg fields

### Input examples

#### Search Newegg by keyword

```json
{
  "searchQueries": ["rtx 4070", "gaming laptop"],
  "maxItems": 50,
  "pageLimit": 2,
  "sort": "featured"
}
```

#### Scrape a specific Newegg listing URL

```json
{
  "startUrls": [
    { "url": "https://www.newegg.com/p/pl?d=mechanical+keyboard" }
  ],
  "maxItems": 25,
  "pageLimit": 1
}
```

#### Include extra specification rows

```json
{
  "searchQueries": ["ssd 2tb"],
  "maxItems": 10,
  "includeProductDetails": true
}
```

#### Scrape direct product URLs or item IDs

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

#### Filter listing results by price

```json
{
  "searchQueries": ["gaming laptop"],
  "minPrice": 700,
  "maxPrice": 1200,
  "maxItems": 50,
  "pageLimit": 5
}
```

### Input settings

| Field | Type | Description |
| --- | --- | --- |
| `searchQueries` | array of strings | Newegg keywords to search. |
| `startUrls` | array of URLs | Public Newegg listing/search/category URLs to scrape. |
| `productUrls` | array of strings | Direct Newegg product URLs or item IDs such as `N82E16814932611`. |
| `maxItems` | integer | Maximum product rows to save across all sources. |
| `pageLimit` | integer | Maximum listing pages to scan for each source. |
| `sort` | string | Sort for generated search URLs: `featured`, `lowest_price`, `highest_price`, `best_selling`, `best_rating`, `most_reviews`. |
| `minPrice` / `maxPrice` | number | Optional inclusive price range applied to parsed product prices. |
| `includeProductDetails` | boolean | Visit product pages to collect extra `specs` when available. |
| `maxConcurrency` | integer | Concurrent product-detail requests, from 1 to 10. |
| `requestTimeoutSecs` | integer | Per-request timeout before a bounded retry. |
| `maxRequestRetries` | integer | Retries for configured-proxy errors, timeouts, 429, 5xx, or empty pages. |
| `proxyConfiguration` | object | Optional Apify proxy configuration. Direct public requests are the default. |

Provide at least one `searchQueries`, `startUrls`, or `productUrls` entry. Only public HTTPS Newegg.com URLs are accepted.

### Output example

```json
{
  "query": "rtx 4070",
  "startUrl": "https://www.newegg.com/p/pl?d=rtx+4070",
  "pageUrl": "https://www.newegg.com/p/pl?d=rtx+4070",
  "position": 1,
  "title": "GIGABYTE GeForce RTX 4070 Graphics Card...",
  "productUrl": "https://www.newegg.com/p/N82E16814932611?Item=N82E16814932611",
  "itemNumber": "N82E16814932611",
  "model": "GV-N4070...",
  "price": 549.99,
  "currentPriceText": "$549.99",
  "originalPriceText": null,
  "originalPrice": null,
  "discountPercent": null,
  "rating": 5,
  "reviewCount": 128,
  "availability": "In stock",
  "inStock": true,
  "condition": "New",
  "seller": "Newegg",
  "shipper": null,
  "shippingCost": 0,
  "freeShipping": true,
  "shipsByNewegg": true,
  "promoText": null,
  "imageUrl": "https://c1.neweggimages.com/...jpg",
  "brand": "GIGABYTE",
  "category": "GPUs / Video Graphics Cards",
  "breadcrumbs": ["Components", "GPUs / Video Graphics Cards"],
  "specs": null,
  "scrapedAt": "2026-07-08T08:30:00.000Z"
}
```

### What data can you extract?

| Field group | Output fields |
| --- | --- |
| Source | `query`, `startUrl`, `pageUrl`, `position`, `scrapedAt` |
| Product | `title`, `productUrl`, `itemNumber`, `model`, `brand`, `category`, `breadcrumbs`, `imageUrl` |
| Price | `price`, `currentPriceText`, `originalPrice`, `originalPriceText`, `discountPercent`, `promoText` |
| Reviews | `rating`, `reviewCount` |
| Stock and condition | `availability`, `inStock`, `condition` |
| Seller and shipping | `seller`, `shipper`, `shippingCost`, `freeShipping`, `shipsByNewegg` |
| Product details | `specs` when direct product pages are used or detail enrichment succeeds |

### Pricing

This Actor uses pay-per-event pricing. A run has one small start fee, then charges only for product rows successfully saved to the dataset. Failed requests, retries, filtered products, and product-detail fallbacks do not create `result` charges. The exact per-result price depends on the Apify plan tier.

| Event | Apify tier | Price per event | Approx. per 1,000 |
| --- | --- | ---: | ---: |
| `start` | All tiers | $0.005 | One time per run |
| `result` | Free | $0.000035046 | $0.03505 |
| `result` | Bronze | $0.000030475 | $0.03048 |
| `result` | Silver | $0.00002377 | $0.02377 |
| `result` | Gold | $0.000018285 | $0.01829 |
| `result` | Platinum | $0.00001219 | $0.01219 |
| `result` | Diamond | $0.0000085329 | $0.00853 |

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

### Tips for reliable runs

- Keep `includeProductDetails` off unless you need specifications; listing-only runs are faster.
- Use `maxItems` and `pageLimit` together to control cost and run duration.
- Start with direct public requests. Enable a proxy only when you explicitly need to use a configured route.
- Leave bounded retries enabled; retries stop after the configured limit and never add a new route automatically.
- Use `RUN_SUMMARY` to distinguish no matches, price-filter exclusions, detail fallbacks, and exhausted upstream retries.
- For price monitoring, run the same query URL on a schedule and compare exported datasets.

### Limits and caveats

- Newegg page layout and availability wording can vary by region and seller.
- Some products may not show prices, ratings, reviews, or stock text.
- Newegg or an upstream residential route can still fail after all bounded retries; the run summary records a machine-readable error counter.
- Sponsored and organic products may both appear when Newegg renders them as product cards.
- The actor only extracts public data visible without logging in.

### API usage

Start a run with cURL:

```bash
curl "https://api.apify.com/v2/acts/fetch_cat~newegg-products-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchQueries":["rtx 4070"],"maxItems":25,"pageLimit":1}'
```

Run it from Node.js:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/newegg-products-scraper').call({
  searchQueries: ['rtx 4070'],
  maxItems: 25,
  pageLimit: 1,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems({ clean: true });
console.log(items);
```

Run it from Python:

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/newegg-products-scraper').call(run_input={
    'searchQueries': ['rtx 4070'],
    'maxItems': 25,
    'pageLimit': 1,
})
items = client.dataset(run['defaultDatasetId']).list_items(clean=True).items
print(items)
```

Download dataset items:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=json&clean=true&token=$APIFY_TOKEN"
```

### MCP and agent usage

Use this actor from AI agents through Apify MCP:

```text
https://mcp.apify.com/?tools=fetch_cat/newegg-products-scraper
```

Claude CLI setup:

```bash
claude mcp add apify-newegg "https://mcp.apify.com/?tools=fetch_cat/newegg-products-scraper"
```

JSON MCP server config:

```json
{
  "mcpServers": {
    "apify-newegg": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/newegg-products-scraper"
    }
  }
}
```

Example prompts:

- "Find current Newegg prices and review counts for RTX 4070 graphics cards and return the lowest-priced in-stock items."
- "Track Newegg gaming laptop listings under 1000 USD and summarize sellers, ratings, and promo text."

### Legality and responsible use

This actor extracts publicly visible Newegg listing data. Use the results responsibly, respect applicable laws and Newegg terms, and avoid collecting or storing personal data you do not need.

### FAQ

#### Do I need a Newegg account?

No. The actor is designed for public Newegg listing pages visible without login.

#### Can it scrape product details?

Yes. Add direct URLs or item IDs to `productUrls`, or set `includeProductDetails` to `true` to enrich listing results with `specs`. Product-page requests are slower than listing-only extraction.

#### What if I get no products?

Check `RUN_SUMMARY`, verify that the query or listing URL returns products in your browser, and widen price filters. Configured-proxy errors, 429, timeout, and 5xx responses have bounded retries before the Actor stops.

#### Is this legal?

This actor extracts publicly visible information. You are responsible for using the data in line with applicable laws, Newegg terms, and privacy requirements.

### Related actors

- [AliExpress Products Scraper](https://apify.com/fetch_cat/aliexpress-products-scraper) for marketplace product comparisons.
- [Google Shopping Results Scraper](https://apify.com/fetch_cat/google-shopping-results-scraper) for multi-merchant price research.
- [Walmart Products Scraper](https://apify.com/fetch_cat/walmart-products-scraper) for US retail product and offer data.

### Support

Open an issue from the actor page and include your run ID, run URL, input JSON, a reproducible public URL from Newegg or a search query, expected output, and actual output so we can reproduce the problem.

### Privacy and data handling

This Actor only requests the permissions needed to run the input you provide. It uses your input (such as URLs, search terms, identifiers, filters, and limits) only to fetch the requested public data from the relevant source site or API for this Actor, then writes results to your Apify dataset/key-value store.

Data may pass through Apify platform services and Apify Proxy during the run, and requests are sent only to the target site or public data provider required for this Actor's results. FetchCat does not send your inputs or outputs to advertising networks, data brokers, or model-training services, and does not retain run data outside Apify storage after the run except when you explicitly share run details for transient support debugging.

You are responsible for using this Actor lawfully, respecting the target site's terms, and avoiding unnecessary personal or sensitive data in inputs. Review the output before storing, sharing, or combining it with other data.

# Actor input Schema

## `searchQueries` (type: `array`):

Newegg keywords to search, such as GPU models, laptop types, components, or brands.

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

Optional Newegg search or category URLs. Use this when you already have a Newegg listing page to monitor.

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

Optional Newegg product-page URLs or item IDs such as N82E16814932611. Direct products are deduplicated with products found in listings.

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

Maximum number of product rows to save across all searches and URLs.

## `pageLimit` (type: `integer`):

Maximum listing pages to scan for each search query or start URL.

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

Sort option for generated search query URLs. Start URLs keep their own sort parameters.

## `minPrice` (type: `number`):

Save only products whose parsed USD price is at least this value.

## `maxPrice` (type: `number`):

Save only products whose parsed USD price is at most this value.

## `includeProductDetails` (type: `boolean`):

Also visit product pages to collect extra specification rows when available. This is slower and uses more requests.

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

Maximum product detail requests processed at once. Lower this if the target becomes unstable.

## `requestTimeoutSecs` (type: `integer`):

Maximum time for one Newegg request before a bounded retry.

## `maxRequestRetries` (type: `integer`):

Bounded retries for transient proxy, timeout, CAPTCHA, 429, 5xx, or empty-page responses.

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

Optional proxy configuration. Direct public requests are used by default; enable a proxy only when you explicitly need to use your configured route.

## Actor input object example

```json
{
  "searchQueries": [
    "rtx 4070"
  ],
  "startUrls": [
    {
      "url": "https://www.newegg.com/p/pl?d=gaming+laptop"
    }
  ],
  "maxItems": 20,
  "pageLimit": 3,
  "sort": "featured",
  "includeProductDetails": false,
  "maxConcurrency": 3,
  "requestTimeoutSecs": 25,
  "maxRequestRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "searchQueries": [
        "rtx 4070"
    ],
    "startUrls": [
        {
            "url": "https://www.newegg.com/p/pl?d=gaming+laptop"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/newegg-products-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 = {
    "searchQueries": ["rtx 4070"],
    "startUrls": [{ "url": "https://www.newegg.com/p/pl?d=gaming+laptop" }],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/newegg-products-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 '{
  "searchQueries": [
    "rtx 4070"
  ],
  "startUrls": [
    {
      "url": "https://www.newegg.com/p/pl?d=gaming+laptop"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fetch_cat/newegg-products-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/zved4DbfKGFm6FXSl/builds/rsLc0HSPxvJ9W2kLe/openapi.json