# Ebay Scraper (`scrapier/ebay-scraper`) Actor

🛒 eBay Scraper extracts product listings, prices, sellers, ratings, images & specs from eBay at scale. ⚡ Export CSV/JSON, API-ready, schedule crawls, monitor price & stock, track keywords & categories. 🔍 Ideal for market research, competitor analysis & e‑commerce insights.

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

## Pricing

from $5.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### Ebay Scraper

Ebay Scraper is an Apify actor that turns public eBay.com listings into clean, structured product data at scale. It solves the hassle of manual copy‑paste by extracting real-time titles, prices, availability, seller info, images, and item specifics from both search results and individual item pages. Built for marketers, developers, data analysts, and researchers, this eBay product scraper lets you scrape eBay listings reliably and export them to CSV/JSON for analysis or automation via the eBay scraper API — enabling large-scale eBay product data extraction and repeatable workflows.

### What data / output can you get?

Below are examples of the structured fields this eBay data scraper returns. Results are written to the Apify dataset, which you can export as JSON, CSV, or Excel.

| Data field | Description | Example value |
| --- | --- | --- |
| url | Canonical product URL (input or discovered listing) | https://www.ebay.com/itm/314567890123 |
| itemNumber | eBay item ID from the listing URL | 314567890123 |
| title | Product title from the listing | Ergonomic Office Chair with Lumbar Support |
| subTitle | Subtitle or short descriptor if available | Adjustable height, breathable mesh — Black |
| price | Numeric price (float) | 129.99 |
| priceWithCurrency | Price as displayed with currency code/symbol | US $129.99 |
| wasPrice | Previous/strike-through price if present | 199.99 |
| wasPriceWithCurrency | Previous price with currency | US $199.99 |
| available | Quantity available (if detected) | 12 |
| availableText | Availability text as shown on page | More than 10 available |
| sold | Sold count parsed from the buy box area | 254 |
| image | Primary image URL from JSON‑LD | https://i.ebayimg.com/images/g/abcd/s-l1600.jpg |
| seller | Seller username extracted from the page | top_seller_store |
| itemLocation | Location string (city, state/country) | Los Angeles, California, United States |
| brand | Brand value from item specifics (defaults to “Unbranded” if missing) | Unbranded |
| type | Product type/model/department if available | Office Chair |
| categories | Breadcrumb category names | ["Home & Garden", "Furniture", "Chairs"] |
| ean | EAN/GTIN when provided (null if not applicable) | 1234567890123 |
| mpn | MPN when provided (null if not applicable) | ABC-1234 |
| upc | UPC value or “Does not apply” if not provided | 887276345678 |
| whyToBuy | Shipping/returns/benefits snippets (up to 12 lines) | ["Free shipping", "30-day returns", "Ships in 24 hours"] |

Notes:
- Extra rows may be added with an error field when a listing doesn’t load (e.g., CAPTCHA, removed item).  
- Bonus metadata such as categories and item specifics enhance downstream analytics (e.g., eBay price scraper workflows).

### Key features

- 🔎 Discovery from search results
  Extracts product links from search pages (s-item__link, regex /itm/, s-item__info fallback), normalizes them to https://www.ebay.com/itm/<id>, and de-duplicates — ideal when you need an eBay search results scraper.

- 🧠 Accurate product parsing
  Full HTML parsing with JSON‑LD, buy box, and item specifics to capture prices, was prices, sold/availability, seller data, location, brand/UPC/EAN/MPN/type — a robust eBay listing scraper for product data extraction.

- 🛰️ Smart request & headers strategy
  Uses impit (Chrome TLS/HTTP fingerprint) with realistic browser headers for reliable eBay web scraping at scale.

- 🛡️ Resilient proxy fallback
  Starts direct (no proxy). On block, automatically falls back to Apify datacenter (group “SHADER”), then residential (group “RESIDENTIAL”) with up to 3 attempts. After a successful residential response, it sticks to residential for subsequent requests.

- ⚡ Parallelized collection with live saves
  Fetches multiple listings concurrently and streams rows to the dataset as they’re processed — perfect for time-sensitive eBay sales data scraper use cases.

- 🧰 Developer-friendly & API-ready
  Built with the Apify SDK for Python. Access results via the Apify API and integrate with your pipeline or eBay scraper Python workflows.

- 📤 Flexible exports
  Export your dataset to JSON, CSV, or Excel for BI tools, enrichment, or dashboards — a production-ready eBay scraping tool for analysis.

### How to use Ebay Scraper - step by step

1. Create or log in to your Apify account.
2. Open the Ebay Scraper actor in your Apify workspace.
3. Add input:
   - Paste one or more eBay URLs into urls (supports both search/category URLs and direct item URLs).
4. (Optional) Set maxItems to cap how many products to collect after discovery.
5. (Optional) Configure proxyConfiguration if you want to control Apify Proxy behavior or country routing.
6. Start the run. The actor will:
   - Discover product links from each search URL.
   - Collect product details from each listing and save rows live to the output dataset.
7. Monitor progress in logs (you’ll see Step 1/2 discovery and Step 2/2 collection, with item snapshots as they’re saved).
8. Download results from the dataset in JSON/CSV/Excel or access them via the Apify API.

Pro Tip: Use search results URLs to cast a wide net across many listings, then filter or join by itemNumber in your data warehouse for ongoing monitoring.

### Use cases

| Use case | Description |
| --- | --- |
| Market research & price tracking | Compare titles, prices, was prices, and availability by category to monitor trends using an eBay price scraper workflow. |
| Competitor analysis | Collect seller names, sold counts, and item specifics to benchmark competitors with an eBay seller data scraper. |
| Catalog enrichment | Enrich your catalog with brand, UPC/EAN/MPN, and categories for better matching and attribution across channels. |
| Data analytics & dashboards | Export JSON/CSV and feed BI tools to analyze product performance and inventory signals at scale. |
| API pipelines & automation | Trigger runs via the Apify API and pipe structured results into your systems for automated eBay product data extraction. |
| Academic & consumer research | Study category distributions, pricing patterns, and availability across segments using an eBay search results scraper. |

### Why choose Ebay Scraper?

Built for precision, reliability, and automation, this eBay scraper tool delivers structured product data without the instability of browser extensions.

- 🎯 Precise extraction: Combines JSON‑LD with targeted HTML parsing of the buy box and item specifics for consistent fields.
- ⚡ Scalable by design: Parallel fetching with live dataset saves supports large batches and repeated runs.
- 💻 Developer-ready: Implementable in any stack via the Apify API; built on the Apify SDK for Python for smooth integration.
- 🛡️ Robust against blocks: Direct → SHADER → RESIDENTIAL fallback with sticky residential after success for resilient runs.
- 📦 Easy exporting: Download your results as JSON, CSV, or Excel for immediate use in analytics and ops.
- 🔍 Comparison-ready: Includes sold counts, was prices, and availability text for deeper insights than typical scrapers.
- ✅ Safer alternative: Avoid brittle browser extensions and manual copy‑paste with a production-ready eBay scraper API workflow.

### Is it legal / ethical to use Ebay Scraper?

Yes — when done responsibly. This actor extracts data from publicly visible eBay listings and does not access authenticated or private areas.

Guidelines for compliant use:
- Scrape only public product pages and respect applicable laws (e.g., GDPR, CCPA).
- Avoid collecting personal or private data.
- Review and respect eBay’s terms; usage remains your responsibility.
- Consult your legal team for edge cases or large-scale, cross-border projects.

### Input parameters & output format

Example JSON input
```json
{
  "urls": [
    "https://www.ebay.com/sch/i.html?_nkw=massage+chair&_sacat=6024",
    "https://www.ebay.com/itm/314567890123"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

Parameter reference

- urls (array, required): Add one or many eBay links — search/category pages for discovery or single listing pages for full details. Paste full URLs from your browser.
  - Default: none
- maxItems (integer, optional): Cap how many product pages to collect after discovery. Use 0 for no limit.
  - Default: 20
- proxyConfiguration (object, optional): Apify Proxy settings for smoother runs and country routing as needed.
  - Default: { "useApifyProxy": true }

Example JSON output

```json
[
  {
    "url": "https://www.ebay.com/itm/314567890123",
    "categories": ["Home & Garden", "Furniture", "Chairs"],
    "itemNumber": "314567890123",
    "title": "Ergonomic Office Chair with Lumbar Support",
    "subTitle": "Adjustable height, breathable mesh — Black",
    "whyToBuy": ["Free shipping", "30-day returns", "Ships in 24 hours"],
    "price": 129.99,
    "priceWithCurrency": "US $129.99",
    "wasPrice": 199.99,
    "wasPriceWithCurrency": "US $199.99",
    "available": 12,
    "availableText": "More than 10 available",
    "sold": 254,
    "image": "https://i.ebayimg.com/images/g/abcd/s-l1600.jpg",
    "seller": "top_seller_store",
    "itemLocation": "Los Angeles, California, United States",
    "ean": "1234567890123",
    "mpn": "ABC-1234",
    "upc": "887276345678",
    "brand": "Unbranded",
    "type": "Office Chair"
  },
  {
    "url": "https://www.ebay.com/itm/123456789012",
    "error": "unavailable"
  }
]
```

Notes:

- ean and mpn may be null when not present on the page.
- upc returns “Does not apply” if no usable value is available.
- brand defaults to “Unbranded” when not specified by the seller.

### FAQ

#### Do I need to log in or provide cookies to scrape eBay?

No. The actor targets publicly visible eBay.com pages and does not require login or cookies.

#### Can it scrape both search results and individual listings?

Yes. Provide search/category URLs to discover multiple product links, or direct item URLs (…/itm/…) for single-product extraction.

#### What fields does it collect from each listing?

It returns titles, prices (with currency), previous/strike-through prices when available, availability (numeric and text), sold counts, primary image, seller, item location, brand, type, categories, and identifiers like UPC/EAN/MPN. See the Output section for a full example.

#### How many items can I scrape in one run?

Use maxItems to cap the number of product pages processed after discovery. Set 0 for no limit.

#### How does the proxy fallback work if eBay blocks requests?

The actor starts without a proxy, then falls back to Apify datacenter (group “SHADER”), and then to residential (group “RESIDENTIAL”) with up to 3 attempts. After a successful residential response, it sticks to residential for subsequent requests.

#### Does it support API access and automation?

Yes. Results are saved to an Apify dataset, accessible via the Apify API. This makes it straightforward to integrate into pipelines as an eBay scraper API or with eBay scraper Python workflows.

#### What export formats are supported?

You can export the Apify dataset to JSON, CSV, or Excel for downstream analytics, BI tools, or enrichment.

#### Which eBay sites are supported?

This actor targets eBay.com listings and normalizes item URLs to https://www.ebay.com/itm/<id>. Use eBay.com search and item links for best results.

### Final thoughts

Ebay Scraper is built to deliver accurate, structured eBay product data for analysis and automation. With resilient discovery, reliable parsing, and flexible exports, it empowers marketers, developers, analysts, and researchers to build repeatable eBay listing scraper workflows. Call it via the Apify API, export JSON/CSV to your data stack, and start scaling your eBay web scraping with confidence.

# Actor input Schema

## `urls` (type: `array`):

🗺️ Add one or many eBay links — mix & match as you like!

🔎 Search / category pages → we’ll discover products from the results grid.

🏷️ Single listing pages → we’ll grab that item’s full details.

✅ Paste full URLs from your browser; that’s all you need to get started.

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

📊 Set a ceiling on how many product pages to process after URL discovery — great for quick samples or budget-friendly runs.

0️⃣ Use 0 for no limit (go as far as your inputs allow).

⚡ Lower = faster & lighter; higher = broader coverage.

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

🛡️ Optional Apify Proxy settings for smoother runs when the target site is picky about traffic.

✨ Tune country or groups in the proxy editor if your use case needs it — especially for international or large-scale jobs.

💚 Leave defaults if you’re unsure; you can always rerun with adjustments.

## Actor input object example

```json
{
  "urls": [
    "https://www.ebay.com/sch/i.html?_from=R40&_trksid=p2499334.m570.l1313&_nkw=massage%2Brecliner%2Bchair&_sacat=6024"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "urls": [
        "https://www.ebay.com/sch/i.html?_from=R40&_trksid=p2499334.m570.l1313&_nkw=massage%2Brecliner%2Bchair&_sacat=6024"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapier/ebay-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 = {
    "urls": ["https://www.ebay.com/sch/i.html?_from=R40&_trksid=p2499334.m570.l1313&_nkw=massage%2Brecliner%2Bchair&_sacat=6024"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapier/ebay-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 '{
  "urls": [
    "https://www.ebay.com/sch/i.html?_from=R40&_trksid=p2499334.m570.l1313&_nkw=massage%2Brecliner%2Bchair&_sacat=6024"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapier/ebay-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ebay Scraper",
        "description": "🛒 eBay Scraper extracts product listings, prices, sellers, ratings, images & specs from eBay at scale. ⚡ Export CSV/JSON, API-ready, schedule crawls, monitor price & stock, track keywords & categories. 🔍 Ideal for market research, competitor analysis & e‑commerce insights.",
        "version": "1.0",
        "x-build-id": "ZyTf1wWerGVGKlXM0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapier~ebay-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapier-ebay-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/scrapier~ebay-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapier-ebay-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/scrapier~ebay-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapier-ebay-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",
                "required": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "Where should we look?",
                        "type": "array",
                        "description": "🗺️ Add one or many eBay links — mix & match as you like!\n\n🔎 Search / category pages → we’ll discover products from the results grid.\n\n🏷️ Single listing pages → we’ll grab that item’s full details.\n\n✅ Paste full URLs from your browser; that’s all you need to get started.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Cap how many products to collect",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "📊 Set a ceiling on how many product pages to process after URL discovery — great for quick samples or budget-friendly runs.\n\n0️⃣ Use 0 for no limit (go as far as your inputs allow).\n\n⚡ Lower = faster & lighter; higher = broader coverage.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Connection & reliability (optional)",
                        "type": "object",
                        "description": "🛡️ Optional Apify Proxy settings for smoother runs when the target site is picky about traffic.\n\n✨ Tune country or groups in the proxy editor if your use case needs it — especially for international or large-scale jobs.\n\n💚 Leave defaults if you’re unsure; you can always rerun with adjustments."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
