# EBay Listings Scraper (Cheap) (`data_api/ebay-listings-scraper-cheap`) Actor

eBay Search Listings Scraper that pulls prices, conditions, seller info, and shipping details from any keyword search, so you can track market prices and research competitors without manual browsing.

- **URL**: https://apify.com/data\_api/ebay-listings-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Listings Scraper

![eBay Listings Scraper](cover.jpg)

Searching eBay by hand and pasting prices into a spreadsheet falls apart the moment you need more than a handful of items. This eBay scraper does the legwork: type a query, and it walks the search results page by page and returns every listing as a tidy row — title, current price, any crossed-out list price, condition, seller, shipping, ratings, and live auction details. Run one keyword or a whole batch, set a cap, and export the data wherever you need it.

### What you get

Each listing comes back as one row with the same set of fields every time, so your columns stay predictable when you load the results into a sheet or database. Values eBay does not show on a given card arrive as `null` rather than disappearing. The data splits into a few groups:

- **Item basics** — `productTitle`, `listingId`, `itemUrl`, `imageLink`, `subtitleText`, `conditionLabel`
- **Pricing** — `currentPrice`, `listPrice`, `currencyCode`
- **Seller and delivery** — `storeName`, `sellerRating`, `deliveryInfo`, `itemLocation`
- **Demand and auctions** — `unitsSold`, `watcherCount`, `buyItNow`, `auctionListing`, `bidCount`, `timeRemaining`
- **Ratings and tags** — `starRating`, `reviewTotal`, `badgeLabel`, `promoted`
- **Run context** — `searchTerm`, `resultPage`, `collectedAt`

### Quick start

1. Click **Try for free** and open the input form.
2. Type a term into **Search query**, or drop several into **Search queries (batch)** to cover more ground in one run.
3. Optionally set a category, price range, condition, or sort order, and a **Results cap** to keep the run short.
4. Press **Start**, then download the dataset as JSON, CSV, Excel, or XML when it finishes.

![How it works](how-it-works.jpg)

### Use cases

- **Price monitoring** — schedule a daily run on a product and watch how prices and discounts move
- **Reseller and dropshipping research** — surface items with high sold counts and watcher numbers before competitors do
- **Competitor and market analysis** — see who is selling what, at which price, and with what feedback score
- **Catalog and pricing data** — pull a structured snapshot of an entire category for your own dashboards
- **Deal hunting** — sort by lowest price and filter by condition to find the best offers fast
- **Auction tracking** — pull bid counts and time-remaining figures across live auctions in one pass

### Input

You only need a query to start; everything else is optional.

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | string | One of `searchQuery` or `searchQueries` | A single term to search on eBay, e.g. `lego star wars set`. |
| `searchQueries` | array of strings | Optional | Several terms searched separately, with all matches combined into one dataset. |
| `categoryFilter` | string | No | Restrict results to one eBay category by numeric ID. Leave blank to search everything. Example `139973`. |
| `priceFloor` | number | No | Lowest price to include, in USD. Leave blank for no lower bound. |
| `priceCeiling` | number | No | Highest price to include, in USD. Leave blank for no upper bound. |
| `itemCondition` | string | No | Filter by condition: `any`, `new`, `used`, or `not_specified`. Default `any`. |
| `resultSorting` | string | No | Order results: `best_match`, `lowest_price`, `highest_price`, `ending_soonest`, or `newly_listed`. Default `best_match`. |
| `resultsLimit` | integer | No | Stop after this many listings per run. Default `60`; max `1000`. |
| `timeoutSeconds` | integer | No | Seconds to wait per page request before moving on. Default `45`. |

#### Example input

```json
{
    "searchQuery": "lego star wars set",
    "itemCondition": "used",
    "resultSorting": "lowest_price",
    "resultsLimit": 100
}
````

### Output

Every listing on the search results becomes one row. Each field is always present; anything eBay does not display on a card comes back as `null`, so the dataset stays rectangular and easy to load.

#### Example output

```json
{
    "listingId": "296812345678",
    "productTitle": "LEGO Star Wars Millennium Falcon 75257 Building Set",
    "currentPrice": "$129.99",
    "listPrice": "$169.99",
    "currencyCode": "USD",
    "conditionLabel": "Used",
    "subtitleText": "Complete with box and instructions",
    "itemUrl": "https://www.ebay.com/itm/296812345678",
    "imageLink": "https://i.ebayimg.com/images/g/AbcAAeSwxyz/s-l500.webp",
    "storeName": "brick_traders",
    "sellerRating": "99.6% positive (12.1K)",
    "deliveryInfo": "Free delivery in 3-4 days",
    "itemLocation": "United States",
    "unitsSold": "37 sold",
    "watcherCount": "9 watchers",
    "buyItNow": true,
    "auctionListing": false,
    "bidCount": null,
    "timeRemaining": null,
    "promoted": false,
    "reviewTotal": "24 product ratings",
    "starRating": "4.8 out of 5 stars",
    "badgeLabel": null,
    "searchTerm": "lego star wars set",
    "resultPage": 1,
    "collectedAt": "2026-06-30T09:15:42.123456+00:00"
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | string | eBay item number that uniquely identifies the listing |
| `productTitle` | string | Headline text shown for the item |
| `currentPrice` | string | Price as printed on the card, with its currency symbol |
| `listPrice` | string | Crossed-out reference price when a markdown is shown; `null` otherwise |
| `currencyCode` | string | Three-letter currency guessed from the price symbol, e.g. USD, GBP, EUR |
| `conditionLabel` | string | Stated condition, e.g. New, Pre-owned, Refurbished |
| `subtitleText` | string | Secondary line under the title, often a warranty or promo note |
| `itemUrl` | string | Clean direct link to the item page, no tracking parameters |
| `imageLink` | string | Thumbnail URL upgraded to 500 px resolution |
| `storeName` | string | Display name of the seller or store |
| `sellerRating` | string | Seller feedback score and review volume |
| `deliveryInfo` | string | Shipping cost or delivery estimate from the card |
| `itemLocation` | string | Where the item ships from, when listed |
| `unitsSold` | string | How many have sold, when shown; `null` otherwise |
| `watcherCount` | string | Number of shoppers watching the listing, when shown |
| `buyItNow` | boolean | True when a fixed-price Buy It Now option is offered |
| `auctionListing` | boolean | True when the listing runs as a timed auction |
| `bidCount` | string | Bids placed on an auction; `null` for fixed-price items |
| `timeRemaining` | string | Time left before an auction ends, when shown |
| `promoted` | boolean | True when the result is a sponsored placement |
| `reviewTotal` | string | Count of product ratings tied to the listing, when present |
| `starRating` | string | Average star score for the product |
| `badgeLabel` | string | Program badge such as eBay Refurbished or Top Rated |
| `searchTerm` | string | The query that surfaced this listing |
| `resultPage` | integer | Page number of the search results the listing came from |
| `collectedAt` | string | ISO 8601 UTC timestamp of when the row was captured |

### Tips for best results

- **Test with a small `resultsLimit`.** Run 20–30 listings first to confirm the fields fit your pipeline, then raise the cap for the full pull.
- **Let pagination run itself.** The scraper pages through results automatically until it hits your cap or eBay runs out of listings — roughly 60 per page.
- **Expect `null` on sparse cards.** Fields like `unitsSold`, `bidCount`, or `badgeLabel` only appear when eBay shows them; a `null` there is normal, not a failure.
- **Keep or drop promoted items with `promoted`.** Sponsored listings are included and flagged, so you can filter them out in your own step if you only want organic demand.
- **Raise `timeoutSeconds` to ~60** if you see frequent timeout errors on busy categories.

### How can I use eBay listings data?

**How can I use the eBay Listings Scraper to track prices over time?**
Schedule the actor to run on the same `searchQuery` each day and store the dataset. Because every row carries `currentPrice`, `listPrice`, and a `collectedAt` timestamp, you can chart how prices and discounts shift across days or weeks and get an alert when something drops to your target.

**How can I scrape eBay search results for reseller and dropshipping research?**
Set a query for the niche you are exploring and sort by `newly_listed` or `best_match`. The `unitsSold` and `watcherCount` fields point to items with real demand, while `storeName` and `sellerRating` show who is already selling them and how well they are rated.

**How can I pull eBay listing data for an entire category?**
Use `categoryFilter` with a category ID and raise `resultsLimit` to gather a broad snapshot, or pass several terms through `searchQueries` to cover a topic from multiple angles. Each result returns as one row with pricing, condition, seller, and delivery details, ready to load into a sheet, database, or dashboard.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# Actor input Schema

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

One term to look up on eBay, for example 'lego star wars set'. To collect several terms in a single run, use the multi-query field below instead.

## `searchQueries` (type: `array`):

Several terms to scrape in one go. Each term is searched on its own and all matches land in the same dataset. Pair it with the single-query field above or use it on its own.

## `categoryFilter` (type: `string`):

Narrow the hunt to one eBay category by its numeric ID (for instance '139973' for Video Games). Leave it empty to search across every category.

## `priceFloor` (type: `number`):

Skip anything cheaper than this amount. Leave empty to set no lower bound.

## `priceCeiling` (type: `number`):

Skip anything pricier than this amount. Leave empty to set no upper bound.

## `itemCondition` (type: `string`):

Keep only listings that match the condition you pick.

## `resultSorting` (type: `string`):

Choose the order eBay returns the matches in.

## `resultsLimit` (type: `integer`):

Stop after collecting this many listings per run. Handy for quick test runs or keeping spend in check.

## `timeoutSeconds` (type: `integer`):

How long to wait on each page request before giving up and moving on.

## Actor input object example

```json
{
  "searchQuery": "lego star wars set",
  "searchQueries": [
    "lego star wars set",
    "vintage polaroid camera",
    "mechanical keyboard"
  ],
  "categoryFilter": "139973",
  "itemCondition": "any",
  "resultSorting": "best_match",
  "resultsLimit": 60,
  "timeoutSeconds": 45
}
```

# 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": "lego star wars set",
    "searchQueries": [
        "lego star wars set",
        "vintage polaroid camera"
    ],
    "categoryFilter": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/ebay-listings-scraper-cheap").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": "lego star wars set",
    "searchQueries": [
        "lego star wars set",
        "vintage polaroid camera",
    ],
    "categoryFilter": "",
}

# Run the Actor and wait for it to finish
run = client.actor("data_api/ebay-listings-scraper-cheap").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": "lego star wars set",
  "searchQueries": [
    "lego star wars set",
    "vintage polaroid camera"
  ],
  "categoryFilter": ""
}' |
apify call data_api/ebay-listings-scraper-cheap --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EBay Listings Scraper (Cheap)",
        "description": "eBay Search Listings Scraper that pulls prices, conditions, seller info, and shipping details from any keyword search, so you can track market prices and research competitors without manual browsing.",
        "version": "0.0",
        "x-build-id": "ShPgrBcR2d0N2v0Qq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~ebay-listings-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-ebay-listings-scraper-cheap",
                "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/data_api~ebay-listings-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-ebay-listings-scraper-cheap",
                "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/data_api~ebay-listings-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-ebay-listings-scraper-cheap",
                "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": "One term to look up on eBay, for example 'lego star wars set'. To collect several terms in a single run, use the multi-query field below instead."
                    },
                    "searchQueries": {
                        "title": "Search queries (batch)",
                        "type": "array",
                        "description": "Several terms to scrape in one go. Each term is searched on its own and all matches land in the same dataset. Pair it with the single-query field above or use it on its own.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryFilter": {
                        "title": "Category ID filter",
                        "type": "string",
                        "description": "Narrow the hunt to one eBay category by its numeric ID (for instance '139973' for Video Games). Leave it empty to search across every category."
                    },
                    "priceFloor": {
                        "title": "Lowest price (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Skip anything cheaper than this amount. Leave empty to set no lower bound."
                    },
                    "priceCeiling": {
                        "title": "Highest price (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Skip anything pricier than this amount. Leave empty to set no upper bound."
                    },
                    "itemCondition": {
                        "title": "Item condition",
                        "enum": [
                            "any",
                            "new",
                            "used",
                            "not_specified"
                        ],
                        "type": "string",
                        "description": "Keep only listings that match the condition you pick.",
                        "default": "any"
                    },
                    "resultSorting": {
                        "title": "Result ordering",
                        "enum": [
                            "best_match",
                            "lowest_price",
                            "highest_price",
                            "ending_soonest",
                            "newly_listed"
                        ],
                        "type": "string",
                        "description": "Choose the order eBay returns the matches in.",
                        "default": "best_match"
                    },
                    "resultsLimit": {
                        "title": "Results cap",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Stop after collecting this many listings per run. Handy for quick test runs or keeping spend in check.",
                        "default": 60
                    },
                    "timeoutSeconds": {
                        "title": "Timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How long to wait on each page request before giving up and moving on.",
                        "default": 45
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
