# 🛍️ eBay Product Details Scraper (`scraper-engine/ebay-product-details-scraper`) Actor

🛍️ eBay Product Details Scraper grabs rich listing data in one click — titles, prices, images, specs, seller & shipping, variations, stock, category, ratings & reviews. ⚡ Fast, API-ready. Export CSV/JSON. 🔍 Ideal for market research, price tracking, SEO, analytics & dropshipping.

- **URL**: https://apify.com/scraper-engine/ebay-product-details-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (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 $4.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 Product Details Scraper

The 🛍️ eBay Product Details Scraper is an Apify actor that turns public eBay item URLs into clean, structured data for analytics, catalogs, and monitoring. It solves the manual effort of copy-paste by extracting titles, prices, images, seller info, shipping and delivery snippets, return policy text, descriptions, item specifics, and more in bulk. Built for marketers, developers, data analysts, and researchers, this eBay product data scraper delivers repeatable results you can export to CSV/JSON/Excel and plug into workflows at scale.

### What data / output can you get?

| Data field | Description | Example value |
|---|---|---|
| seller_name | Seller/store display name | "best-tech-store" |
| seller_items_sold | Sales volume hint parsed from page text | "1.2K" |
| positive_feedback | Seller feedback summary | "99.8% positive" |
| product_title | Listing title (from page header/meta) | "Sony WH-1000XM5 Wireless Noise-Canceling Headphones" |
| product_price | Price string detected on the page | "$299.99" |
| product_condition | Item condition badge/text | "Brand New" |
| product_image | Array of product image URLs (hi-res when available) | ["https://i.ebayimg.com/images/g/abc/s-l1600.jpg", "..."] |
| shipping_info | Shipping location/restriction/price snippets | "Free shipping via USPS Priority" |
| delivery_info | Delivery estimate or destination snippet | "Estimated delivery Fri, May 10" |
| return_policy | Return policy summary extracted from page | "30-day returns. Buyer pays for return shipping." |
| item_number | eBay item number parsed from page | "396090328598" |
| item_description | Main description (frame-loaded content when available) | "Experience industry-leading noise cancellation..." |
| item_specifics | Key/value map of item attributes | {"Brand": "Sony", "Model": "WH-1000XM5", "Connectivity": "Bluetooth"} |
| detail_url | Canonical detail URL of the item | "https://www.ebay.com/itm/396090328598" |
| source_url | The input URL that produced the row | "https://www.ebay.com/itm/396090328598" |
| success | Success flag for the row | true |
| proxyMode | How the page was fetched | "direct" |
| scrapedAt | ISO timestamp when the row was written | "2026-04-21T10:22:33Z" |
| error | Present only for failures with a short message | "Could not fetch or parse listing" |

Notes:
- Rows are written as each listing finishes, so the OUTPUT dataset updates in near real time during a run.
- Export your dataset to JSON, CSV, or Excel from the Apify Console or via the Apify API.

### Key features

- ⚡️ Bold proxy strategy for reliability — Starts with a direct request, then (when Apify Proxy is enabled) escalates to datacenter and residential with retries; after the first successful residential fetch, it stays residential-only for the rest of the run.
- 📦 Bulk eBay URLs — Paste many item links at once for true eBay bulk product scraper workflows.
- 🧩 Structured, analytics-ready output — Consistent fields for an eBay listing details scraper: title, price, images, item specifics, seller signals, delivery/return snippets, and more.
- 🔌 Integration-friendly exports — Download as JSON/CSV/Excel or pipe the dataset into your stack via the Apify API; ideal as an eBay product data API alternative.
- 🛡️ Optional Apify Proxy — Tune access for stable cloud scraping; disable for direct-only environments.
- 👨‍💻 Developer-ready — Works smoothly with APIs and eBay product scraper Python pipelines; designed for ETL and data engineering use cases.
- 🚀 Transparent logs and run metadata — Each row can include success flags, source URL, proxy mode, and scrape timestamp to simplify monitoring and QA.
- 🌐 No login required — Targets public eBay item pages only; does not access private or authenticated content.

### How to use 🛍️ eBay Product Details Scraper - step by step

1. Create or log in to your Apify account.
2. Open Apify Console and locate “🛍️ eBay Product Details Scraper” (or your fork).
3. Add your input in the Run configuration:
   - Paste one or more eBay item URLs into urls (string list).
   - Optionally configure proxyConfiguration. By default (prefill), Apify Proxy is enabled.
4. Start the run. The actor first tries a direct request; if blocked and Apify Proxy is enabled, it escalates to datacenter and then residential proxies with retries.
5. Watch the Logs for progress and proxy mode transitions (direct → datacenter → residential, then sticky residential).
6. Browse intermediate results in the OUTPUT tab as items finish — records are pushed in real time.
7. Export your dataset to JSON, CSV, or Excel, or fetch via the Apify API for downstream processing.

Pro Tip: For automation, trigger runs via the Apify API and connect outputs to your data warehouse or apps. This is ideal for eBay product catalog scraper pipelines and recurring price tracking.

### Use cases

| Use case | Description |
|---|---|
| Market research + assortment analysis | Aggregate eBay listing details to compare brands, models, and attributes across categories for trend analysis. |
| Price and availability tracking | Scrape eBay product details regularly to monitor price changes, stock signals, shipping, and return policy shifts. |
| SEO and content enrichment | Enrich product catalogs with titles, item specifics, and descriptions to improve onsite search and SEO. |
| Competitive benchmarking | Compare sellers and items using seller name, items sold, and feedback summaries to map competitive positions. |
| Data analytics pipelines (API/Python) | Pipe structured JSON to your warehouse; ideal for eBay product data scraping tool integrations and Python-based ETL. |
| Academic or non-profit research | Collect public item attributes and descriptions for studies on pricing patterns and product lifecycles. |
| Dropshipping and sourcing checks | Validate item specifics, condition, and shipping/delivery details at scale for sourcing workflows. |

### Why choose 🛍️ eBay Product Details Scraper?

- 🎯 Precision-first extraction: Focused on public eBay item pages to capture high-signal fields reliably.
- 🌍 Scales to batches: Paste dozens or thousands of URLs for an eBay bulk product scraper workflow.
- 👨‍💻 Built for developers: Clean JSON output, Apify API support, and easy eBay product scraper Python integration.
- 🔄 Automation-friendly: Integrate datasets into Make, n8n, Zapier, or your internal pipelines as an eBay product data API alternative.
- 🛡️ Safe-by-design: Does not log in or access private pages; aims at public listings only.
- 💸 Cost-effective reliability: Proxy escalation (direct → datacenter → residential) helps keep throughput high and failures low versus brittle, manual tools.
- 🧱 Production-ready infrastructure: Run in the cloud with logging, datasets, and exports — no servers to maintain.

In short: a purpose-built eBay product details extractor that outperforms fragile extensions and one-off scripts for repeatable, scalable use.

### Is it legal / ethical to use 🛍️ eBay Product Details Scraper?

Yes — when done responsibly. This actor collects data from publicly visible eBay item pages and does not access private or authenticated content. You are responsible for:

- Complying with eBay’s terms of use and any site-specific rate expectations.
- Respecting data protection laws such as GDPR/CCPA as applicable.
- Scraping only public data and avoiding personal or sensitive information.
- Using results for legitimate purposes (e.g., research, analysis) and not for spam or abuse.

For edge cases or commercial deployments, consult your legal team to confirm compliance.

### Input parameters & output format

Example input
```json
{
  "urls": [
    "https://www.ebay.com/itm/396090328598"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

Parameters

- urls (array, required)
  - Description: Add one link or many — each should be a standard eBay item page (copy from the address bar). Bulk-friendly.
  - Prefill (UI): \["https://www.ebay.com/itm/396090328598"]
- proxyConfiguration (object, optional)
  - Description: First request is always direct (no proxy). If Apify Proxy is on, the actor can fall back to datacenter then residential (with retries), then stay on residential for the rest of the run. Turn off for direct-only.
  - Prefill (UI): {"useApifyProxy": true}

Note: The actor code also accepts startUrls as an alias for urls, but the official input schema defines urls and proxyConfiguration.

Example output (success record)

```json
{
  "seller_name": "best-tech-store",
  "seller_items_sold": "1.2K",
  "positive_feedback": "99.8% positive",
  "product_title": "Sony WH-1000XM5 Wireless Noise-Canceling Headphones",
  "product_image": [
    "https://i.ebayimg.com/images/g/abc/s-l1600.jpg",
    "https://i.ebayimg.com/images/g/def/s-l1600.jpg"
  ],
  "product_price": "$299.99",
  "product_condition": "Brand New",
  "shipping_info": "Free shipping via USPS Priority",
  "delivery_info": "Estimated delivery Fri, May 10",
  "return_policy": "30-day returns. Buyer pays for return shipping.",
  "item_number": "396090328598",
  "item_description": "Experience industry-leading noise cancellation...",
  "item_specifics": {
    "Brand": "Sony",
    "Model": "WH-1000XM5",
    "Connectivity": "Bluetooth"
  },
  "detail_url": "https://www.ebay.com/itm/396090328598",
  "source_url": "https://www.ebay.com/itm/396090328598",
  "success": true,
  "proxyMode": "direct",
  "scrapedAt": "2026-04-21T10:22:33Z"
}
```

Example output (error record)

```json
{
  "source_url": "https://www.ebay.com/itm/invalid",
  "success": false,
  "error": "Could not fetch or parse listing",
  "proxyMode": "failed",
  "scrapedAt": "2026-04-21T10:25:10Z"
}
```

Field availability:

- If a field is not present on the page, it will be null/omitted (e.g., seller\_items\_sold, positive\_feedback, item\_description).
- For non-eBay URLs, an error row is saved with success: false and an error message.

Proxy behavior:

- With Apify Proxy enabled, the actor tries direct → datacenter → residential (up to 3 attempts); after the first successful residential fetch, it uses residential only for the rest of the run.

### FAQ

#### Do I need to log in to scrape eBay listings?

No. This actor targets public item pages only and does not require login or cookies. It functions as an eBay product details scraper without accessing private data.

#### Can I use it as an API or with Python?

Yes. You can access datasets via the Apify API, and it integrates smoothly with Python-based pipelines. Many users adopt it as an eBay product data API alternative in ETL workflows.

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

You can process one URL or many in a single run, depending on your Apify plan and fair use limits. It’s built for eBay bulk product scraper scenarios.

#### What data fields are included in the output?

Core fields include seller\_name, seller\_items\_sold, positive\_feedback, product\_title, product\_image, product\_price, product\_condition, shipping\_info, delivery\_info, return\_policy, item\_number, item\_description, item\_specifics, detail\_url, plus run metadata (source\_url, success, proxyMode, scrapedAt).

#### Does it scrape eBay search results or store pages?

No. This tool is focused on individual item pages. Use it as an eBay listing details scraper for product pages you already collected from search or navigation.

#### How does the proxy setting affect results?

The first attempt is always direct. If Apify Proxy is enabled and a direct request is blocked/invalid, the actor escalates to datacenter and then residential proxies with retries. After the first successful residential fetch, it remains on residential for the rest of the run.

#### Can I export to CSV or Excel?

Yes. Results are stored in an Apify dataset, which you can export to JSON, CSV, or Excel from the OUTPUT tab or programmatically via the Apify API.

#### Is it okay to use the data commercially?

You must comply with eBay’s terms and applicable laws. The actor collects only public data. Consult your legal team for your specific use case.

### Closing CTA / Final thoughts

The 🛍️ eBay Product Details Scraper is built to turn public eBay item URLs into structured, analytics-ready datasets fast. With bulk URL support, robust proxy escalation, and clean JSON output, it’s ideal for marketers, developers, analysts, and researchers who need reliable eBay product data at scale. Connect via the Apify API or your eBay product scraper Python workflow to automate exports, sync to your warehouse, and keep your dashboards fresh. Start extracting smarter, structured eBay listing data — without the manual grind.

# Actor input Schema

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

📋 Add one link or many — each should be a standard eBay item page (copy from the address bar). ✨ Bulk-friendly: drop your whole list here and go.

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

🔒 First request is always direct (no proxy). If Apify Proxy is on, the actor can fall back to datacenter then residential (with retries), then stay on residential for the rest of the run. Turn off for direct-only.

## Actor input object example

```json
{
  "urls": [
    "https://www.ebay.com/itm/396090328598"
  ],
  "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/itm/396090328598"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/ebay-product-details-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/itm/396090328598"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/ebay-product-details-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/itm/396090328598"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scraper-engine/ebay-product-details-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🛍️ eBay Product Details Scraper",
        "description": "🛍️ eBay Product Details Scraper grabs rich listing data in one click — titles, prices, images, specs, seller & shipping, variations, stock, category, ratings & reviews. ⚡ Fast, API-ready. Export CSV/JSON. 🔍 Ideal for market research, price tracking, SEO, analytics & dropshipping.",
        "version": "0.1",
        "x-build-id": "OksvKvxw54WhgMFbY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~ebay-product-details-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-ebay-product-details-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/scraper-engine~ebay-product-details-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-ebay-product-details-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/scraper-engine~ebay-product-details-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-ebay-product-details-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": "🔗 Your eBay listing URLs",
                        "type": "array",
                        "description": "📋 Add one link or many — each should be a standard eBay item page (copy from the address bar). ✨ Bulk-friendly: drop your whole list here and go.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy (optional)",
                        "type": "object",
                        "description": "🔒 First request is always direct (no proxy). If Apify Proxy is on, the actor can fall back to datacenter then residential (with retries), then stay on residential for the rest of the run. Turn off for direct-only."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
