# TCGplayer Scraper (`solidcode/tcgplayer-scraper`) Actor \[💰 $3.0 / 1K] Extract trading card prices and seller listings from TCGplayer — market, median, and lowest prices plus seller offers and optional sales history for Magic, Pokémon, Yu-Gi-Oh!, Lorcana, and more. - **URL**: https://apify.com/solidcode/tcgplayer-scraper.md - **Developed by:** [SolidCode](https://apify.com/solidcode) (community) - **Categories:** E-commerce, Automation, Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks - **User rating**: No ratings yet ## Pricing from $3.00 / 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. 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 Scraper Pull live trading-card pricing from TCGplayer at scale — market, median, and lowest prices, real-time seller offers, and recent sales history for every card across Magic: The Gathering, Pokémon, Yu-Gi-Oh!, Disney Lorcana, One Piece, and more. Search by keyword or paste the exact product pages you already track, and get one clean row per card with every price signal bundled in. Built for card investors, arbitrage sellers, local game store owners, and deck builders who need up-to-the-minute TCG market data without checking hundreds of product pages by hand. ### Why This Scraper? - **Four price signals on every card** — market price, median price, lowest price, and lowest price *with shipping*, so you compare apples to apples instead of getting fooled by a cheap listing with a $5 shipping tax. - **Live seller offers per card** — capture up to 25+ individual offers each with seller name, seller rating, verified-seller flag, asking price, shipping cost, condition, printing, and quantity in stock. - **True listing count even when offers are trimmed** — `listingCount` always carries the full number of sellers (we've seen 600+ on a single hot card) even when you cap the nested offers to keep rows compact. - **Eight trading card games in one actor** — Magic: The Gathering, Pokémon, Yu-Gi-Oh!, Disney Lorcana, Flesh and Blood, Digimon, One Piece, and Star Wars: Unlimited, scoped with a single dropdown. - **Optional sales-history enrichment** — flip one toggle to add recent completed sales (price, shipping, date, condition, printing) plus per-SKU price points (market, lowest, highest) split by Normal and Foil. - **Five sort modes including Best Selling** — order results by Best Match, Best Selling, Name A→Z, Price Low→High, or Price High→Low to surface the hottest singles or the cheapest copies first. - **Search by keyword OR exact product URL** — type "charizard" to sweep the catalog, or paste the specific TCGplayer product pages for cards already in your portfolio. - **One billable row per card** — seller offers and sales history nest *inside* each product row, so a card with 600 sellers is still a single result. You are never charged per offer or per sale. ### Use Cases **Card Investing & Portfolio Tracking** - Monitor market price moves on the singles you hold and flag breakouts early - Compare market vs. median to spot cards trading above or below their typical value - Track recent completed sales to value a collection at true clearing prices - Watch lowest-price floors to time buys and sells **Arbitrage & Reselling** - Surface cards where the lowest listing sits well under market price - Factor lowest-price-with-shipping to find genuinely underpriced copies - Pull verified-seller offers and quantities to source bulk inventory - Sort by Best Selling to find the fastest-moving singles to flip **Local Game Store Pricing** - Reprice your case and showcase singles against live market data every morning - Benchmark your buy prices against current seller-offer floors - Track competing sellers' conditions, printings, and shipping on key SKUs - Build category-wide price sheets for Magic, Pokémon, and Yu-Gi-Oh! inventory **Deck-Building & Collection Management** - Price out a full decklist by feeding card names as search queries - Pull set, rarity, card number, and printing for accurate collection cataloging - Capture canonical product URLs and 1000×1000 card images for your database - Track Normal vs. Foil price points side by side **Market Research** - Map pricing across an entire game category or expansion set - Analyze how condition and printing affect realized sale prices - Measure listing depth (seller count) as a liquidity signal per card - Feed structured TCG pricing into dashboards and valuation models ### Getting Started #### Simple — Search by Card Name ```json { "searchQueries": ["charizard"], "maxResults": 50 } ```` #### Scoped Search with Sorting Limit to one game and surface the hottest singles first: ```json { "searchQueries": ["pikachu", "snorlax"], "category": "pokemon", "sortBy": "bestSelling", "maxResults": 200, "maxListingsPerProduct": 10 } ``` #### Track Exact Cards by URL with Full History Paste the product pages you already follow and turn on sales-history enrichment: ```json { "productUrls": [ "https://www.tcgplayer.com/product/42364/pokemon-base-set-charizard", "https://www.tcgplayer.com/product/610549/magic-the-gathering-the-one-ring" ], "includeSalesHistory": true, "maxListingsPerProduct": 25 } ``` ### Input Reference #### What to Scrape | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `searchQueries` | string\[] | `["charizard"]` | Card or product names to search for, such as "charizard" or "black lotus". Each query is scraped separately. | | `productUrls` | string\[] | `[]` | Paste exact TCGplayer product page URLs to scrape specific cards directly. Use this when you already know the cards you want. | #### Filters | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `category` | select | *(all games)* | Limit searches to one game: Magic: The Gathering, Pokémon, Yu-Gi-Oh!, Disney Lorcana, Flesh and Blood, Digimon, One Piece Card Game, or Star Wars: Unlimited. Leave blank to search across everything. | | `sortBy` | select | `Best Match` | Result ordering: Best Match, Best Selling, Name: A to Z, Price: Low to High, or Price: High to Low. | #### Limits | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `startPage` | integer | `1` | Which result page to start from for each query (each page holds 24 products). | | `maxResults` | integer | `100` | The most products to return across the whole run. Set to 0 for no limit (be mindful of cost). | #### Extra Data | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `includeSalesHistory` | boolean | `false` | Also collect recent sales and price points for each product, split by Normal / Foil. Adds depth at the cost of a slower run. Leave off for the fastest, lowest-cost runs. | | `maxListingsPerProduct` | integer | `25` | How many individual seller offers to include with each product. Popular cards can have hundreds — this keeps each result compact. Set to 0 to skip seller offers entirely. | ### Output Each result is one product row (`recordType: "product"`) with its seller offers and optional sales history nested inside. Here's a representative result with sales history enabled: ```json { "recordType": "product", "productId": 42364, "name": "Charizard", "setName": "Base Set", "categoryName": "Pokemon", "rarity": "Holo Rare", "cardNumber": "4/102", "cardType": "Fire", "energyType": "Fire", "printing": "Holofoil", "condition": "Near Mint", "marketPrice": 412.55, "medianPrice": 399.99, "lowestPrice": 350.00, "lowestPriceWithShipping": 354.99, "listingCount": 550, "listings": [ { "sellerName": "CardKingdomTCG", "sellerRating": 99.8, "verified": true, "price": 350.00, "shippingPrice": 4.99, "condition": "Near Mint", "printing": "Holofoil", "quantity": 2 } ], "_enrichment": { "recentSales": [ { "condition": "Near Mint", "printing": "Holofoil", "language": "English", "quantity": 1, "purchasePrice": 405.00, "shippingPrice": 0.0, "orderDate": "2026-05-27T18:22:00Z" } ], "pricePoints": [ { "skuId": 1234567, "marketPrice": 412.55, "lowestPrice": 350.00, "highestPrice": 899.99, "priceCount": 488 } ] }, "imageUrl": "https://tcgplayer-cdn.tcgplayer.com/product/42364_in_1000x1000.jpg", "url": "https://www.tcgplayer.com/product/42364", "sourceQuery": "charizard", "scrapedAt": "2026-05-29T14:30:00Z" } ``` #### Core Fields | Field | Type | Description | |-------|------|-------------| | `recordType` | string | Always `"product"` — the billable unit. | | `productId` | integer | TCGplayer product identifier. | | `name` | string | Card or product name. | | `setName` | string | Set or expansion name. | | `categoryName` | string | Game category (Magic, Pokemon, YuGiOh, etc.). | | `rarity` | string | Card rarity, when applicable. | | `cardNumber` | string | Collector / card number, when applicable. | | `cardType` | string | Card type (game-specific; often null on sealed products). | | `energyType` | string | Pokémon energy type or equivalent, when applicable. | | `printing` | string | Printing variant (Normal, Foil, Holofoil, etc.). | | `condition` | string | Condition tier for the headline price (e.g. Near Mint). | | `imageUrl` | string | 1000×1000 product image URL. | | `url` | string | Canonical TCGplayer product URL. | | `sourceQuery` | string | The search term that produced this row, or `"url"` for URL inputs. | | `scrapedAt` | string | ISO 8601 timestamp of capture. | #### Pricing | Field | Type | Description | |-------|------|-------------| | `marketPrice` | number | TCGplayer calculated market value. | | `medianPrice` | number | Median across current listings. | | `lowestPrice` | number | Lowest listing price before shipping. | | `lowestPriceWithShipping` | number | Lowest total cost including shipping. | | `listingCount` | integer | True total seller offers available — full count even when `listings` is trimmed. | #### Seller Offers `listings` is an array of seller offers, bounded by `maxListingsPerProduct`. | Field | Type | Description | |-------|------|-------------| | `sellerName` | string | Marketplace seller name. | | `sellerRating` | number | Seller's feedback rating. | | `verified` | boolean | Whether the seller is a verified seller. | | `price` | number | Asking price before shipping. | | `shippingPrice` | number | Shipping cost for this offer. | | `condition` | string | Card condition for this offer. | | `printing` | string | Printing variant for this offer. | | `quantity` | integer | Quantity in stock from this seller. | #### Sales History `_enrichment` is present only when `includeSalesHistory` is on. It holds two arrays: | Field | Type | Description | |-------|------|-------------| | `recentSales[].purchasePrice` | number | Price of a recent completed sale. | | `recentSales[].shippingPrice` | number | Shipping paid on that sale. | | `recentSales[].condition` | string | Condition of the sold card. | | `recentSales[].printing` | string | Printing of the sold card. | | `recentSales[].language` | string | Language of the sold card. | | `recentSales[].quantity` | integer | Quantity in that sale. | | `recentSales[].orderDate` | string | Date of the sale. | | `pricePoints[].marketPrice` | number | Market price for that SKU (condition × printing). | | `pricePoints[].lowestPrice` | number | Lowest price for that SKU. | | `pricePoints[].highestPrice` | number | Highest price for that SKU. | | `pricePoints[].priceCount` | integer | Number of listings behind that price point. | ### Tips for Best Results - **Start small to test** — set `maxResults` to 10–50 on your first run to confirm the cards match what you expect, then scale up. - **Use Best Selling to find the hot singles** — `sortBy: "bestSelling"` surfaces the fastest-moving cards in a category, ideal for spotting trending plays and flip candidates. - **Paste product URLs for cards you already track** — `productUrls` resolves to the exact card every time, so your portfolio rows never drift to a similarly-named print. - **Keep `maxListingsPerProduct` low to control row size** — set it to 5–10 for pricing sweeps; the `listingCount` field still reports the true total seller depth even when offers are trimmed. - **Leave sales history off for fast price sweeps** — `includeSalesHistory` adds extra data per card and slows the run; turn it on only when you need realized sale prices for valuation. - **Compare market vs. lowest-with-shipping for true deals** — a low headline price with heavy shipping often costs more than a pricier listing with free shipping; `lowestPriceWithShipping` is the number that matters for buyers. - **Scope generic names with a category** — a query like "charizard" or "dragon" spans multiple games; set `category` to keep results to the one you trade. ### Pricing **$3.00 per 1,000 results** — pay-per-result, undercutting comparable TCG scrapers. No compute charges — you only pay per result returned. | Results | Estimated Cost | |---------|----------------| | 100 | $0.30 | | 1,000 | $3.00 | | 10,000 | $30.00 | | 100,000 | $300.00 | A "result" is one product row — its nested seller offers and sales history are bundled in at no extra cost. You are never charged per seller offer or per sale, only per product. Platform fees (storage and data transfer) depend on your Apify plan. ### Integrations Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via: - **Zapier** / **Make** / **n8n** — Workflow automation - **Google Sheets** — Direct spreadsheet export - **Slack** / **Email** — Notifications on new results - **Webhooks** — Trigger custom APIs on run completion - **Apify API** — Full programmatic access ### Legal & Ethical Use This actor is designed for legitimate trading-card market research, pricing analysis, and inventory management. Users are responsible for complying with applicable laws and TCGplayer's Terms of Service. Collect only publicly available pricing and listing data, respect reasonable request volumes, and do not use seller information for spam, harassment, or any unlawful purpose. # Actor input Schema ## `searchQueries` (type: `array`): Card or product names to search for, such as 'charizard' or 'black lotus'. Each query is scraped separately. Leave empty if you only want to use product URLs. ## `productUrls` (type: `array`): Paste exact TCGplayer product page URLs to scrape specific cards directly. Use this when you already know the cards you want. ## `category` (type: `string`): Limit searches to one game or category. Leave blank to search across everything. ## `sortBy` (type: `string`): How search results are ordered. ## `startPage` (type: `integer`): Which result page to start from for each query (each page holds 24 products). ## `maxResults` (type: `integer`): The most products to return across the whole run. Set to 0 for no limit, which collects up to about 120,000 products per query (be mindful of cost). ## `includeSalesHistory` (type: `boolean`): Also collect the most recent sales (up to 25 per product) and price points for each product (split by Normal / Foil). This fetches extra data per product and makes the run slower. ## `maxListingsPerProduct` (type: `integer`): How many individual seller offers to include with each product. Popular cards can have hundreds — this keeps each result compact. Set to 0 to skip seller offers entirely. ## Actor input object example ```json { "searchQueries": [ "charizard" ], "productUrls": [], "sortBy": "bestMatch", "startPage": 1, "maxResults": 100, "includeSalesHistory": false, "maxListingsPerProduct": 25 } ``` # Actor output Schema ## `overview` (type: `string`): Table of products with name, set, prices, and listing count. ## `details` (type: `string`): Full per-product rows including card attributes, seller offers, and image. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "searchQueries": [ "charizard" ], "productUrls": [], "sortBy": "bestMatch", "startPage": 1, "maxResults": 100, "includeSalesHistory": false, "maxListingsPerProduct": 25 }; // Run the Actor and wait for it to finish const run = await client.actor("solidcode/tcgplayer-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "searchQueries": ["charizard"], "productUrls": [], "sortBy": "bestMatch", "startPage": 1, "maxResults": 100, "includeSalesHistory": False, "maxListingsPerProduct": 25, } # Run the Actor and wait for it to finish run = client.actor("solidcode/tcgplayer-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" ], "productUrls": [], "sortBy": "bestMatch", "startPage": 1, "maxResults": 100, "includeSalesHistory": false, "maxListingsPerProduct": 25 }' | apify call solidcode/tcgplayer-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=solidcode/tcgplayer-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "TCGplayer Scraper", "description": "[💰 $3.0 / 1K] Extract trading card prices and seller listings from TCGplayer — market, median, and lowest prices plus seller offers and optional sales history for Magic, Pokémon, Yu-Gi-Oh!, Lorcana, and more.", "version": "1.0", "x-build-id": "aVtJeKcx5vIhEsCdX" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/solidcode~tcgplayer-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-solidcode-tcgplayer-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/solidcode~tcgplayer-scraper/runs": { "post": { "operationId": "runs-sync-solidcode-tcgplayer-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/solidcode~tcgplayer-scraper/run-sync": { "post": { "operationId": "run-sync-solidcode-tcgplayer-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": "Card or product names to search for, such as 'charizard' or 'black lotus'. Each query is scraped separately. Leave empty if you only want to use product URLs.", "items": { "type": "string" } }, "productUrls": { "title": "Product URLs", "type": "array", "description": "Paste exact TCGplayer product page URLs to scrape specific cards directly. Use this when you already know the cards you want.", "items": { "type": "string" } }, "category": { "title": "Game / Category", "enum": [ "magic", "pokemon", "yugioh", "lorcana", "fleshandblood", "digimon", "onepiece", "starwars" ], "type": "string", "description": "Limit searches to one game or category. Leave blank to search across everything." }, "sortBy": { "title": "Sort Results By", "enum": [ "bestMatch", "bestSelling", "aToZ", "priceLowHigh", "priceHighLow" ], "type": "string", "description": "How search results are ordered.", "default": "bestMatch" }, "startPage": { "title": "Start Page", "minimum": 1, "type": "integer", "description": "Which result page to start from for each query (each page holds 24 products).", "default": 1 }, "maxResults": { "title": "Maximum Products", "minimum": 0, "type": "integer", "description": "The most products to return across the whole run. Set to 0 for no limit, which collects up to about 120,000 products per query (be mindful of cost).", "default": 100 }, "includeSalesHistory": { "title": "Include Sales History", "type": "boolean", "description": "Also collect the most recent sales (up to 25 per product) and price points for each product (split by Normal / Foil). This fetches extra data per product and makes the run slower.", "default": false }, "maxListingsPerProduct": { "title": "Seller Offers per Product", "minimum": 0, "type": "integer", "description": "How many individual seller offers to include with each product. Popular cards can have hundreds — this keeps each result compact. Set to 0 to skip seller offers entirely.", "default": 25 } } }, "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 } } } } } } } } } } ```