# Newegg Scraper \[$0.85/1K💰] | Prices, Sellers & Stock Data (`ahmed_jasarevic/newegg-scraper`) Actor

Scrape Newegg search, category and product data - price, list price, promo codes, eggs rating, stock quantity, Newegg-vs-marketplace seller, shipping cost, brand and model. Uses Newegg's own API, no browser.

- **URL**: https://apify.com/ahmed_jasarevic/newegg-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.75 / 1,000 results

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

Scrape **Newegg search results, category listings and full product specs** as structured JSON — current price, list price, promo codes, instant rebate, eggs rating, stock quantity, whether Newegg or a marketplace seller fulfills the order, shipping cost, brand, model, UPC and category. Built for price trackers, deal aggregators, PC-hardware market research and competitor pricing.

Runs entirely over **Newegg's own JSON-RPC API** — no browser, no captcha, no scraping of protected HTML.

### What you get

#### Price tracking with the discount actually broken out

Not just "is it cheaper" — the detail record gives you `price`, `listPrice`, `discountAmount`, `discountPercent`, `promoText`, `instantRebate` and `lowestPrice30Days`. That last field is the one that makes historical deal analysis possible: you can tell whether today's price is genuinely low against the item's own 30-day floor, instead of only against a stale list price.

#### Newegg seller vs marketplace seller, resolved

`sellerType` is derived, not copied: `shipByNewegg === true`, or no seller name at all, or an empty `sellerId` all resolve to `"Newegg"`; anything else is `"Marketplace"`. Plus `seller`, `sellerId`, `sellerRating`, `sellerRatingCount`, `shipsFromCountry` and `shipByNewegg`. This is the field that distinguishes a genuine Newegg deal from a third-party marketplace listing wearing the same price — and third-party sellers are exactly where fulfilment and return policy get worse.

#### Stock state as a real enum, not a boolean

`stockStatus` is resolved to `in_stock`, `out_of_stock`, `preorder` or `restricted`, from `Instock`, `Stock`, `CanPreorder`, `IsPreLaunch`, `WebsiteBlockMark` and `RestrictedItemMark` together. Keep `stockQuantity` (`Qty`) and `limitQuantity` (`LimitQuantity`) alongside it, because `in_stock` with `limitQuantity: 5` is a different commercial fact from `in_stock` with `limitQuantity: null`.

#### Shipping cost per offer, with a free-shipping flag

`shippingCost` and `freeShipping` are per-offer, not per-store — the same product has different shipping depending on the seller. `freeShipping` is true when shipping resolves to 0 *or* the item carries Newegg's free-shipping flag, so it survives both API paths.

#### Every image size without re-fetching

`image` (compressed), `imageOriginal` (the `CompressAll0` → `Original` rewrite), and `images[]` — the full gallery parsed from Newegg's comma-separated `ImageNameList`, each resolved against `c1.neweggimages.com`.

#### Detail records rich enough for a catalog database

`brand`, `model`, `manufacturerPartNumber`, `upc`, `category`, `categoryId`, `subcategory`, `isRefurbished`, `isOpenBoxed`, `availabilityRank` (best-selling rank), `merchantScore`, `eggsRating`, `eggSaverMark`, `viewCount` and `shipOutTimeUnit`. `upc` plus `manufacturerPartNumber` is what makes cross-site product matching possible.

### How it works

`www.newegg.com` sits behind Cloudflare — direct HTML fetches return **403**. Newegg does, however, publish its own JSON-RPC tool API at `apis.newegg.com`, the same surface it exposes to AI shopping assistants. The Actor calls that directly, so **no HTML is scraped and no browser ever loads**.

Every call is a JSON-RPC 2.0 `tools/call` POST carrying an `x-skill: newegg-product-search` header:

| Purpose | Endpoint | Tool | Page size |
| --- | --- | --- | --- |
| Keyword search | `apis.newegg.com/ex-mcp/endpoint/product-search` | `newegg product search` | 30 |
| Category browse | `apis.newegg.com/ex-mcp/endpoint/website-www-tool` | `getapi_store_specifiedstore_catalog` | 96 |
| Product detail | `apis.newegg.com/ex-mcp/endpoint/website-www-tool` | `getapi_item_detail` | **8 items per request** |

Three input modes feed one queue, then dedupe on `itemNumber` and enrich:

- **`searchQueries`** → paginated keyword search, with `order`, `minPrice` and `maxPrice` pushed server-side.
- **`categoryUrls`** → the `N=` category id and store id are parsed out of the URL, so you paste a normal Newegg category link. The trailing `?N=9` is optional.
- **`itemNumbers`** → direct detail lookups; full product URLs are accepted too, and the item number is extracted.

#### The batching detail that makes detail mode affordable

Detail is **not** one request per product. `DETAIL_BATCH = 8`, so 100 products with `detail: true` costs about 13 detail requests, not 100 — roughly an **8× request reduction** versus naive per-product fetching. The Actor also skips items it already has detail for, so overlapping `searchQueries` and `categoryUrls` don't double-charge you.

The Actor explicitly discards the empty stub Newegg returns for unknown item numbers — a record with neither a title nor a price is dropped rather than pushed as junk.

#### Request budgeting you can predict

Given `itemCap`, `wantDetail` and `pageSize`, the Actor computes expected requests up front: listing pages, plus `ceil(pageSize / 8)` detail requests per page, plus `ceil(directItems / 8)` for direct lookups. Result pages stop paginating once `maxItems` is reached, or when the source runs out — `TotalItemCount` bounds category pagination.

### Input

| Field | Type | Default | Notes |
| --- | --- | --- | --- |
| `searchQueries` | string\[] | `["rtx 4090"]` | Keyword searches. Each is paginated independently. |
| `categoryUrls` | string\[] | `[]` | Newegg category/store URLs; `N=` and store id are parsed from them. |
| `itemNumbers` | string\[] | `[]` | Specific item numbers or full product URLs for detail lookup. |
| `detail` | boolean | `true` | Enrich every discovered item with full detail. `false` returns listing-level fields only. |
| `maxItems` | integer | `100` | Hard cap on dataset rows. |
| `order` | integer | `8` | Search sort: `1` Best Rating, `2` Lowest Price, `3` Highest Price, `4` Most Reviews, `6` Name A→Z, `7` Name Z→A, `8` Featured, `14` Release Date, `15` Best Selling, `16` Seller Rating, `22` Sales Volume. |
| `minPrice` / `maxPrice` | number | — | Inclusive price filter, applied server-side. |
| `storeSource` | string | `"1"` | Category listing source: `1` Best Selling, `2` Lowest Price. |
| `countryCode` | string | `"USA"` | Newegg storefront country code. |
| `companyCode` | integer | `1003` | Newegg company code. `1003` = Newegg.com. |
| `proxy` | object | `{ "useApifyProxy": false }` | Standard Apify proxy picker. |

All three source fields are optional, but supply at least one or the run produces no products. They combine: pass `searchQueries` *and* `categoryUrls` to union both sources into one deduplicated queue.

### Output

One flat dataset. Records come in two shapes depending on `detail`, sharing `itemNumber` and `url` so you can join or upgrade later.

#### Detail record — 48 fields

`itemNumber`, `title`, `brand`, `model`, `manufacturerPartNumber`, `upc`, `price`, `listPrice`, `discountAmount`, `discountPercent`, `promoText`, `instantRebate`, `lowestPrice30Days`, `mapPrice`, `finalPrice`, `unitCost`, `currency`, `eggsRating`, `eggSaverMark`, `merchantScore`, `rating`, `reviewCount`, `viewCount`, `inStock`, `stockStatus`, `stockQuantity`, `limitQuantity`, `seller`, `sellerId`, `sellerType`, `shipByNewegg`, `sellerRating`, `sellerRatingCount`, `shipsFromCountry`, `shippingCost`, `freeShipping`, `shipOutTimeUnit`, `image`, `imageOriginal`, `images`, `url`, `category`, `categoryId`, `subcategory`, `isRefurbished`, `isOpenBoxed`, `availabilityRank`, `scrapedAt`

#### Listing record — 12 fields

Returned only when `detail: false`:

`itemNumber`, `title`, `url`, `image`, `price`, `listPrice`, `discountPercent`, `discountText`, `rating`, `reviewCount`, `currency`, `isRefurbished`

Field notes that change how you read the data:

- **`discountText` exists only on listing records**; `discountAmount` and `promoText` only on detail records. Filter by whether `brand` is present to tell them apart, or check for `stockStatus`.
- `currency` is always `"USD"` on detail records — Newegg's US storefront. `countryCode` selects the storefront, but the currency field is hardcoded, so **do not treat it as authoritative for non-US storefronts**.
- `price` and `finalPrice` can differ. `price` is the resolved current price through the fallback chain (including `UnitCost`); `finalPrice` and `unitCost` are the raw API fields. `mapPrice` is Newegg's price-match reference.
- `images[]` is empty when Newegg exposes no gallery list — it is not a failed parse.
- `imageOriginal` is derived by string-rewriting the compressed image URL, so it can be absent where `image` exists.

### Example input

Keyword search, cheapest first:

```json
{
  "searchQueries": ["rtx 4090"],
  "order": 2,
  "maxItems": 100
}
```

Full-spec catalog build in a price band:

```json
{
  "searchQueries": ["nvme 2tb ssd"],
  "minPrice": 100,
  "maxPrice": 400,
  "detail": true,
  "maxItems": 500
}
```

Browse a category, best selling, no detail calls:

```json
{
  "categoryUrls": ["https://www.newegg.com/p/N82E16817159011"],
  "storeSource": "1",
  "detail": false,
  "maxItems": 500
}
```

Specific products by item number or URL:

```json
{
  "itemNumbers": ["20-147-903", "https://www.newegg.com/p/9SIAD8JHV287"],
  "detail": true
}
```

Union a search and a category in one run:

```json
{
  "searchQueries": ["rtx 4090"],
  "categoryUrls": ["https://www.newegg.com/p/N82E16819159011"],
  "order": 15,
  "detail": true,
  "maxItems": 300
}
```

### Example output

```json
{
  "itemNumber": "20-147-903",
  "title": "NVIDIA GeForce RTX 4090 24GB GDDR6X Graphics Card",
  "brand": "NVIDIA",
  "model": "GeForce RTX 4090",
  "manufacturerPartNumber": "900-1G144-2530-000",
  "upc": "195893028201",
  "price": 1649.99,
  "listPrice": 1899.99,
  "discountAmount": 250,
  "discountPercent": 13,
  "promoText": "Save $250 with instant rebate",
  "instantRebate": 250,
  "lowestPrice30Days": 1599.99,
  "mapPrice": 1699.99,
  "finalPrice": 1649.99,
  "unitCost": 1649.99,
  "currency": "USD",
  "eggsRating": 4.8,
  "eggSaverMark": 1,
  "merchantScore": 92,
  "rating": 4.7,
  "reviewCount": 312,
  "viewCount": 18422,
  "inStock": true,
  "stockStatus": "in_stock",
  "stockQuantity": 41,
  "limitQuantity": 2,
  "seller": "Newegg",
  "sellerId": null,
  "sellerType": "Newegg",
  "shipByNewegg": true,
  "sellerRating": 4.8,
  "sellerRatingCount": 18422,
  "shipsFromCountry": "US",
  "shippingCost": 0,
  "freeShipping": true,
  "shipOutTimeUnit": "days",
  "image": "https://c1.neweggimages.com/NeweggImage/ProductImageCompressAll/20-147-903-01.jpg",
  "imageOriginal": "https://c1.neweggimages.com/NeweggImage/ProductImageOriginal/20-147-903-01.jpg",
  "images": [
    "https://c1.neweggimages.com/NeweggImage/ProductImageCompressAll/20-147-903-01.jpg",
    "https://c1.neweggimages.com/NeweggImage/ProductImageCompressAll/20-147-903-02.jpg"
  ],
  "url": "https://www.newegg.com/p/20-147-903",
  "category": "Graphics Cards",
  "categoryId": "1583",
  "subcategory": "NVIDIA GeForce RTX 4090",
  "isRefurbished": false,
  "isOpenBoxed": false,
  "availabilityRank": 4,
  "scrapedAt": "2026-10-04T06:12:41.220Z"
}
```

### Integrations & automation

Call it over the Apify API (`POST /v2/acts/B6PjkefnUOQwWi5Lx/runs`), or from Python, JavaScript, the CLI or MCP. Output exports as JSON, CSV, Excel, XML or RSS.

For **price tracking**, run daily on a fixed `searchQueries` set with `order: 2` and upsert on `itemNumber`; alert when `price` drops below `lowestPrice30Days` or when `stockStatus` leaves `in_stock`. For **deal feeds**, filter `discountPercent >= 20` and `sellerType == "Newegg"` to guarantee Newegg-fulfilled deals. For **catalog builds**, `categoryUrls` plus `storeSource: "2"` gives cheapest-first ordering for assortment planning.

Typical pipeline: run on schedule → upsert on `itemNumber` → keep a `price`/`listPrice` history table → alert on `lowestPrice30Days` breaches → join against your own cost data. No browser means runs are fast and cheap, so hourly polling of a small basket is practical.

#### What a run costs

| Configuration | Results | Cost |
| --- | --- | --- |
| Listing-only, `detail: false`, 100 products | 100 × result | **$0.085** |
| Detail, 100 products (≈13 detail requests) | 100 × result | **$0.085** |
| 1,000 products, listing-only | 1,000 × result | **$0.85** |

**$0.00085 per result.** Detail batching means cost tracks *products pushed to the dataset*, not API requests — a detail run of the same 100 products costs exactly the same as a listing-only run of 100. Free accounts get a small trial quota; paying accounts get full `maxItems`, and tiered rates go lower on higher plans.

### Related Actors

| Actor | Why |
| --- | --- |
| [`amazon-scraper`](https://apify.com/ahmed_jasarevic/amazon-scraper) | The other half of PC-hardware price comparison — run both and diff `price`, `listPrice` and seller on the same `upc`. |
| [`walmart-scraper`](https://apify.com/ahmed_jasarevic/walmart-scraper) | Mass-market electronics pricing and stock, for cross-retailer spread analysis. |
| [`best-buy-scraper`](https://apify.com/ahmed_jasarevic/best-buy-scraper) | Consumer-electronics competitor with its own marketplace sellers. |
| [`micro-center-scraper`](https://apify.com/ahmed_jasarevic/micro-center-scraper) | PC-hardware specialist, useful for builder-component price checks. |
| [`cargurus-scraper`](https://apify.com/ahmed_jasarevic/cargarus-scraper) | Same marketplace-listing shape on a different vertical, with seller detail records. |

### FAQ

#### Why not scrape the Newegg HTML directly?

Because you can't reliably. `www.newegg.com` is behind Cloudflare and returns **403** to plain HTTP fetches, which is exactly why this Actor uses plain HTTP against Newegg's own JSON-RPC API instead. You get the same underlying data — and more, since the detail endpoint exposes fields the HTML does not render cleanly — without a headless browser.

#### Do I need a browser, a captcha solver or a proxy?

No to all three. The API is called directly with a JSON-RPC POST, there is no rendering challenge, and `proxy` defaults to `{ "useApifyProxy": false }`. Enable a proxy only if you plan sustained high-volume runs.

#### Why is `detail: true` the same price as `detail: false`?

Because billing is **per result pushed to the dataset**, not per API request, and detail records cost the same as listing records. Detail mode looks expensive until you notice it batches 8 item numbers per request — 100 products cost about 13 detail requests, not 100. Turning detail *off* saves money only when you want fewer products; it never saves money per product.

#### `currency` says USD but I set a different `countryCode`. Why?

Because `currency` is hardcoded to `"USD"` on detail records. `countryCode` selects the storefront you query, but Newegg's response field is not authoritative across storefronts. Treat `currency` as a US-storefront assumption and do not use it for non-US price normalisation.

#### Newegg says "Sold and shipped by Newegg" but `sellerType` says "Marketplace". Why?

Because `sellerType` is derived from `shipByNewegg`, the seller name and `sellerId` — and for marketplace offers Newegg still fulfils some orders while a third party is the merchant of record. Where the badge and the merchant disagree, `sellerType` follows the merchant, because that's who your return window and dispute path actually run through. Trust `shipByNewegg` for logistics and `sellerType` for the merchant relationship; keep both.

#### What does `stockStatus: "restricted"` mean?

That Newegg flagged the item as restricted or region/age/blocked (`WebsiteBlockMark` or `RestrictedItemMark`). It is deliberately distinct from `out_of_stock` — a restricted item exists and has a price, but cannot be ordered. Don't fold it into "unavailable" in stock reporting, or you'll understate how much catalogue is gated rather than sold out.

#### `images` is empty. Did it fail?

No. The gallery is parsed from Newegg's comma-separated `ImageNameList`, which some listings simply don't provide. Empty `images[]` alongside a populated `image` is normal, not a parse error.

### SEO Keywords

newegg scraper, newegg api, pc hardware price tracker, gpu price tracking, newegg deals, electronics price comparison, computer parts database, product catalog data, marketplace seller analysis, stock monitoring, gpu stock tracker, deal aggregator data, product price history, newegg vs marketplace, hardware market research, build a pc parts database, cross retailer price comparison, refurbished gpu prices, pc component pricing, newegg product data, ecommerce product scraping, product catalog api, price drop alerts

### For AI Agents & LLM Apps

Returns Newegg products as **one flat dataset** with 48 fields per detail record, or 12 per listing record when `detail: false`.

**Minimal input** — smallest input that produces a valid run:

```json
{ "searchQueries": ["rtx 4090"] }
```

**Listing-only sweep** (cheapest per product, no enrichment):

```json
{ "searchQueries": ["nvme ssd"], "detail": false, "maxItems": 500 }
```

**Full detail, price band**:

```json
{ "searchQueries": ["rtx 4090"], "minPrice": 1000, "maxPrice": 2500, "detail": true, "maxItems": 200 }
```

**Specific products only**:

```json
{ "itemNumbers": ["20-147-903"], "detail": true }
```

**Output fields — detail record (48):** itemNumber, title, brand, model, manufacturerPartNumber, upc, price, listPrice, discountAmount, discountPercent, promoText, instantRebate, lowestPrice30Days, mapPrice, finalPrice, unitCost, currency, eggsRating, eggSaverMark, merchantScore, rating, reviewCount, viewCount, inStock, stockStatus, stockQuantity, limitQuantity, seller, sellerId, sellerType, shipByNewegg, sellerRating, sellerRatingCount, shipsFromCountry, shippingCost, freeShipping, shipOutTimeUnit, image, imageOriginal, images, url, category, categoryId, subcategory, isRefurbished, isOpenBoxed, availabilityRank, scrapedAt

**Output fields — listing record (12):** itemNumber, title, url, image, price, listPrice, discountPercent, discountText, rating, reviewCount, currency, isRefurbished

**Behaviours an agent should know**

- **Billing is per dataset result ($0.00085), not per API request.** `detail: true` costs the same per product as `detail: false` — it just adds fields. Turn detail *off* only to reduce product count, never to save per-product money.
- **Detail batches 8 items per request.** A 100-product detail run is ~13 detail requests. Budget by products, not calls.
- **Record shape depends on `detail`.** Detail records have `brand`, `stockStatus`, `sellerType`; listing records don't. To tell them apart programmatically, test for `brand` or `stockStatus` being present.
- **Field availability is asymmetric.** `discountText` is listing-only; `discountAmount`/`promoText` are detail-only. Don't write one parser expecting both.
- Supply at least one of `searchQueries`, `categoryUrls`, or `itemNumbers` — all empty produces no products.
- Sources union into one queue and dedupe on `itemNumber`, so overlapping `searchQueries` + `categoryUrls` don't duplicate rows or double-bill.
- `currency` is hardcoded `"USD"` regardless of `countryCode`. Do not use it to normalise non-US storefront prices.
- `stockStatus` is one of `in_stock`, `out_of_stock`, `preorder`, `restricted`. Keep `restricted` separate from `out_of_stock` — it's a gated item, not a sold-out one.
- `sellerType` is `"Newegg"` or `"Marketplace"`, derived from `shipByNewegg` / seller id. Keep `shipByNewegg` too; they answer different questions (merchant vs fulfilment).
- Empty stub responses for unknown item numbers are discarded, not pushed. Missing `images[]` is normal.
- Proxy is off by default. No browser is used or needed.
- Free accounts have a small trial quota; paid accounts get full `maxItems` with tiered rates.

### Legal & Compliance

This Actor is an independent third-party tool. It is not affiliated with, endorsed by, or sponsored by Newegg, Inc.

**What it actually accesses:** Newegg's own published JSON-RPC tool API at `apis.newegg.com` — the endpoint Newegg exposes for its own AI shopping integrations — via JSON-RPC `tools/call` POSTs carrying an `x-skill` header identifying the calling skill. It does **not** scrape or bypass the Cloudflare-protected HTML of `www.newegg.com`, does not log in, does not bypass any authentication, and does not solve captchas. No browser is used.

**What it does not do:** it never attempts to defeat the 403 on the HTML site, never authenticates as a customer or seller, and never circumvents access controls. All data comes from the endpoint Newegg publishes for machine consumption.

**Still your responsibility.** Being a machine-readable endpoint does not by itself grant unrestricted commercial redistribution rights. Review Newegg's Terms of Use, its Partner/affiliate terms and your own legal advice before you resell, republish or build a competing product on this data. Newegg's own Terms restrict scraping, and their robots and API policies apply to you directly regardless of what this tool does.

**Product data and trademarks.** Product titles, images, specifications and brand names are Newegg's and their suppliers'. Brand names (NVIDIA, AMD, Intel, Samsung and others) are trademarks of their respective owners; use them descriptively and don't imply endorsement.

**No personal data.** Output is product and seller-business data. `sellerRating` and `sellerRatingCount` describe a merchant business, not an individual. There is no consumer personal data in the output.

You are solely responsible for compliance with Newegg's Terms of Use, applicable law, and any retailer agreements you have entered into.

# Actor input Schema

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

Keyword searches against Newegg, e.g. \["rtx 4090", "nvme ssd"]. Each query is paginated.

## `categoryUrls` (type: `array`):

Newegg category / store URLs. The `N=` value and the store id are parsed from the URL, e.g. https://www.newegg.com/p/N82E16817159011?N=9

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

Specific Newegg item numbers (or full product URLs) to fetch in detail, e.g. \["20-147-903"].

## `detail` (type: `boolean`):

When true (default) every discovered item is enriched via Newegg's item-detail API, which adds brand, model, list price, stock, seller and shipping cost. When false only the listing-level fields are returned.

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

Maximum number of products to push to the dataset. Result pages are paginated automatically until this many products are collected, or the source runs out of results.

## `order` (type: `integer`):

Keyword search sort order: 1-Best Rating, 2-Lowest Price, 3-Highest Price, 4-Most Reviews, 6-Name A→Z, 7-Name Z→A, 8-Featured (default), 14-Release Date, 15-Best Selling, 16-Seller Rating, 22-Sales Volume.

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

Minimum price filter (inclusive).

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

Maximum price filter (inclusive).

## `storeSource` (type: `string`):

For category URLs: 1 = Best Selling (default), 2 = Lowest Price.

## `countryCode` (type: `string`):

Newegg storefront country code.

## `companyCode` (type: `integer`):

Newegg company code. 1003 = Newegg.com.

## `proxy` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "searchQueries": [
    "rtx 4090"
  ],
  "detail": true,
  "maxItems": 100,
  "order": 8,
  "storeSource": "1",
  "countryCode": "USA",
  "companyCode": 1003,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 4090"
    ],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/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 = {
    "searchQueries": ["rtx 4090"],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/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 '{
  "searchQueries": [
    "rtx 4090"
  ],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/newegg-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/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/B6PjkefnUOQwWi5Lx/builds/wtxzpq1CjAtgpf8Pz/openapi.json