# Newegg Product Scraper (`scrapeworks/newegg-product-scraper`) Actor

Scrape Newegg product listings in bulk: title, brand, price, list price, discount, rating, reviews, shipping, model number, stock and image. Paste category or search URLs (or keywords) and it paginates deep, 96 products per page. Clean JSON/CSV, one row per product. No login.

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

## Pricing

from $3.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.

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/docs.md):

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

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

**Scrape Newegg product listings in bulk — title, brand, price, discount, rating, review count, shipping, model number, stock status and image — from any Newegg category, search or store page.** No login, no API key. Paste the Newegg pages (or keywords) you care about and get one clean row per product, with deep automatic pagination.

Perfect for **price monitoring, competitor research, market/assortment analysis, dropshipping product sourcing, deal tracking, and MAP-price checks** across PC components, laptops, electronics, gaming gear and everything else Newegg sells.

### What you get

One flat, ready-to-use record per product:

| Field | Description |
|---|---|
| `itemNumber` | Newegg item number (e.g. `14-932-753`) — stable product id |
| `title` | Full product title |
| `brand` | Manufacturer / brand (e.g. `GIGABYTE`, `ASUS`) |
| `price` | Current price (number, e.g. `1449.99`) |
| `listPrice` | Original / "was" price when the item is discounted |
| `currency` | Price currency (`USD` on newegg.com) |
| `discountPercent` | Advertised saving, e.g. `18` |
| `rating` | Average star rating out of 5 (e.g. `4.6`) |
| `reviewCount` | Number of customer reviews |
| `shippingText` | Shipping label (e.g. `Free Shipping`, `$19.99 Shipping`) |
| `shippingCost` | Parsed shipping cost (`0.0` for free shipping) |
| `model` | Manufacturer model number |
| `features` | Short spec bullets from the listing card |
| `inStock` | `true` when the card is purchasable (Add to Cart); `false` for Sold Out / Auto Notify / Back Order / Coming Soon |
| `stockStatus` | The availability label for unavailable items (e.g. `Sold Out`, `Auto Notify`, `Back order`); empty when in stock |
| `moreOptions` | "More options from $X – $Y" text when a product has multiple sellers |
| `isSponsored` | `true` if the card is a sponsored/ad placement |
| `imageUrl` | Product image URL |
| `productUrl` | Clean link to the product page |
| `sourceUrl` | The listing URL this product came from |
| `resultPage` | Which result page it was found on |
| `scrapedAt` | ISO 8601 UTC timestamp |

### Input

- **Newegg listing URLs** (`startUrls`) — one or more Newegg pages. Each can be:
  - a **category / subcategory browse** page, e.g. `https://www.newegg.com/Desktop-Graphics-Cards/SubCategory/ID-48` (**most reliable**),
  - a **store or brand-store** page,
  - or a **keyword search** page, e.g. `https://www.newegg.com/p/pl?d=rtx+4090`.
- **Search keywords** (`searchKeywords`, optional) — plain keywords the actor turns into Newegg searches for you (e.g. `rtx 4090`, `ddr5 32gb`).
- **Max results per start URL** / **Max pages per start URL** — how deep to paginate (96 products per page).
- **Max results overall** (optional) — a single cap across everything.
- **Proxy** — leave the default (Apify Residential, US) in place.

Every URL and keyword is **paginated deep automatically** (96 products per page), and products are de-duplicated by item number, so a handful of inputs returns thousands of rows.

> **Tip:** Newegg's category / subcategory / store *browse* pages are the most reliable source. Newegg guards its keyword-search route more aggressively; the actor still scrapes it (routing through the residential proxy on a block), but if a keyword returns few rows, grab the matching **category browse URL** instead — open newegg.com, click into the category, and copy that page's URL.

#### Example input

```json
{
  "startUrls": [
    "https://www.newegg.com/Desktop-Graphics-Cards/SubCategory/ID-48",
    "https://www.newegg.com/Laptops-Notebooks/SubCategory/ID-32"
  ],
  "searchKeywords": ["mechanical keyboard", "nvme ssd 2tb"],
  "maxResultsPerUrl": 300,
  "maxPagesPerUrl": 10
}
````

### Output sample

```json
{
  "itemNumber": "14-202-457",
  "title": "SAPPHIRE PULSE Radeon RX 9060 XT 16GB GDDR6 PCI Express 5.0 x16 ATX Graphics Card 11350-03-20G",
  "brand": "Sapphire Tech",
  "price": 469.99,
  "listPrice": 498.49,
  "currency": "USD",
  "discountPercent": 5,
  "rating": 4.7,
  "reviewCount": 121,
  "shippingText": "Free Shipping",
  "shippingCost": 0.0,
  "model": "11350-03-20G",
  "features": ["Model #: 11350-03-20G"],
  "inStock": true,
  "stockStatus": null,
  "moreOptions": null,
  "isSponsored": false,
  "imageUrl": "https://c1.neweggimages.com/productimage/nb300/14-202-457-01.jpg",
  "productUrl": "https://www.newegg.com/sapphire-tech-pulse-11350-03-20g-radeon-rx-9060-xt/p/N82E16814202457",
  "sourceUrl": "https://www.newegg.com/Desktop-Graphics-Cards/SubCategory/ID-48",
  "resultPage": 1,
  "scrapedAt": "2026-07-19T12:00:00+00:00"
}
```

Export the whole dataset as **JSON, CSV, Excel, or feed it to an API** — Apify handles the format.

### Use cases

- **Price & MAP monitoring** — track prices and discounts across a category on a schedule.
- **Competitor & market research** — pull an entire category (GPUs, laptops, SSDs…) and analyse brands, price bands and ratings.
- **Product sourcing / dropshipping** — build a catalog with images, models and prices ready to import.
- **Deal hunting** — filter the output for the biggest `discountPercent` or best rating-per-dollar.

### FAQ

**Do I need a Newegg login or API key?** No. The actor reads public listing pages.

**Which URLs work best?** Category / subcategory / store *browse* pages (they're server-rendered and most reliable). Keyword search also works but guards harder — the actor routes it through the residential proxy automatically.

**How many products can I get?** Newegg serves 96 per page and categories run to dozens of pages, so tens of thousands of products per run is normal. Use *Max results* / *Max pages* to bound a run.

**What currency are prices in?** USD (newegg.com US). Keep the proxy country set to US.

**How is it billed?** Pay per result — you're charged once per product returned. Blocked or empty pages are never charged.

**Some products have no rating or brand — why?** Products with no customer reviews have no rating/review count, and a few listings don't expose a brand link. Those fields are left empty for that product; it's a gap in Newegg's own listing, not a scraping error.

# Actor input Schema

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

One or more newegg.com listing pages to scrape. Each can be a category or subcategory 'browse' page (e.g. https://www.newegg.com/Desktop-Graphics-Cards/SubCategory/ID-48), a store or brand-store page, or a keyword search-results page (e.g. https://www.newegg.com/p/pl?d=rtx+4090). To get a URL: open newegg.com, browse or search to the products you want, and copy the page URL from your browser. Every URL is paginated DEEP automatically (96 products per page), so a few URLs return thousands of rows. Category / subcategory / store browse URLs are the MOST RELIABLE input; keyword-search pages guard harder and are routed through the proxy on a block. Results are billed per product, so more URLs = more rows.

## `searchKeywords` (type: `array`):

Optional convenience: keywords to search Newegg for (each becomes a https://www.newegg.com/p/pl?d=<keyword> search and is paginated deep). Newegg's keyword-search route guards harder than its category pages, so results here run through the residential proxy on a block; if you get few/no rows for a keyword, use the matching category/subcategory 'browse' URL in the Newegg listing URLs field instead (that path is the most reliable).

## `maxResultsPerUrl` (type: `integer`):

Maximum products to return for EACH start URL or keyword. The actor paginates automatically (96 products per page). Set high to pull a whole category; lower it to sample.

## `maxPagesPerUrl` (type: `integer`):

Hard limit on how many result pages to fetch per start URL (a safety cap on top of Max results per start URL). Newegg serves 96 products per page, so 100 pages is roughly 9,600 products. The actor also stops automatically at the listing's real last page.

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

Optional overall cap across ALL start URLs and keywords combined. Leave empty for no overall cap (each URL is still bounded by Max results / Max pages per URL). Useful to cap total billed rows for a run.

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

Fallback proxy for reaching newegg.com. The actor fetches DIRECTLY first with a real Chrome TLS fingerprint (Newegg's server-rendered category/browse pages return fine this way) and only routes through this proxy - rotating exits - if a request is blocked (e.g. on Newegg's stricter keyword-search route). The default (Apify Residential, US) is a safe fallback; leave it in place. Keep the country US so prices stay in USD.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.newegg.com/Desktop-Graphics-Cards/SubCategory/ID-48",
    "https://www.newegg.com/Laptops-Notebooks/SubCategory/ID-32",
    "https://www.newegg.com/p/pl?d=mechanical+keyboard"
  ],
  "searchKeywords": [
    "rtx 4090",
    "ddr5 32gb",
    "nvme ssd 2tb"
  ],
  "maxResultsPerUrl": 5000,
  "maxPagesPerUrl": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "startUrls": [
        "https://www.newegg.com/Desktop-Graphics-Cards/SubCategory/ID-48"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeworks/newegg-product-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": ["https://www.newegg.com/Desktop-Graphics-Cards/SubCategory/ID-48"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapeworks/newegg-product-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 '{
  "startUrls": [
    "https://www.newegg.com/Desktop-Graphics-Cards/SubCategory/ID-48"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call scrapeworks/newegg-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Newegg Product Scraper",
        "description": "Scrape Newegg product listings in bulk: title, brand, price, list price, discount, rating, reviews, shipping, model number, stock and image. Paste category or search URLs (or keywords) and it paginates deep, 96 products per page. Clean JSON/CSV, one row per product. No login.",
        "version": "0.1",
        "x-build-id": "StjsmV6LGcYNsFxAB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeworks~newegg-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeworks-newegg-product-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/scrapeworks~newegg-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeworks-newegg-product-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/scrapeworks~newegg-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeworks-newegg-product-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": {
                    "startUrls": {
                        "title": "Newegg listing URLs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "One or more newegg.com listing pages to scrape. Each can be a category or subcategory 'browse' page (e.g. https://www.newegg.com/Desktop-Graphics-Cards/SubCategory/ID-48), a store or brand-store page, or a keyword search-results page (e.g. https://www.newegg.com/p/pl?d=rtx+4090). To get a URL: open newegg.com, browse or search to the products you want, and copy the page URL from your browser. Every URL is paginated DEEP automatically (96 products per page), so a few URLs return thousands of rows. Category / subcategory / store browse URLs are the MOST RELIABLE input; keyword-search pages guard harder and are routed through the proxy on a block. Results are billed per product, so more URLs = more rows.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchKeywords": {
                        "title": "Search keywords (optional)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional convenience: keywords to search Newegg for (each becomes a https://www.newegg.com/p/pl?d=<keyword> search and is paginated deep). Newegg's keyword-search route guards harder than its category pages, so results here run through the residential proxy on a block; if you get few/no rows for a keyword, use the matching category/subcategory 'browse' URL in the Newegg listing URLs field instead (that path is the most reliable).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerUrl": {
                        "title": "Max results per start URL",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum products to return for EACH start URL or keyword. The actor paginates automatically (96 products per page). Set high to pull a whole category; lower it to sample.",
                        "default": 5000
                    },
                    "maxPagesPerUrl": {
                        "title": "Max pages per start URL",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard limit on how many result pages to fetch per start URL (a safety cap on top of Max results per start URL). Newegg serves 96 products per page, so 100 pages is roughly 9,600 products. The actor also stops automatically at the listing's real last page.",
                        "default": 100
                    },
                    "maxResults": {
                        "title": "Max results overall (optional)",
                        "minimum": 1,
                        "maximum": 500000,
                        "type": "integer",
                        "description": "Optional overall cap across ALL start URLs and keywords combined. Leave empty for no overall cap (each URL is still bounded by Max results / Max pages per URL). Useful to cap total billed rows for a run."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Fallback proxy for reaching newegg.com. The actor fetches DIRECTLY first with a real Chrome TLS fingerprint (Newegg's server-rendered category/browse pages return fine this way) and only routes through this proxy - rotating exits - if a request is blocked (e.g. on Newegg's stricter keyword-search route). The default (Apify Residential, US) is a safe fallback; leave it in place. Keep the country US so prices stay in USD.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
