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

🛍️ eBay Product Details Scraper extracts rich listing data in one click — title, price, images, seller, item specifics, shipping, variations & reviews. ⚡ Fast, accurate, CSV/JSON export. 🔎 Perfect for market research, price tracking, SEO, and catalog enrichment.

- **URL**: https://apify.com/scrapier/ebay-product-details-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 Product Details Scraper

The 🛍️ eBay Product Details Scraper is an Apify actor that turns public eBay item URLs into structured datasets you can export and analyze fast. It solves the manual copy-paste problem by extracting titles, prices, images, seller signals, descriptions, shipping/returns, and item specifics from listing pages — ideal for marketers, developers, data analysts, and researchers. With this eBay product details scraper and eBay listing data scraper, you can power market research, price tracking, SEO, and catalog enrichment at scale.

### What data / output can you get?

| Data type | Description | Example value |
| --- | --- | --- |
| source_url | The input eBay listing URL that produced the row | https://www.ebay.com/itm/396090328598 |
| success | Flag indicating if the listing parsed successfully | true |
| proxyMode | How the page was fetched: direct, datacenter, or residential (when proxy is enabled) | residential |
| scrapedAt | ISO 8601 timestamp when the row was written | 2026-04-27T05:27:36Z |
| seller_name | Seller/store name (when available) | Best Buy |
| seller_items_sold | Seller’s items sold indicator (when present on page) | 12K |
| positive_feedback | Seller positive feedback summary (if visible) | 99.7% positive |
| product_title | Listing title | Apple iPhone 14 Pro Max 256GB – Deep Purple |
| product_price | Price string parsed from the page | $899.99 |
| product_condition | Condition shown on the listing | Open box |
| product_image | Array of product image URLs (prefers s-l1600 when available) | ["https://i.ebayimg.com/images/g/abc/s-l1600.jpg"] |
| shipping_info | Shipping/location snippets parsed from page | $9.95 USPS Priority; Located in: Austin, TX |
| delivery_info | Delivery/arrival snippet (if present) | Estimated delivery Tue, May 7 |
| return_policy | Return policy text (if present) | 30 days returns. Buyer pays for return shipping. |
| item_number | eBay item number extracted from the page | 396090328598 |
| item_description | Main description text (inline or iframe, when available) | Includes original box, cable, and manual… |
| item_specifics | Key/value map of item attributes | {"Brand":"Apple","Model":"iPhone 14 Pro Max","Color":"Deep Purple"} |
| detail_url | Canonical detail URL (when available) | https://www.ebay.com/itm/396090328598 |
| error | Error message for failed rows | Could not fetch or parse listing |

Notes:
- Results stream into an Apify dataset you can export to JSON, CSV, or Excel.
- Bonus metadata includes proxyMode and scrapedAt for auditability.
- Some fields may be null if not present on the page (e.g., seller_items_sold, positive_feedback, delivery_info, return_policy).

### Key features

- ⚡ Bold proxy escalation strategy
  Direct first; on failure, escalate to datacenter, then residential (up to 3 tries). After the first successful residential fetch, the run switches to sticky residential for stability. This improves reliability for your eBay product data extractor workflows.

- 📦 Batch scraping & bulk automation
  Feed one or thousands of item URLs in a single run. Ideal for eBay bulk product scraper use cases and repeatable pipelines.

- 🧱 Structured JSON for analytics
  Consistent output fields for titles, prices, item specifics, images, shipping/returns, and more — perfect for databases, dashboards, and ETL.

- 🖼️ High‑resolution product images
  Extracts gallery URLs and prefers s-l1600 when available, making it a dependable eBay product images scraper for catalog builds.

- 🧩 Item specifics extraction
  Captures category-specific attributes as a key/value map — a precise eBay item specifics scraper for enrichment and filtering.

- 📝 Full description capture
  Reads inline descriptions and follows the description iframe when present, serving as a reliable eBay product description scraper.

- 🔌 Developer-friendly
  Runs on Apify with dataset outputs accessible via the Apify API. Easy to plug into Python data pipelines or workflow tools.

- 💾 Flexible exports
  Download results as JSON, CSV, or Excel directly from the OUTPUT tab — streamlined eBay product data export to CSV.

- 🛡️ No login required
  Built for public listing pages only; does not access private data or accounts.

- 🏗️ Production-ready infrastructure
  Transparent logs, real-time dataset updates, and optional Apify Proxy for resilient fetching — ideal for an eBay product details scraping tool in production.

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

1. Sign in to Apify
   Create or log into your Apify account.

2. Open the actor
   Find “🛍️ eBay Product Details Scraper” in Apify Console.

3. Add your input URLs
   Paste one or many eBay item links into the urls field. It accepts an array of strings.

4. (Optional) Configure proxy
   Set proxyConfiguration if you want Apify Proxy escalation (recommended). The first request is always direct; the actor escalates only when needed.

5. Start the run
   Click Start. Watch progress in Logs; results stream to the OUTPUT dataset as each listing completes.

6. Monitor and iterate
   Error rows (if any) include error messages and metadata so you can retry or fix sources.

7. Export your data
   Download JSON, CSV, or Excel from the OUTPUT tab, or fetch via the Apify API for automation in Python or no-code tools.

Pro Tip: Automate end-to-end. Trigger the actor via the Apify API, pipe the dataset into your warehouse, and keep an eBay listing data scraper workflow updated for ongoing price tracking and catalog enrichment.

### Use cases

| Use case name | Description |
| --- | --- |
| Market research & trend analysis | Aggregate titles, prices, and item specifics across categories to quantify assortment and pricing trends using an eBay category listings scraper workflow (with pre-collected item links). |
| Price tracking & competitive monitoring | Track product title and price changes over time from public listings; export to CSV for comparison dashboards. |
| Catalog enrichment & SEO | Enrich product records with high‑res images, item specifics, and descriptions from a dependable eBay product attributes extractor. |
| Seller QA & compliance checks | Verify return policies, shipping/location notes, and seller feedback signals to reduce risk. |
| Data science & analytics pipeline | Use the Apify dataset + API to stream structured JSON into Python pipelines for modeling and reporting (eBay product data scraping Python). |
| Academic & non-profit research | Collect public item data for research projects — no login, structured outputs, reproducible runs. |
| Repricing & inventory snapshots | Capture price, condition, and listing metadata on a schedule to inform pricing ops. |
| Bulk audits from store exports | Combine seller exports with this eBay seller listings scraper approach by feeding item URLs for detailed per‑listing extraction. |

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

This tool prioritizes precision, automation, and reliability for structured eBay listing data.

- 🎯 Accurate field extraction: Titles, prices, item specifics, descriptions, images, and seller signals from public pages.
- 🌍 Scales from 1 to many: Supports bulk runs for large datasets without manual overhead.
- 👩‍💻 Developer access: Dataset-first design integrates with the Apify API for downstream apps and ETL.
- 🔒 Safe-by-design: No login or private data; public listing pages only.
- 🌐 Resilient fetching: Optional proxy escalation (direct → datacenter → residential, then sticky residential) for robust access.
- 💰 Cost-effective alternative: More stable than ad‑hoc browser extensions or manual copy‑paste.
- 🔗 Export & integrate: JSON/CSV/Excel outputs fit analytics stacks and workflow tools.

In short, it’s a production-ready eBay product data extractor built for consistent results — not a brittle extension.

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

Yes — when used responsibly. This actor collects data from publicly visible eBay listing pages and does not log in or access private information. You are responsible for complying with eBay’s terms of use, applicable laws (e.g., GDPR, CCPA), and your organization’s policies.

Guidelines:
- Use only public listing URLs you’re allowed to process.
- Respect platform terms and fair-use expectations.
- Avoid personal data and sensitive information.
- Validate compliance with your legal team for specific use cases.

### Input parameters & output format

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

Parameters

- urls (array)
  - Description: Add one link or many — each should be a standard eBay item page (copy from the address bar).
  - Required: Yes
  - Default: Not provided in schema (UI shows a prefill example)
- proxyConfiguration (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.
  - Required: No
  - Default: Not provided in schema (UI shows prefill { "useApifyProxy": true })

Example output (success row)

```json
{
  "seller_name": "Best Buy",
  "seller_items_sold": "12K",
  "positive_feedback": "99.7% positive",
  "product_title": "Apple iPhone 14 Pro Max 256GB – Deep Purple",
  "product_image": [
    "https://i.ebayimg.com/images/g/abc/s-l1600.jpg",
    "https://i.ebayimg.com/images/g/def/s-l1600.jpg"
  ],
  "product_price": "$899.99",
  "product_condition": "Open box",
  "shipping_info": "$9.95 USPS Priority; Located in: Austin, TX",
  "delivery_info": "Estimated delivery Tue, May 7",
  "return_policy": "30 days returns. Buyer pays for return shipping.",
  "item_number": "396090328598",
  "item_description": "Includes original box, cable, and manual. Device shows minor signs of wear...",
  "item_specifics": {
    "Brand": "Apple",
    "Model": "iPhone 14 Pro Max",
    "Color": "Deep Purple",
    "Storage Capacity": "256 GB"
  },
  "detail_url": "https://www.ebay.com/itm/396090328598",
  "source_url": "https://www.ebay.com/itm/396090328598",
  "success": true,
  "proxyMode": "residential",
  "scrapedAt": "2026-04-27T05:27:36Z"
}
```

Example output (error row)

```json
{
  "source_url": "https://www.ebay.com/itm/000000000000",
  "success": false,
  "error": "Could not fetch or parse listing",
  "proxyMode": "datacenter",
  "scrapedAt": "2026-04-27T05:27:36Z"
}
```

Notes:

- On “not an eBay URL”, error rows include source\_url, success, error, and scrapedAt.
- Some fields may be null if the page doesn’t expose them or if anti‑bot content obscures them (e.g., seller\_items\_sold, positive\_feedback, delivery\_info, return\_policy).

### FAQ

#### Is this an official eBay product?

No. This is an independent Apify actor. eBay is a trademark of its respective owners, and this tool works only with publicly available listing pages.

#### Does it scrape search results, categories, or whole stores?

It’s designed for individual listing URLs. You can collect item URLs from search, category, or store pages separately and feed those links into this eBay product details scraping tool for structured per‑item data.

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

No. The actor targets public eBay listing pages and does not require login or cookies.

#### What data types does it extract?

It captures seller\_name, seller\_items\_sold, positive\_feedback, product\_title, product\_price, product\_condition, product\_image, shipping\_info, delivery\_info, return\_policy, item\_number, item\_description, item\_specifics, detail\_url, plus metadata like source\_url, success, proxyMode, and scrapedAt.

#### How does proxy escalation work?

The actor fetches directly first. If blocked or invalid, it escalates to a datacenter proxy, and then to residential with up to three attempts. After the first successful residential fetch, the run switches to residential-only (sticky) for the remaining URLs to maximize success rates.

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

Yes. All results are written to an Apify dataset that you can export as JSON, CSV, or Excel from the OUTPUT tab — perfect for eBay product data export to CSV.

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

Yes. It runs on Apify and exposes output via the Apify API, making it easy to integrate with Python scripts or no-code tools in an eBay product data scraping Python pipeline.

#### Is this a Chrome extension?

No. This is a cloud-based Apify actor, not an eBay product scraper Chrome extension. It’s engineered for reliability, bulk automation, and structured outputs.

### Closing CTA / Final thoughts

Built for structured eBay listing extraction, the 🛍️ eBay Product Details Scraper turns public item URLs into clean, analytics-ready datasets. In minutes, you can collect titles, prices, images, descriptions, shipping/returns, item specifics, and seller signals — and export them as JSON, CSV, or Excel.

Whether you’re a marketer, developer, data analyst, or researcher, this eBay product data extractor supports bulk automation, clear run logs, and resilient proxy strategies. Developers can integrate via the Apify API to power pipelines and dashboards. Start extracting smarter, scalable eBay listing data today.

# 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("scrapier/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("scrapier/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 scrapier/ebay-product-details-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapier/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 extracts rich listing data in one click — title, price, images, seller, item specifics, shipping, variations & reviews. ⚡ Fast, accurate, CSV/JSON export. 🔎 Perfect for market research, price tracking, SEO, and catalog enrichment.",
        "version": "0.1",
        "x-build-id": "H4WvGpQyZ9QaujpxL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapier~ebay-product-details-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapier-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/scrapier~ebay-product-details-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapier-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/scrapier~ebay-product-details-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapier-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
