# Newegg Scraper (`solidcode/newegg-scraper`) Actor

\[💰 $5 / 1K] Extract Newegg products — titles, brands, item numbers, prices, sale prices, shipping, ratings, review counts, images, sellers, and stock. Search by keyword or paste search, category, brand, store, or product URLs.

- **URL**: https://apify.com/solidcode/newegg-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

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

Pull product data from Newegg at scale — titles, brands, item numbers, current and original prices, computed discounts, shipping, star ratings, review counts, sellers, and live stock status across the entire US catalog of components, laptops, peripherals, and electronics. Search by keyword or paste any Newegg search, category, brand, store, or product URL. Built for price-monitoring teams, deal aggregators, e-commerce analysts, and resellers who need fresh, structured Newegg pricing without babysitting a fragile in-house collector.

### Why This Scraper?

- **14 structured fields on every product** — title, brand, item number, price, original price, discount, currency, shipping, rating, review count, in-stock status, seller, image, and direct URL, in clean flat rows ready for a spreadsheet.
- **Original price plus an auto-computed discount** — every on-sale product surfaces its pre-discount price and the savings as "23% off", an instant-rebate amount, or the live promo text, so you spot real deals without doing the math.
- **Six named sort modes** — Featured Items, Lowest Price, Highest Price, Best Selling, Best Rating, and Most Reviews, applied across search, category, brand, and store pages.
- **First-party vs. marketplace seller on every row** — the `seller` field reads "Newegg" for first-party stock or the exact marketplace seller name, so you can separate Newegg-shipped inventory from third-party listings.
- **Price-range and in-stock filters applied to every result** — set a minimum and maximum dollar amount and an in-stock-only toggle once and they hold across the full listing, not just the first page.
- **Star rating and review count for social proof** — pull the average rating and the number of reviews on each product to rank by popularity or filter out untested items.
- **Newegg item number for exact SKU matching** — every row carries the official Newegg item code (e.g. `N82E16814126751`), the reliable key for joining against your own catalog or re-pulling a specific product.
- **Five URL types accepted** — paste search-result, category, brand, store, or individual product URLs; listing pages expand into their full product grid and product URLs return that one item directly.
- **US-wide catalog coverage** — graphics cards, CPUs, motherboards, SSDs, gaming laptops, monitors, and peripherals across Newegg's full United States storefront.

### Use Cases

**Price Monitoring & Repricing**
- Track GPU, CPU, and SSD prices across the catalog day over day
- Watch original-vs-current price to catch flash sales and rebates
- Feed live competitor pricing into your own repricing engine
- Alert when a target item drops below a set price

**Deal & Coupon Sites**
- Surface the steepest percentage-off products with the discount field
- Sort by Best Selling to populate "trending deals" pages
- Build category-specific deal feeds (gaming, storage, networking)
- Flag instant-rebate and promo-tagged items automatically

**Market & Competitor Research**
- Compare brand presence and pricing within a category
- Measure first-party vs. marketplace seller mix on a product line
- Benchmark a competitor's catalog by pasting their store page
- Track review counts and ratings to gauge product traction

**Reselling & Sourcing**
- Find in-stock components under a target buy price
- Identify high-rating, high-review products with healthy margins
- Monitor stock status to source items the moment they return
- Pull marketplace seller listings for arbitrage analysis

**Inventory & Catalog Tracking**
- Keep a live mirror of pricing and stock for chosen item numbers
- Enrich an existing product database with ratings and images
- Detect when watched SKUs go out of stock or come back

### Getting Started

#### Search by Keyword

The simplest run — one keyword, default cap:

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

#### Filter by Price and Stock

Find in-stock graphics cards in a target price band, cheapest first:

```json
{
    "searchQueries": ["graphics cards"],
    "minPrice": 500,
    "maxPrice": 1500,
    "inStockOnly": true,
    "sortBy": "lowest-price",
    "maxResults": 200
}
```

#### Paste Newegg URLs

Mix a category listing with an individual product page:

```json
{
    "startUrls": [
        "https://www.newegg.com/p/pl?d=nvme%20ssd",
        "https://www.newegg.com/asus-geforce-rtx-5090/p/N82E16814126751"
    ],
    "sortBy": "most-reviews",
    "maxResults": 300
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | string\[] | `["graphics cards"]` | Keywords to search on Newegg. Each keyword runs its own search and collects matching products. Use specific terms like "rtx 4090" or "gaming laptop". Leave empty if you are pasting URLs. |
| `startUrls` | string\[] | `[]` | Newegg URLs to scrape. Supports search-result, category, brand, store, and individual product pages. Listing pages expand into their products; product pages are scraped directly. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `minPrice` | integer | *none* | Only include products priced at or above this amount, in US dollars. Leave empty for no minimum. |
| `maxPrice` | integer | *none* | Only include products priced at or below this amount, in US dollars. Leave empty for no maximum. |
| `inStockOnly` | boolean | `false` | Only include products currently in stock and available to order. |
| `sortBy` | select | `Featured Items` | Order products are collected in: Featured Items, Lowest Price, Highest Price, Best Selling, Best Rating, or Most Reviews. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum products to return per search keyword or URL. Set to 0 for unlimited. Individual product URLs always return their one product. |

### Output

Each product is one flat row. Here's a representative result:

```json
{
    "title": "ASUS ROG Astral GeForce RTX 5090 OC Edition 32GB GDDR7 Graphics Card",
    "brand": "ASUS",
    "itemNumber": "N82E16814126751",
    "price": 2799.99,
    "originalPrice": 3199.99,
    "discount": "13% off",
    "currency": "USD",
    "shipping": "Free Shipping",
    "rating": 4.6,
    "reviewCount": 97,
    "inStock": true,
    "seller": "Newegg",
    "image": "https://c1.neweggimages.com/ProductImage/14-126-751-V01.jpg",
    "url": "https://www.newegg.com/asus-geforce-rtx-5090/p/N82E16814126751"
}
```

#### Output Fields

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Full product name |
| `brand` | string | Manufacturer / brand (e.g. ASUS, Samsung, Intel) |
| `itemNumber` | string | Official Newegg item number for exact SKU matching |
| `price` | number | Current price in USD |
| `originalPrice` | number | List / pre-discount price when the product is on sale |
| `discount` | string | Savings as a percentage, instant-rebate amount, or promo text, when present |
| `currency` | string | Currency code (USD) |
| `shipping` | string | Shipping cost text (e.g. "Free Shipping", "$5.99") |
| `rating` | number | Average star rating (e.g. 4.6) |
| `reviewCount` | integer | Number of customer reviews |
| `inStock` | boolean | Whether the product is currently in stock |
| `seller` | string | "Newegg" for first-party stock, or the marketplace seller name |
| `image` | string | Primary product image URL |
| `url` | string | Direct Newegg product page URL |

### Tips for Best Results

- **Use specific keywords** — search "rtx 4090" or "gaming laptop", not a bare department name like "graphics card". Broad single-word department terms can land on a Newegg landing page instead of a product list.
- **Pair price filters with a Lowest Price sort** — Newegg returns products in the order you choose, so a `minPrice`/`maxPrice` band reaches its matches fastest when collected cheapest-first instead of by Featured Items.
- **Use Most Reviews to surface established products** — sorting by review count brings battle-tested, high-confidence items to the top, ideal for sourcing or building "best of" lists.
- **Paste a category URL with filters already applied** — set up a filtered view on Newegg (brand, price, attributes), then paste that URL; the actor preserves those category parameters and expands the full filtered grid.
- **Start small to test** — set `maxResults` to 20–50 on your first run to confirm the data matches your needs, then scale up.
- **Combine keywords and URLs** — run several search keywords and several Newegg URLs in a single job; each gets its own result cap. Overlapping keywords (for example "rtx 4090" and "geforce") can return the same product in more than one search, so a product may appear more than once across the dataset.
- **Read the seller field for sourcing** — filter rows where `seller` is "Newegg" for first-party stock, or keep the named marketplace sellers when you want third-party listings.

### Pricing

**From $5.00 per 1,000 results** — pay only for the products you collect, with no monthly rental. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.60 | $0.57 | $0.53 | $0.50 |
| 1,000 | $6.00 | $5.65 | $5.30 | $5.00 |
| 10,000 | $60.00 | $56.50 | $53.00 | $50.00 |
| 100,000 | $600.00 | $565.00 | $530.00 | $500.00 |

A "result" is any product row in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate price monitoring, market research, and competitive analysis. Users are responsible for complying with applicable laws and Newegg's Terms of Service. Collect only publicly available product information, respect reasonable request volumes, and do not use extracted data for spam or any unlawful purpose.

# Actor input Schema

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

Keywords to search on Newegg, such as 'graphics cards' or 'nvme ssd'. Each keyword runs its own search and collects matching products. Tip: use specific terms (e.g. 'rtx 4090', 'gaming laptop') — a bare department name like 'graphics card' can land on a category page instead of a product list. Leave empty if you are pasting URLs below.

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

Paste Newegg URLs. Supported: search result pages, category pages, brand pages, seller/store pages, and individual product pages. Search, category, brand, and store pages are expanded into their product listings; product page URLs are scraped directly. Leave empty if you are using search keywords above.

## `minPrice` (type: `integer`):

Only include products priced at or above this amount, in US dollars. Leave empty for no minimum.

## `maxPrice` (type: `integer`):

Only include products priced at or below this amount, in US dollars. Leave empty for no maximum.

## `inStockOnly` (type: `boolean`):

Only include products that are currently in stock and available to order.

## `sortBy` (type: `string`):

Order in which products are collected from search, category, brand, and store pages.

## `maxResults` (type: `integer`):

Maximum number of products to return per search keyword or URL. Set to 0 for unlimited. Individual product page URLs always return their one product regardless of this setting.

## Actor input object example

```json
{
  "searchQueries": [
    "graphics cards"
  ],
  "startUrls": [],
  "sortBy": "featured",
  "maxResults": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of scraped products with key fields.

# 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": [
        "graphics cards"
    ],
    "startUrls": [],
    "inStockOnly": false,
    "sortBy": "featured",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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": ["graphics cards"],
    "startUrls": [],
    "inStockOnly": False,
    "sortBy": "featured",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/newegg-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": [
    "graphics cards"
  ],
  "startUrls": [],
  "inStockOnly": false,
  "sortBy": "featured",
  "maxResults": 100
}' |
apify call solidcode/newegg-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Newegg Scraper",
        "description": "[💰 $5 / 1K] Extract Newegg products — titles, brands, item numbers, prices, sale prices, shipping, ratings, review counts, images, sellers, and stock. Search by keyword or paste search, category, brand, store, or product URLs.",
        "version": "1.0",
        "x-build-id": "LuTXyoFSYjsoCwECH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~newegg-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-newegg-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/solidcode~newegg-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-newegg-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/solidcode~newegg-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-newegg-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": {
                    "searchQueries": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Keywords to search on Newegg, such as 'graphics cards' or 'nvme ssd'. Each keyword runs its own search and collects matching products. Tip: use specific terms (e.g. 'rtx 4090', 'gaming laptop') — a bare department name like 'graphics card' can land on a category page instead of a product list. Leave empty if you are pasting URLs below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Newegg URLs",
                        "type": "array",
                        "description": "Paste Newegg URLs. Supported: search result pages, category pages, brand pages, seller/store pages, and individual product pages. Search, category, brand, and store pages are expanded into their product listings; product page URLs are scraped directly. Leave empty if you are using search keywords above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minPrice": {
                        "title": "Minimum Price ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include products priced at or above this amount, in US dollars. Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "Maximum Price ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include products priced at or below this amount, in US dollars. Leave empty for no maximum."
                    },
                    "inStockOnly": {
                        "title": "In Stock Only",
                        "type": "boolean",
                        "description": "Only include products that are currently in stock and available to order."
                    },
                    "sortBy": {
                        "title": "Sort Results By",
                        "enum": [
                            "featured",
                            "lowest-price",
                            "highest-price",
                            "best-selling",
                            "best-rating",
                            "most-reviews"
                        ],
                        "type": "string",
                        "description": "Order in which products are collected from search, category, brand, and store pages.",
                        "default": "featured"
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of products to return per search keyword or URL. Set to 0 for unlimited. Individual product page URLs always return their one product regardless of this setting.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
