# Newegg Scraper (`s-r/newegg-scraper`) Actor

Search Newegg and get product rows: current price, previous price, the saving in dollars and percent, rating, review count, shipping and free-shipping flag, brand, model and Newegg's item number, plus the spec line parsed into fields. Deals-only mode included.

- **URL**: https://apify.com/s-r/newegg-scraper.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** E-commerce, Business
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 run start fees

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/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 Scraper

Search Newegg and get the results back as rows: current price, **the previous price where there is one**, the saving in dollars and percent, rating, shipping and the full spec line parsed into fields.

No login, no cookie, no API key. It reads the ordinary search grid from a US exit.

### What you get

- **A discount feed, not a price snapshot.** Newegg is one of the few US retailers that publishes a struck-through price in its search grid, so one run gives you `price`, `was_price`, `discount_amount` and `discount_percent` without opening a single product page
- **`deals_only`**, which returns nothing but genuine markdowns
- **Discounts that are actually discounts.** Newegg renders the previous-price element on every card whether or not there is a value in it. Counting elements says every product is on sale; this actor parses the value and checks it is above the current price before calling it one
- **The spec line parsed into fields.** `specs` turns Newegg's run-on `Processor Name: ... Memory: ... SSD: ... Brand: ...` string into labelled values, and `model` comes out of it on essentially every row
- **Rating and review count**, read from the rating link's own title attribute
- **Shipping wording plus a `free_shipping` flag**
- **Newegg's item number** on every row, stable across runs, so consecutive runs diff cleanly

### Why Newegg

For US computer hardware, Newegg is the price reference. GPUs, CPUs, motherboards, laptops and components move on price there faster than almost anywhere, and the site itself tells you what a thing used to cost.

That last part is what makes the listing page worth reading. Most retail scrapers give you a price and leave you to build your own history before you can say whether it is a good one. Newegg publishes the comparison itself, so the very first run already answers "is this cheap right now" for a whole category. With `deals_only` set, a scheduled run becomes an alert feed rather than a dataset you still have to analyse.

### Input

| Field | Type | Required | Default | What it does |
|---|---|---|---|---|
| `query` | string | one of the two | `laptop` | What to search for |
| `url` | string | one of the two | – | A newegg.com search or category URL. Takes precedence |
| `deals_only` | boolean | no | `false` | Return only genuinely discounted products |
| `price_min` | integer | no | – | Lower bound in dollars |
| `price_max` | integer | no | – | Upper bound in dollars |
| `limit` | integer | no | `50` | Products to return, 1 to 800. A page carries about 42 |
| `retries` | integer | no | `3` | Retry attempts per page |

### Output

```json
{
  "position": 3,
  "item_number": "N82E16834360431",
  "url": "https://www.newegg.com/acer-america-aspire-go-15/p/N82E16834360431",
  "title": "Acer Aspire Go 15 15.6\" FHD AMD Ryzen 7 5825U 48GB DDR4 512GB PCIe Gen4 SSD",
  "brand": "Acer",
  "model": "AG15-31P-30E4",
  "part_number": null,
  "price": 714.99,
  "was_price": 999.99,
  "discount_amount": 285.0,
  "discount_percent": 28.5,
  "currency": "USD",
  "shipping": "Free Shipping",
  "free_shipping": true,
  "rating": 4.3,
  "reviews_count": 98,
  "specs": {
    "Processor Name": "AMD Ryzen 7 5825U",
    "Memory": "48GB DDR4",
    "SSD": "512GB PCIe Gen4"
  },
  "image": "https://c1.neweggimages.com/...",
  "query": "laptop"
}
```

### Use cases

**A deals alert for a category.** Schedule your category with `deals_only` on and alert when a row appears whose `discount_percent` clears your threshold. Nothing has to be stored between runs for this to work, because the comparison is in the data.

**Competitive price tracking.** `item_number` is stable, so diffing `price` per item across runs gives you a price history. `was_price` tells you whether a drop is a real promotion or a quiet reprice.

**Component sourcing.** `specs` carries processor, memory, storage and GPU as separate fields, so a search for laptops can be filtered on RAM without reading titles.

**Matching against your own catalogue.** `model` is present on essentially every row and `part_number` where Newegg publishes it, which are far better join keys than a title.

**Watching how deep a category discounts.** Run it broad and take the distribution of `discount_percent`. A category where the median markdown is climbing is one where somebody is clearing stock.

### How it compares

| | this actor | `kawsar/newegg-product-scraper` | `apivault_labs/newegg-product-scraper` |
|---|---|---|---|
| Per 1.000 products | **$2,00** | no per-item rate | $3,00 |
| Previous price and saving | **yes** | not stated | not stated |
| Deals-only mode | **yes** | no | no |
| Spec line parsed into fields | **yes** | no | no |
| Monthly users | new | **7** | 3 |

Honest about the other side: `kawsar` has seven monthly users to this actor's none, and charges nothing per row, so on a large run it is cheaper. Eleven Newegg actors exist and none has broken seven monthly users, so nobody in this category has proven much.

### Pricing

Two events. `run_start` costs $0,0010 per run. `product` costs $0,0020 per product written to the dataset, which is $2,00 per 1.000. Pages that stay blocked never reach the dataset and are never billed. All pricing is pay-per-event.

### Limits and gotchas

- **`brand` and `part_number` are sparse by Newegg's choice.** Roughly a fifth of cards carry a brand in the spec line and about one in eighteen a part number. `model` is the field that is nearly always present. The run summary reports the coverage.
- **The previous-price element is always rendered.** Its presence is not a discount; only a parsed value above the current price counts. `discounted` in the summary is the real number.
- **`specs` only recognises labels Newegg actually uses.** The spec line has no delimiter between pairs, so "Color: Pike Silver Model #: X" is ambiguous from the text alone. An unrecognised label stays inside the previous value rather than inventing a field, which is why `features` is also returned verbatim.
- **Ratings exist on about a third of rows**, because much of Newegg's catalogue is new or low-traffic.
- **US only.** Results are US-based and prices come back in dollars. Newegg's other storefronts are not covered.
- **A search term with no hits still returns a page.** It comes back as `no_results` rather than an empty success.

### FAQ

**Can I get Newegg discounts without opening every product page?**
Yes, that is the point of this actor. The struck-through price is in the search grid, so one page of results yields about 42 products with their previous prices.

**How do I get only the products on sale?**
Set `deals_only`. Rows without a genuine previous price above the current one are dropped.

**Why do most products have no brand?**
Because Newegg only puts a brand into the card's spec line on some listings. Use `model`, which is present on essentially every row.

**Is `was_price` reliable?**
It is whatever Newegg printed as the previous price, filtered so it must be above the current one. It is a retailer's claim, not an independently verified history.

**How many products can I get in one run?**
Up to 800, about 19 pages.

### Related Actors

- [Amazon Buy Box Monitor](https://apify.com/s-r/amazon-buybox) — who currently wins an Amazon listing, across 15 marketplaces
- [eMAG Scraper](https://apify.com/s-r/emag-scraper) — the same job for Romania, Bulgaria and Hungary
- [Beslist.nl Scraper](https://apify.com/s-r/beslist-scraper) — Dutch price comparison with EAN barcodes

# Actor input Schema

## `query` (type: `string`):

What to search for on newegg.com. Optional if you pass a URL instead.

## `url` (type: `string`):

A newegg.com search or category URL to read instead of a term. Paste it from your browser after applying any filters. Takes precedence.

## `deals_only` (type: `boolean`):

Drop everything that does not carry a genuine struck-through price above the current one.

## `price_min` (type: `integer`):

Lower price bound in US dollars.

## `price_max` (type: `integer`):

Upper price bound in US dollars.

## `limit` (type: `integer`):

How many products to return, 1 to 800. A page carries about 42.

## `retries` (type: `integer`):

Retry attempts per page, each with a rotated user agent and TLS fingerprint.

## Actor input object example

```json
{
  "query": "laptop",
  "url": "https://www.newegg.com/p/pl?d=graphics+card",
  "deals_only": false,
  "limit": 50,
  "retries": 3
}
```

# Actor output Schema

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

One row per product, with its current and previous price where Newegg publishes one.

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

Products returned, pages fetched, how many are genuinely discounted, and rating, part-number and shipping coverage.

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

Per-page failures with a code and a redacted message.

# 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 = {
    "query": "laptop",
    "limit": 50,
    "retries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/newegg-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 = {
    "query": "laptop",
    "limit": 50,
    "retries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("s-r/newegg-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 '{
  "query": "laptop",
  "limit": 50,
  "retries": 3
}' |
apify call s-r/newegg-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/newegg-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/1lo55l6l0oHZcYBd4/builds/kgHutHL06bUH3sQVV/openapi.json