# eBay Product Listing Scraper — Prices & Sellers (8 Markets) (`khadinakbar/ebay-product-listing-scraper`) Actor

Scrape active eBay product listings by keyword or URL across 8 marketplaces. Returns price, condition, shipping, seller, image and item URL per listing, plus optional item-page enrichment. MCP-ready, pay-per-event. For sold-price comps use ebay-all-in-one-scraper.

- **URL**: https://apify.com/khadinakbar/ebay-product-listing-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, MCP servers, Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 ebay listing scrapeds

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 Listing Scraper** extracts **active eBay product listings** by keyword or direct URL across **8 global marketplaces** (US, UK, DE, FR, IT, ES, CA, AU). Search a term, paste eBay search / category URLs, or paste individual `/itm/` product URLs — and get clean, structured JSON for every listing. No eBay developer API needed.

Built for resellers, dropshippers, price-monitoring tools, and AI agents that need fast, current eBay product data. Runs on the **Apify platform** with API access, scheduling, integrations (Zapier, Make, n8n, Slack), residential proxy rotation, and full run monitoring.

> **Need sold-price comps or seller search?** Use the sibling actor **[ebay-all-in-one-scraper](https://apify.com/khadinakbar/ebay-all-in-one-scraper)** — it covers sold/completed listings, price comps, and seller storefronts. This actor is focused purely on **active product listings** for speed and predictable cost.

### What it does

Scrapes eBay search-result and item pages and returns one flat JSON record per active listing:

- **Search by keyword** — e.g. `iphone 15 pro 256gb`, `vintage rolex submariner`, `pokemon charizard psa 10`.
- **Scrape by URL** — paste any eBay search URL, category URL, or individual `/itm/` product URL into Start URLs.
- **Optional item-page enrichment** — set `detailedItems: true` to also pull item specifics (brand, model, MPN, color), full description, and gallery images.

### When to use it

| Use case | How |
|---|---|
| Track competitor / market prices for a product | Search the product keyword, schedule daily |
| Build a price-comparison or deal-finder tool | Feed keywords or category URLs, pipe JSON to your app |
| Monitor a niche or category | Paste a category / filtered search URL |
| Feed an AI agent live eBay inventory | Call via MCP / API, read structured JSON |
| Enrich a product list with eBay offers | Pass `/itm/` URLs with `detailedItems: true` |

**Not for:** sold-price comps, completed-listing history, or seller-roster scraping — use **ebay-all-in-one-scraper** for those. Seller storefront URLs (`ebay.com/str/...`) are not supported.

### Output

Each listing is one flat record. Example (truncated):

```json
{
  "itemId": "204512345678",
  "title": "Apple AirPods Pro 2nd Generation USB-C — Sealed",
  "price": 189.99,
  "priceText": "US $189.99",
  "currency": "USD",
  "originalPrice": 249.0,
  "discountPercent": 24,
  "condition": "Brand New",
  "listingType": "buy_it_now",
  "bidsCount": null,
  "buyItNowAvailable": true,
  "shippingCost": 0,
  "shippingType": "free",
  "itemLocation": "United States",
  "sellerName": "techdeals_usa",
  "sellerFeedbackPercent": 99.2,
  "sellerFeedbackCount": 19700,
  "watchersCount": 42,
  "imageUrl": "https://i.ebayimg.com/images/g/abcAAOSw.../s-l1600.jpg",
  "itemUrl": "https://www.ebay.com/itm/204512345678",
  "marketplace": "ebay.com",
  "mode": "active",
  "scrapedAt": "2026-06-18T03:00:00.000Z"
}
````

With `detailedItems: true`, records also include `categoryName`, `itemSpecifics` (key/value object), `description`, and `imageUrls` (full gallery).

### Pricing (pay-per-event)

| Event | Price |
|---|---|
| Actor start | $0.00005 |
| Listing scraped (fast search-card path) | **$0.003** per listing |
| Detailed listing scraped (item-page enrichment) | $0.005 per listing |

You pay only for what you get. A 1,000-listing keyword sweep costs about **$3.00**. The actor prints the worst-case cost cap at the start of every run and the actual billed total at the end.

### How to use it

1. Click **Try for free**.
2. Enter a **Search Query** (e.g. `iphone 15 pro 256gb`) — OR paste eBay URLs into **Start URLs**.
3. Pick a **Marketplace** (default `ebay.com`).
4. Set **Max Results** (5 for a quick test, 1,000+ for a full sweep).
5. Optional: filter by **Condition**, **Min/Max Price**, **Sort Order**; toggle **Visit each item page** for richer data.
6. **Start** the run. Download results as JSON, CSV, Excel, HTML, or RSS — or pull them via the Apify API / MCP.

### Use via API & MCP

The actor is MCP-ready and discoverable to AI agents as `apify--ebay-product-listing-scraper`. Connect through `https://mcp.apify.com` or call it with the Apify API / client SDKs. Input is a single keyword or URL list in; structured listing JSON out.

```bash
apify call khadinakbar/ebay-product-listing-scraper \
  --input='{"searchQuery":"airpods pro 2","marketplace":"ebay.com","maxResults":20}'
```

### Marketplaces supported

`ebay.com` (US), `ebay.co.uk` (UK), `ebay.de` (DE), `ebay.fr` (FR), `ebay.it` (IT), `ebay.es` (ES), `ebay.ca` (CA), `ebay.com.au` (AU). The actor pins residential proxies to the marketplace country for accurate, geo-correct pricing and inventory.

### Reliability

eBay aggressively blocks raw HTTP, so this actor uses a real Chromium browser with marketplace-pinned residential proxies, a session warm-up step, and an anti-bot circuit breaker that exits cleanly (charging only the start fee) on transient blocks instead of failing the run. If a run returns empty due to a transient block, retry in 10–15 minutes.

### FAQ

**Does this return sold prices?** No — active listings only. Use **ebay-all-in-one-scraper** for sold comps.

**Do I need an eBay API key or login?** No. No account, no API key.

**How many results can I get?** Up to 10,000 per run (auto-paginated). For larger jobs, split by keyword, category, or marketplace.

**Why is a run sometimes empty?** eBay occasionally rate-limits the residential proxy pool. The actor exits cleanly (start fee only) and the next run usually succeeds.

**Can I get item specifics / full description?** Yes — set `detailedItems: true` (billed at the detailed-result rate).

### Legal

This actor scrapes publicly available data from eBay search and item pages. It does not access private data, bypass logins, or collect personal data beyond public seller usernames shown on listings. You are responsible for using the data in compliance with eBay's Terms of Service, applicable laws (including GDPR/CCPA where relevant), and your own jurisdiction's regulations. Use responsibly and at your own risk.

# Actor input Schema

## `searchQuery` (type: `string`):

Use this to search active eBay listings by keyword (e.g., 'iphone 15 pro 256gb', 'vintage rolex submariner'). Supports eBay search syntax: quotes for exact match, minus to exclude. Defaults to 'airpods pro 2'. Leave empty if you provide startUrls. NOT a product URL and NOT for sold/completed listings — paste item URLs into startUrls, and use ebay-all-in-one-scraper for sold comps.

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

Direct eBay URLs to scrape instead of a keyword. Accepts search result URLs (https://www.ebay.com/sch/i.html?\_nkw=...), category URLs, OR individual item URLs (https://www.ebay.com/itm/...). When provided, searchQuery and the filter fields below are ignored. NOT for seller storefront URLs (ebay.com/str/...) — those return 0 results.

## `marketplace` (type: `string`):

Which eBay regional site to scrape. Affects currency, language, and available inventory. Default is ebay.com (US). NOT all sellers ship internationally — pick the marketplace closest to your buyer location for accurate pricing.

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

Maximum number of items to return. eBay paginates 60 results per page; the actor handles pagination automatically. The example prefill is intentionally small so Apify health checks finish quickly; raise it for production sweeps. Hard cap is 10000 to protect against runaway PPE costs.

## `condition` (type: `string`):

Filter by item condition. 'any' returns all conditions (default). NOT applied when startUrls already encode a condition filter in the URL.

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

Lower bound on listing price (in marketplace currency). Leave blank for no minimum. Example: 100 returns items priced $100 and above. NOT applied when startUrls already encode price filters.

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

Upper bound on listing price (in marketplace currency). Leave blank for no maximum. Example: 500 returns items priced $500 and below. NOT applied when startUrls already encode price filters.

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

How eBay should order the results before scraping. 'best\_match' (default) is eBay's relevance ranking. 'ending\_soon' surfaces auctions about to close. 'price\_asc' / 'price\_desc' for cheapest / most expensive first. NOT applied when startUrls already encode sort.

## `detailedItems` (type: `boolean`):

When true, the actor visits each listing's item page to extract item specifics (brand, model, MPN, color, etc.), full description, and gallery images, billed at the higher detailed-result rate. Roughly 3x slower and more PPE cost. Default is false (fast search-card data only: title, price, condition, shipping, seller, image, URL).

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

Proxy settings. Leave default — residential proxies are required for eBay reliability and the actor configures them automatically.

## Actor input object example

```json
{
  "searchQuery": "vintage rolex submariner",
  "startUrls": [],
  "marketplace": "ebay.com",
  "maxResults": 5,
  "condition": "any",
  "sortBy": "best_match",
  "detailedItems": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

All scraped active eBay product listings. Download as JSON, CSV, Excel, HTML, or RSS.

# 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 = {
    "searchQuery": "airpods pro 2",
    "startUrls": [],
    "maxResults": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/ebay-product-listing-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 = {
    "searchQuery": "airpods pro 2",
    "startUrls": [],
    "maxResults": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/ebay-product-listing-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 '{
  "searchQuery": "airpods pro 2",
  "startUrls": [],
  "maxResults": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call khadinakbar/ebay-product-listing-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "eBay Product Listing Scraper — Prices & Sellers (8 Markets)",
        "description": "Scrape active eBay product listings by keyword or URL across 8 marketplaces. Returns price, condition, shipping, seller, image and item URL per listing, plus optional item-page enrichment. MCP-ready, pay-per-event. For sold-price comps use ebay-all-in-one-scraper.",
        "version": "0.1",
        "x-build-id": "v0kiqQBxFWrZqVS4u"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~ebay-product-listing-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-ebay-product-listing-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/khadinakbar~ebay-product-listing-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-ebay-product-listing-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/khadinakbar~ebay-product-listing-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-ebay-product-listing-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Use this to search active eBay listings by keyword (e.g., 'iphone 15 pro 256gb', 'vintage rolex submariner'). Supports eBay search syntax: quotes for exact match, minus to exclude. Defaults to 'airpods pro 2'. Leave empty if you provide startUrls. NOT a product URL and NOT for sold/completed listings — paste item URLs into startUrls, and use ebay-all-in-one-scraper for sold comps."
                    },
                    "startUrls": {
                        "title": "Start URLs (alternative to Search Query)",
                        "type": "array",
                        "description": "Direct eBay URLs to scrape instead of a keyword. Accepts search result URLs (https://www.ebay.com/sch/i.html?_nkw=...), category URLs, OR individual item URLs (https://www.ebay.com/itm/...). When provided, searchQuery and the filter fields below are ignored. NOT for seller storefront URLs (ebay.com/str/...) — those return 0 results.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "marketplace": {
                        "title": "eBay Marketplace",
                        "enum": [
                            "ebay.com",
                            "ebay.co.uk",
                            "ebay.de",
                            "ebay.fr",
                            "ebay.it",
                            "ebay.es",
                            "ebay.ca",
                            "ebay.com.au"
                        ],
                        "type": "string",
                        "description": "Which eBay regional site to scrape. Affects currency, language, and available inventory. Default is ebay.com (US). NOT all sellers ship internationally — pick the marketplace closest to your buyer location for accurate pricing.",
                        "default": "ebay.com"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of items to return. eBay paginates 60 results per page; the actor handles pagination automatically. The example prefill is intentionally small so Apify health checks finish quickly; raise it for production sweeps. Hard cap is 10000 to protect against runaway PPE costs.",
                        "default": 50
                    },
                    "condition": {
                        "title": "Item Condition",
                        "enum": [
                            "any",
                            "new",
                            "used",
                            "refurbished",
                            "open_box"
                        ],
                        "type": "string",
                        "description": "Filter by item condition. 'any' returns all conditions (default). NOT applied when startUrls already encode a condition filter in the URL.",
                        "default": "any"
                    },
                    "minPrice": {
                        "title": "Minimum Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lower bound on listing price (in marketplace currency). Leave blank for no minimum. Example: 100 returns items priced $100 and above. NOT applied when startUrls already encode price filters."
                    },
                    "maxPrice": {
                        "title": "Maximum Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Upper bound on listing price (in marketplace currency). Leave blank for no maximum. Example: 500 returns items priced $500 and below. NOT applied when startUrls already encode price filters."
                    },
                    "sortBy": {
                        "title": "Sort Order",
                        "enum": [
                            "best_match",
                            "ending_soon",
                            "newest",
                            "price_asc",
                            "price_desc"
                        ],
                        "type": "string",
                        "description": "How eBay should order the results before scraping. 'best_match' (default) is eBay's relevance ranking. 'ending_soon' surfaces auctions about to close. 'price_asc' / 'price_desc' for cheapest / most expensive first. NOT applied when startUrls already encode sort.",
                        "default": "best_match"
                    },
                    "detailedItems": {
                        "title": "Visit each item page (slower, richer data)",
                        "type": "boolean",
                        "description": "When true, the actor visits each listing's item page to extract item specifics (brand, model, MPN, color, etc.), full description, and gallery images, billed at the higher detailed-result rate. Roughly 3x slower and more PPE cost. Default is false (fast search-card data only: title, price, condition, shipping, seller, image, URL).",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Leave default — residential proxies are required for eBay reliability and the actor configures them automatically.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
