# TCGplayer Product Price Scraper (`automation-lab/tcgplayer-product-price-scraper`) Actor

🎴 Extract TCGplayer product prices, market lows, listing counts, card metadata, URLs, and seller summaries for repricing workflows.

- **URL**: https://apify.com/automation-lab/tcgplayer-product-price-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## TCGplayer Product Price Scraper

Extract TCGplayer product prices, market lows, listing counts, card metadata, seller summaries, product URLs, and image URLs from public TCGplayer search results.

### What does TCGplayer Product Price Scraper do?

TCGplayer Product Price Scraper turns public TCGplayer marketplace search results into clean structured product price snapshots.

It is built for repeat monitoring workflows where you need to track changing prices for cards, sealed products, and collectibles across TCGplayer.

The actor accepts search terms, TCGplayer product IDs, or TCGplayer search/product URLs.

It returns product titles, game/product line, set, rarity, card number, market price, low price, listing counts, top listing summary fields, product URLs, image URLs, and scrape timestamps.

### Who is it for?

🛒 Trading card sellers can monitor market lows before repricing inventory.

📈 Repricing teams can export daily snapshots into spreadsheets or pricing systems.

🧑‍💼 Local game stores can compare card and sealed product availability across games.

🧑‍🔬 Market researchers can follow price movement for high-demand cards and sets.

🎴 Collectors can track watchlists without manually opening dozens of TCGplayer searches.

### Why use this scraper?

TCGplayer pages are useful for humans but hard to monitor manually at scale.

This actor gives you repeatable data with a stable schema.

You can schedule it daily or hourly on Apify, export the dataset, and compare results over time.

The output is intentionally flat so it works well in CSV, Google Sheets, BI tools, or downstream automations.

### What TCGplayer data can you extract?

| Field | Description |
| --- | --- |
| `productId` | TCGplayer product ID |
| `title` | Product or card title |
| `productLineName` | Game or product line |
| `setName` | Set name |
| `setCode` | Set code when available |
| `rarityName` | Rarity when available |
| `cardNumber` | Collector/card number when available |
| `marketPrice` | TCGplayer market price |
| `lowestPrice` | Lowest product price |
| `lowestPriceWithShipping` | Lowest price including shipping when available |
| `totalListings` | TCGplayer listing count |
| `topListingPrice` | Top sampled listing price |
| `topListingCondition` | Top listing condition |
| `topListingPrinting` | Top listing printing |
| `topListingSellerName` | Top listing seller name |
| `productUrl` | TCGplayer product URL |
| `imageUrl` | Product image URL |
| `scrapedAt` | Timestamp for the price snapshot |

### How much does it cost to scrape TCGplayer product prices?

The actor uses pay-per-event pricing.

There is a small start charge per run and a per-product charge for each dataset item produced.

The default pricing is designed for scheduled monitoring jobs and scales with the number of products you extract.

For a small 100-product search, cost is usually the start fee plus 100 product events.

Check the Apify run billing panel for exact charged events after each run.

### Input options

Use `searchQueries` for normal marketplace searches.

Use `startUrls` when you already have TCGplayer search URLs or product URLs.

Use `productIds` for exact product monitoring.

Optional filters include `productLineName`, `setName`, and `productTypeName`.

Use `maxItems` to cap output volume.

Use `includeListings` and `listingsPerProduct` to control listing summary extraction.

### Example input

```json
{
  "searchQueries": ["charizard", "one piece manga luffy"],
  "maxItems": 100,
  "includeListings": true,
  "listingsPerProduct": 3
}
````

### Example product ID input

```json
{
  "productIds": ["219059"],
  "maxItems": 1,
  "includeListings": true,
  "listingsPerProduct": 5
}
```

### Example output

```json
{
  "searchQuery": "charizard",
  "productId": 219059,
  "title": "Charizard GX - 9/68 (#60 Charizard Stamped)",
  "productLineName": "Pokemon",
  "setName": "Battle Academy",
  "marketPrice": 13.14,
  "lowestPrice": 7,
  "lowestPriceWithShipping": 7.95,
  "totalListings": 90,
  "topListingCondition": "Moderately Played",
  "productUrl": "https://www.tcgplayer.com/product/219059/pokemon-battle-academy-charizard-gx-9-68-60-charizard-stamped",
  "scrapedAt": "2026-07-09T04:38:06.481Z"
}
```

### How to scrape TCGplayer prices

1. Add one or more search terms, product IDs, or TCGplayer URLs.

2. Set `maxItems` to the number of products you want.

3. Choose whether to include top listing summary fields.

4. Run the actor.

5. Export the dataset as JSON, CSV, Excel, or via API.

### Scheduled monitoring workflow

Create an Apify schedule with the same input.

Run the actor daily for a watchlist of cards or sealed products.

Export each dataset to your data warehouse or spreadsheet.

Compare `marketPrice`, `lowestPrice`, and `totalListings` over time.

Trigger alerts when prices move beyond your thresholds.

### Repricing workflow

Sellers can use the output to compare current inventory prices against TCGplayer market lows.

The fields `lowestPriceWithShipping`, `topListingCondition`, and `topListingPrinting` help prevent misleading comparisons.

Use exact `productIds` for the most stable repricing workflow.

Use broad `searchQueries` when discovering products or monitoring a set.

### Tips for better results

Use specific product names when you want high precision.

Use exact product IDs for recurring jobs.

Use `productLineName` to narrow terms that exist across games.

Keep `maxItems` reasonable for scheduled runs.

Use `includeListings: false` when you only need product-level market prices.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/tcgplayer-product-price-scraper').call({
  searchQueries: ['charizard'],
  maxItems: 100
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/tcgplayer-product-price-scraper').call(
    run_input={'searchQueries': ['charizard'], 'maxItems': 100}
)
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~tcgplayer-product-price-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchQueries":["charizard"],"maxItems":100}'
```

### MCP usage

Use Apify MCP with Claude Desktop or Claude Code to run TCGplayer monitoring jobs from chat.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/tcgplayer-product-price-scraper
```

Claude Code CLI setup:

```bash
claude mcp add apify-tcgplayer "https://mcp.apify.com/?tools=automation-lab/tcgplayer-product-price-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-tcgplayer": {
      "url": "https://mcp.apify.com/?tools=automation-lab/tcgplayer-product-price-scraper"
    }
  }
}
```

Example prompt:

```text
Run the TCGplayer Product Price Scraper for Charizard and return products where marketPrice is above 20 dollars.
```

### Integrations

📊 Send CSV exports to Google Sheets for watchlists.

🧾 Push JSON records into Airtable or Notion databases.

📉 Load daily runs into BigQuery or Snowflake for price history.

🔔 Connect Apify webhooks to Slack alerts for price changes.

🤖 Use MCP to ask an AI assistant for current TCGplayer market snapshots.

### Related scrapers

Browse other Automation Lab actors at https://apify.com/automation-lab/.

Useful adjacent categories include ecommerce scrapers, marketplace price monitors, product search scrapers, and price comparison actors.

### Data freshness

Each dataset row includes `scrapedAt`.

Treat each run as a point-in-time price snapshot.

TCGplayer prices and listing counts can change frequently, so scheduled runs are recommended for monitoring.

### Limitations

The actor extracts public product/search information.

It does not log in to TCGplayer.

It does not manage carts, purchases, seller dashboards, or private account data.

Some rare products may have unavailable market prices.

### Legality

This actor extracts publicly available marketplace information.

### Is it legal to scrape TCGplayer?

This actor extracts publicly available marketplace information.

You are responsible for using the data in compliance with applicable laws, TCGplayer terms, and your own business requirements.

Do not use scraped data for spam, abusive automation, or prohibited resale workflows.

### Troubleshooting: no results

Check that the search term returns products on TCGplayer.

Try removing strict filters such as `productLineName` or `setName`.

Increase `maxItems` if the first page is too narrow.

### Troubleshooting: prices are null

Some products do not have market prices in the TCGplayer response.

Use `lowestPrice` and `lowestPriceWithShipping` when market price is unavailable.

Try including listing summaries for more context.

### FAQ

#### Can I scrape exact products?

Yes. Use `productIds` or paste TCGplayer product URLs in `startUrls`.

#### Can I monitor multiple games in one run?

Yes. Add multiple search queries or omit `productLineName` to search all products.

#### Does it include seller data?

It includes top listing seller summary fields, not full seller profiles.

#### Can I schedule it?

Yes. Use Apify schedules for recurring price monitoring.

#### Can I export to CSV?

Yes. Apify datasets can be exported as CSV, JSON, Excel, XML, RSS, or via API.

### Support

If a TCGplayer page or search term produces unexpected output, share the run input and run ID so the issue can be reproduced.

### Changelog

Initial version extracts TCGplayer product search results, product IDs, market prices, low prices, listing counts, and top listing summaries.

# Actor input Schema

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

TCGplayer search terms such as card names, set names, sealed products, or SKUs.

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

Optional TCGplayer search or product URLs. The actor extracts q= search terms and product IDs from supported URLs.

## `productIds` (type: `array`):

Optional exact TCGplayer product IDs to fetch.

## `productLineName` (type: `string`):

Optional exact TCGplayer product line name, for example Pokemon, Magic, YuGiOh, One Piece Card Game.

## `setName` (type: `string`):

Optional exact TCGplayer set name to narrow the search.

## `productTypeName` (type: `string`):

Optional product type, such as Cards or Sealed Products.

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

Maximum number of product records to save.

## `includeListings` (type: `boolean`):

When enabled, each product includes top listing price/seller/condition fields from the search response.

## `listingsPerProduct` (type: `integer`):

How many top listings to inspect per product for summary fields. Set to 0 to skip listing summaries.

## `sort` (type: `string`):

Optional marketplace sort hint.

## Actor input object example

```json
{
  "searchQueries": [
    "charizard",
    "one piece manga luffy"
  ],
  "startUrls": [
    {
      "url": "https://www.tcgplayer.com/search/all/product?q=charizard"
    }
  ],
  "maxItems": 20,
  "includeListings": true,
  "listingsPerProduct": 3,
  "sort": "relevance"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "searchQueries": [
        "charizard",
        "one piece manga luffy"
    ],
    "startUrls": [
        {
            "url": "https://www.tcgplayer.com/search/all/product?q=charizard"
        }
    ],
    "maxItems": 20,
    "includeListings": true,
    "listingsPerProduct": 3,
    "sort": "relevance"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/tcgplayer-product-price-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 = {
    "searchQueries": [
        "charizard",
        "one piece manga luffy",
    ],
    "startUrls": [{ "url": "https://www.tcgplayer.com/search/all/product?q=charizard" }],
    "maxItems": 20,
    "includeListings": True,
    "listingsPerProduct": 3,
    "sort": "relevance",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/tcgplayer-product-price-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 '{
  "searchQueries": [
    "charizard",
    "one piece manga luffy"
  ],
  "startUrls": [
    {
      "url": "https://www.tcgplayer.com/search/all/product?q=charizard"
    }
  ],
  "maxItems": 20,
  "includeListings": true,
  "listingsPerProduct": 3,
  "sort": "relevance"
}' |
apify call automation-lab/tcgplayer-product-price-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TCGplayer Product Price Scraper",
        "description": "🎴 Extract TCGplayer product prices, market lows, listing counts, card metadata, URLs, and seller summaries for repricing workflows.",
        "version": "0.1",
        "x-build-id": "YSXlFv4N7QJ87IqiG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~tcgplayer-product-price-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-tcgplayer-product-price-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/automation-lab~tcgplayer-product-price-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-tcgplayer-product-price-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/automation-lab~tcgplayer-product-price-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-tcgplayer-product-price-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": {
                    "searchQueries": {
                        "title": "🔎 Search queries",
                        "type": "array",
                        "description": "TCGplayer search terms such as card names, set names, sealed products, or SKUs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "🔗 TCGplayer start URLs",
                        "type": "array",
                        "description": "Optional TCGplayer search or product URLs. The actor extracts q= search terms and product IDs from supported URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "productIds": {
                        "title": "Product IDs",
                        "type": "array",
                        "description": "Optional exact TCGplayer product IDs to fetch.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "productLineName": {
                        "title": "Game / product line filter",
                        "type": "string",
                        "description": "Optional exact TCGplayer product line name, for example Pokemon, Magic, YuGiOh, One Piece Card Game."
                    },
                    "setName": {
                        "title": "Set filter",
                        "type": "string",
                        "description": "Optional exact TCGplayer set name to narrow the search."
                    },
                    "productTypeName": {
                        "title": "Product type filter",
                        "type": "string",
                        "description": "Optional product type, such as Cards or Sealed Products."
                    },
                    "maxItems": {
                        "title": "Maximum products",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of product records to save.",
                        "default": 20
                    },
                    "includeListings": {
                        "title": "Include listing summary",
                        "type": "boolean",
                        "description": "When enabled, each product includes top listing price/seller/condition fields from the search response.",
                        "default": true
                    },
                    "listingsPerProduct": {
                        "title": "Listings sampled per product",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many top listings to inspect per product for summary fields. Set to 0 to skip listing summaries.",
                        "default": 3
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "marketPriceAsc",
                            "marketPriceDesc",
                            "lowestPriceAsc",
                            "lowestPriceDesc"
                        ],
                        "type": "string",
                        "description": "Optional marketplace sort hint.",
                        "default": "relevance"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```