# Reverb Scraper — Sold Listings & Price Guide (`devilscrapes/reverb-sold-listings`) Actor Pull Reverb's sold-listing-based estimated value range for any musical-gear search via the Reverb price-guide API — used-price lows and highs plus make, model, year, finish — export to JSON or CSV. One row per price guide. No login; we handle the retries. - **URL**: https://apify.com/devilscrapes/reverb-sold-listings.md - **Developed by:** [DevilScrapes](https://apify.com/devilscrapes) (community) - **Categories:** E-commerce - **Stats:** 2 total users, 0 monthly users, 50.0% runs succeeded, NaN 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. 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 Reverb Scraper — Sold Listings & Price Guide Data ## Reverb Scraper — Sold Listings & Price Guide Data _We do the dirty work so your dataset stays clean._ 😈 **$5.05 / 1,000 rows** — Pull Reverb's **sold-listing-based estimated value range** for any musical gear search. One row per price guide entry: `priceLow`, `priceHigh`, make, model, year, finish, product type — the same signal Reverb's own price-guide pages publish. We handle the blocks, the retries, and the fingerprint rotation. You get clean JSON. The Reverb Price Guide is the internet's largest public database of musical-instrument valuations, computed directly from completed sales ("We look at sold listings — based on how much gear in the same condition has sold for on Reverb recently"). Reverb offers no bulk export and no public API for estimates. This reverb scraper walks the price-guide search API, fetches each matching guide's estimated value range from Reverb's GraphQL endpoint, and emits one flat dataset row per guide — ready for reseller pricing models, gear-investment tracking, insurance valuations, or used-instrument market journalism. ### 🎯 What this scrapes One row per Reverb price-guide entry. Each row carries the estimated sold-based value range (low and high) alongside full gear context. The `marketplace_url` links to Reverb's live marketplace search for the item — useful for cross-referencing current asking prices against the estimated value. | Field | Type | Description | |---|---|---| | `guide_id` | integer | Reverb price-guide entry ID | | `guide_title` | string | Human-readable title (e.g. `Fender Stratocaster 1979 Red`) | | `make` | string \| null | Manufacturer (e.g. `Fender`) | | `model` | string \| null | Model name (e.g. `Stratocaster`) | | `year` | string \| null | Year string — Reverb mixes `1979` / `1970s` | | `finish` | string \| null | Finish / colour (e.g. `Red`, `Sunburst`) | | `product_type` | string \| null | Reverb category (e.g. `Electric Guitars`, `Tube Combos`) | | `estimate_low_amount` | number \| null | Low end of estimated value, original currency | | `estimate_low_cents` | integer \| null | Low end in smallest currency unit (e.g. cents) | | `estimate_low_display` | string \| null | Reverb's pre-formatted low estimate (e.g. `$935`) | | `estimate_high_amount` | number \| null | High end of estimated value, original currency | | `estimate_high_cents` | integer \| null | High end in smallest currency unit | | `estimate_high_display` | string \| null | Reverb's pre-formatted high estimate (e.g. `$1,320`) | | `estimate_currency` | string \| null | ISO 4217 currency code (e.g. `USD`) | | `marketplace_url` | string | Reverb marketplace search link for this gear | | `scraped_at` | string | ISO 8601 UTC datetime this row was written | ### 🔥 Features - **Sold-data signal, not speculative listing prices** — Reverb's estimated value range is computed from actual completed transactions on the platform. The `priceLow` / `priceHigh` pair is the same figure Reverb displays on their own price-guide pages under the heading "Estimated Value." - **Two-stage pipeline** — supply a free-text `query` (e.g. `fender stratocaster`) and the Actor pages Reverb's price-guide search API, optionally filters by `productType`, then fetches each matching guide's estimate via Reverb's GraphQL endpoint. One row out per guide. - **Or skip the search entirely** — supply explicit `guideIds` and the Actor goes straight to the estimate fetch. Useful for incremental crawls, watch-lists, and price-monitoring pipelines. - **`maxGuides` cap** — generic queries like `fender` match tens of thousands of price-guide entries; the cap (default 20, up to 200) keeps fan-out bounded and cost predictable. - **Pydantic v2 input validation** — XOR between `query` and `guideIds` enforced before any network call; `maxGuides` bounds enforced at parse time. - **We rotate browser fingerprints** — `curl-cffi` with Chrome/Firefox/Safari TLS impersonation means Reverb's servers see real-browser traffic, not raw Python. - **We retry with exponential backoff** — `408 / 429 / 503` trigger a retry sequence (2 → 4 → 8 → 16 → 30 s, max 5 attempts) with `Retry-After` honoured. - **We rotate proxies on every block** — Apify Proxy handles IP rotation so a single rate-limited IP never stalls your run. - **Clean, Pydantic-validated rows** — every dataset row passes schema validation before it lands. ISO 8601 timestamps, stable column names, no partial writes. - **Pay only for results that land** — no data, no charge beyond the small `actor-start` warm-up fee. ### 💡 Use cases - **Reseller pricing models** — fetch estimated value ranges for every variant of a model (Gibson Les Paul, all years and finishes), feed the `estimate_low` / `estimate_high` pairs into your pricing algorithm, and stop pricing by gut. - **Gear-investment and vintage-appreciation tracking** — schedule weekly runs for canonical vintage models (1959 Les Paul, 1965 Fender Twin Reverb) and watch the estimate bands move over time. The data is direct from Reverb's sold-price engine. - **Insurance valuation** — pull estimates for a specific instrument and export them as a defensible "current market value" backed by Reverb's own sold-data methodology. Works for individual items or entire collections. - **Used-gear market journalism** — Reverb's estimates are the de facto standard for secondhand instrument values. Pull a category-wide sweep (`productType=Electric Guitars`, `query=gibson`) and you have the dataset behind a market-movement story. - **Buy / sell price-band alerts** — combine with a downstream notification workflow: if `estimate_low_amount` for a target guide crosses a threshold, fire an alert. The Actor's `guideIds` mode makes repeated single-guide polling cheap. - **Shop inventory appraisal** — for a guitar shop doing a bulk valuation, run one `guideIds` batch against all catalogue SKUs and get the Reverb-anchored estimate for every piece in the warehouse. ### ⚙️ How to use it 1. Open the Actor input form in Apify Console. 2. Provide **either** `query` (free-text search) **or** `guideIds` (explicit Reverb price-guide IDs). Providing both or neither raises a validation error before any network call. 3. Optionally narrow `query` mode with `productType` — case-insensitive match against Reverb's category column. Common values: `Electric Guitars`, `Bass Guitars`, `Tube Combos`, `Solid State Combos`, `Pedals`, `Synths`, `Drum Sets`. 4. Set `maxGuides` to cap how many estimate rows to emit (default 20, up to 200). Generic queries can match tens of thousands of entries; the cap keeps cost predictable. 5. Leave `useProxy` on (default) — we use it for IP rotation and stability. Disable only when debugging locally. 6. Click **Start**. Results stream into the default dataset as JSON, CSV, Excel, or XML. #### Search for one model — top 20 estimates ```json { "query": "fender stratocaster", "productType": "Electric Guitars", "maxGuides": 20, "useProxy": true } ```` #### Direct guide-ID mode (skip the search) ```json { "guideIds": ["18677", "1404", "1021"], "useProxy": true } ``` #### Wide category sweep ```json { "query": "gibson les paul", "productType": "Electric Guitars", "maxGuides": 200, "useProxy": true } ``` ### 📥 Input | Field | Type | Required | Default | Description | |---|---|---|---|---| | `query` | string | XOR | — | Free-text search passed to Reverb's price-guide API. XOR with `guideIds`. Prefilled: `fender stratocaster`. | | `guideIds` | string\[] | XOR | — | Explicit Reverb price-guide IDs to fetch estimates for (skips the search stage). | | `productType` | string | no | — | Case-insensitive filter on `product_type` (query mode only). E.g. `Electric Guitars`, `Pedals`. | | `maxGuides` | integer | no | `20` | Cap on estimate rows emitted (1–200). The Actor over-fetches search results to hit this target after skipping guides without a published estimate. | | `useProxy` | boolean | no | `true` | Route requests through Apify Proxy for IP rotation and stability. | Exactly one of `query` or `guideIds` must be provided. ### 📤 Output One row per Reverb price-guide entry that has a published estimate. Field shapes match the table in the "What this scrapes" section above. Export to JSON, CSV, Excel, or XML from the Apify Console. Example row (live run, 2026-06-01): ```json { "guide_id": 18677, "guide_title": "Fender Stratocaster 1979 Red", "make": "Fender", "model": "Stratocaster", "year": "1979", "finish": "Red", "product_type": "Electric Guitars", "estimate_low_amount": 935.0, "estimate_low_cents": 93500, "estimate_low_display": "$935", "estimate_high_amount": 1320.0, "estimate_high_cents": 132000, "estimate_high_display": "$1,320", "estimate_currency": "USD", "marketplace_url": "https://reverb.com/marketplace?query=Fender+Stratocaster+1979+Red", "scraped_at": "2026-06-01T06:03:40+00:00" } ``` Guides that Reverb hasn't published an estimate for (roughly 20% of search results) are skipped cleanly — the Actor over-fetches search pages to compensate and still reach `maxGuides` rows. ### 💰 Pricing This Actor is priced **per-event** — you pay only for results that land in your dataset. | Event | Price (USD) | When charged | |---|---|---| | `actor-start` | $0.05 | Once at the start of each run | | `result-row` | $0.005 | Per estimate row written to the dataset | A run of 20 guides (the default) costs **$0.15 total**. A full 200-guide sweep costs **$1.05**. The default `maxGuides=20` keeps trial runs cheap. Gear-pricing SaaS tools charge $50–200/month per seat for used-instrument valuation data. Reverb publishes no bulk export. This Actor is the only programmatic way to pull this signal at scale. ### 🚧 Limitations - **One row per guide, not per transaction** — Reverb retired its per-transaction public endpoint in 2026. The estimated value range is Reverb's current authoritative sold-data signal; individual transaction-level rows (sale date, condition, buyer-paid amount) are no longer available from any public Reverb API path. - **~20% of guides have no published estimate** — Reverb only computes an estimate when enough recent sold data exists for that specific guide. Guides without estimates are skipped; the Actor over-fetches to compensate. - **No individual condition tiers** — Reverb's estimate is a single range across all conditions for that guide. Condition-stratified pricing requires downstream logic on your side. - **Day-precision `scraped_at`** — the estimate itself carries no timestamp from Reverb; `scraped_at` records when this Actor fetched the row. - **Individual guide pages are gone** — Reverb retired `reverb.com/price-guide/guide/` pages (they 301 to a search landing). The `marketplace_url` column links to Reverb's marketplace search instead, which shows current live listings for the gear. - **Generic queries may exhaust `maxGuides` quickly** — `query=fender` matches tens of thousands of entries; the Actor walks search pages until `maxGuides` rows have been emitted. Tighten with `productType` and a more specific query for targeted results. - **Currency is whatever Reverb returns** — most estimates are in USD; `estimate_currency` tells you which. ### ❓ FAQ **Q: Why did the output shape change from per-transaction to per-guide?** Reverb retired the public `/api/priceguide/{id}/transactions` endpoint in 2026 — it now returns empty results for every guide. The estimated value range (fetched from Reverb's GraphQL endpoint) is the current authoritative sold-data signal Reverb publishes. We made the change in v0.3.0 rather than ship an Actor that emits zero rows. **Q: Is the estimated value range really based on sold listings?** Yes — Reverb's own price-guide pages state: "We look at sold listings, which means that the value you see is based on how much gear in the same condition has sold for on Reverb recently." This reverb scraper fetches that same figure programmatically. **Q: Is there an official Reverb API for sold listings or price guide data?** Reverb has no official public API for sold listing data or bulk price guide exports. Reverb's own documentation does not cover programmatic access to the price guide — no reverb api key, no OAuth, no documented endpoint. This Actor is the only programmatic route to Reverb sold listings at scale. **Q: What is "reverb data export" and how do I do it?** Reverb offers no native bulk data export. You can't download reverb sold listings as CSV or JSON from the Reverb dashboard. This Actor is the reverb data export path: run it with your search terms or guide IDs and download the results as JSON, CSV, Excel, or XML from the Apify Console. **Q: How do I get estimates for a fixed list of gear items?** Use `guideIds` mode. Supply the numeric guide IDs as strings. You can find a guide's ID from the `guide_id` field of any previous run, or by inspecting Reverb's price-guide search results. **Q: Why does `maxGuides` cap the output but the Actor sometimes fetches more pages?** Reverb doesn't tell us upfront which guides have a published estimate. The Actor over-fetches search results — walking more guide entries than `maxGuides` — to ensure it reaches the requested count after skipping guides without estimates. Billing is still based only on rows actually emitted. **Q: What happens when zero estimates are found?** The Actor exits with a non-zero status code and sets a clear status message (`No estimate rows emitted — N guides inspected`). You'll see it in the run summary. You will still be charged the `actor-start` fee. **Q: Can I poll a single guide repeatedly for price changes?** Yes. Use `guideIds` mode with a single ID. The `actor-start` fee is $0.05 and the one row emitted costs $0.005 — about 5.5 cents per poll. Apify's Scheduler can automate this on any interval. **Q: Does the Actor de-duplicate across runs?** No. Each run emits fresh rows from the current Reverb data. De-dup on `guide_id` downstream if you're accumulating results over time. ### 💬 Your feedback This Actor is built and maintained by [Devil Scrapes](https://apify.com/DevilScrapes). If a Reverb search returns fewer rows than expected, if you notice the estimate shape has changed upstream, or if you need a feature (condition-tier breakdown, scheduled monitoring mode), [open an issue on the Actor page](https://apify.com/DevilScrapes/reverb-sold-listings/issues) and we'll patch it within a release cycle. The target blocks; we get back up. # Actor input Schema ## `query` (type: `string`): Free-text search passed to Reverb's price-guide API (e.g. fender stratocaster, marshall jcm800, fender precision bass). Either query OR guideIds must be provided — not both. ## `guideIds` (type: `array`): Explicit Reverb price-guide entry IDs to drill into directly (skips the search stage). Each ID is fetched for its estimated value. Either query OR guideIds must be provided — not both. ## `productType` (type: `string`): Optional case-insensitive filter on the Reverb category (e.g. Electric Guitars, Bass Guitars, Tube Combos, Pedals). Only applied in query mode; ignored when using guideIds. ## `maxGuides` (type: `integer`): Cap on how many price-guide estimate rows to emit. The Actor over-fetches search entries to reach this many rows after skipping guides without a published estimate. Range 1-200. ## `useProxy` (type: `boolean`): Route requests through Apify Proxy (BUYPROXIES94952). Recommended ON for stability. Disable only for debugging. ## Actor input object example ```json { "query": "fender stratocaster", "guideIds": [ "1404", "1021" ], "productType": "Electric Guitars", "maxGuides": 20, "useProxy": true } ``` # Actor output Schema ## `datasetItems` (type: `string`): All dataset items as JSON. ## `datasetItemsCsv` (type: `string`): Same data exported to CSV. ## `datasetView` (type: `string`): Open the run dataset in the Console. # 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 = { "query": "fender stratocaster" }; // Run the Actor and wait for it to finish const run = await client.actor("devilscrapes/reverb-sold-listings").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 = { "query": "fender stratocaster" } # Run the Actor and wait for it to finish run = client.actor("devilscrapes/reverb-sold-listings").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 '{ "query": "fender stratocaster" }' | apify call devilscrapes/reverb-sold-listings --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=devilscrapes/reverb-sold-listings", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Reverb Scraper — Sold Listings & Price Guide", "description": "Pull Reverb's sold-listing-based estimated value range for any musical-gear search via the Reverb price-guide API — used-price lows and highs plus make, model, year, finish — export to JSON or CSV. One row per price guide. No login; we handle the retries.", "version": "0.3", "x-build-id": "oGBkwVQVgVBiFNVcJ" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/devilscrapes~reverb-sold-listings/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-devilscrapes-reverb-sold-listings", "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/devilscrapes~reverb-sold-listings/runs": { "post": { "operationId": "runs-sync-devilscrapes-reverb-sold-listings", "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/devilscrapes~reverb-sold-listings/run-sync": { "post": { "operationId": "run-sync-devilscrapes-reverb-sold-listings", "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": { "query": { "title": "Search query", "type": "string", "description": "Free-text search passed to Reverb's price-guide API (e.g. fender stratocaster, marshall jcm800, fender precision bass). Either query OR guideIds must be provided — not both." }, "guideIds": { "title": "Reverb price-guide IDs", "type": "array", "description": "Explicit Reverb price-guide entry IDs to drill into directly (skips the search stage). Each ID is fetched for its estimated value. Either query OR guideIds must be provided — not both.", "items": { "type": "string" } }, "productType": { "title": "Product type filter (query mode only)", "type": "string", "description": "Optional case-insensitive filter on the Reverb category (e.g. Electric Guitars, Bass Guitars, Tube Combos, Pedals). Only applied in query mode; ignored when using guideIds." }, "maxGuides": { "title": "Max price-guide estimate rows", "minimum": 1, "maximum": 200, "type": "integer", "description": "Cap on how many price-guide estimate rows to emit. The Actor over-fetches search entries to reach this many rows after skipping guides without a published estimate. Range 1-200.", "default": 20 }, "useProxy": { "title": "Use Apify Proxy", "type": "boolean", "description": "Route requests through Apify Proxy (BUYPROXIES94952). Recommended ON for stability. Disable only for debugging.", "default": true } } }, "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 } } } } } } } } } } ```