# eBay Sold Price Scraper + Free Comp Analytics (`alextyt/ebay-sold-listings-scraper`) Actor

eBay sold-price scraper: real completed-listing prices across 8 markets plus a free median/percentile/velocity analytics record. $2.50/1k, under the leader.

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

## Pricing

from $2.50 / 1,000 sold listings

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## eBay Sold Price Scraper + Free Comp Analytics

**The asking price is a wish; the sold price is the truth.** This pulls the price eBay buyers *actually paid* — across **8 marketplaces** — and hands you a **free** median, percentile and velocity read on every keyword, so you bid, list, and reprice on facts instead of vibes.

Per sold listing you get the final price, sold date, condition, listing type, bids, shipping and seller. On top, every keyword returns a **free price-distribution record** (median, p10–p90, condition & listing-type breakdowns, sell-through velocity, A–D confidence grade) — the class of pricing intelligence the only other analytics actor on the Store charges **$25 / 1,000** for. Pay per result, no monthly fee.

![Real eBay sold prices across 8 markets — $2.50/1,000, free analytics included](https://api.apify.com/v2/key-value-stores/feNBBUbM9HzDLHUfQ/records/shot1.png?v=1)

![One clean row per sold lot: price, date, condition, listing type, bids](https://api.apify.com/v2/key-value-stores/feNBBUbM9HzDLHUfQ/records/shot2.png?v=1)

![Free price-distribution analytics: median, percentiles, velocity and confidence grade](https://api.apify.com/v2/key-value-stores/feNBBUbM9HzDLHUfQ/records/shot3.png?v=1)

---

### What it does

eBay only keeps **sold/completed** listings visible for ~90 days, and there is no official API for sold prices. This actor reads the public sold-search results pages and returns one clean record per sold lot:

- **Sold price = final transaction price.** For auctions it's the winning bid; for fixed-price it's the Buy-It-Now price; for accepted Best Offers the public price is hidden by eBay (`priceIsMasked: true`) and the shown strike-through price is returned instead.
- No login required. **No buyer or bidder data** is collected (no buyer usernames, bids identities, or addresses). Public seller identity and feedback *are* included, as published by eBay.

### Quick start

1. Enter one or more **keywords** (e.g. `iphone 13`, `pokemon charizard psa 10`) — or paste a **category / search URL**.
2. Pick a **marketplace** (default `ebay.com`) and optional filters: condition, price range, days back.
3. Run. Results stream into the dataset; a free analytics record is appended per keyword.

```json
{
  "keywords": ["iphone 13"],
  "marketplace": "ebay.com",
  "condition": "used",
  "maxResults": 100,
  "daysBack": 30,
  "withAnalytics": true
}
````

### Output fields

| Field | Description |
|---|---|
| `itemId`, `url` | eBay item id and canonical `/itm/{id}` URL |
| `title` | Listing title (cleaned) |
| `soldPrice`, `soldPriceString`, `currency` | Final sold price (number), raw string, currency from the domain |
| `priceIsRange`, `priceIsMasked` | True for multi-variation ranges / Best-Offer-hidden prices |
| `soldDate`, `soldDateText` | Sold date as ISO-8601 UTC **and** the raw eBay text |
| `condition`, `conditionId` | Normalised condition + eBay condition id |
| `listingType`, `bidsCount` | `Auction` / `BuyItNow` / `BestOffer` (`Unknown` only if eBay served a degraded layout); bid count (`null` unless auction) |
| `shippingCost`, `shippingCostString`, `shippingType` | Shipping price; `free` / `paid` / `unknown` |
| `sellerName`, `sellerFeedbackPercent`, `sellerFeedbackCount` | Public seller identity & feedback |
| `itemLocation` | Item location (not buyer PII) |
| `imageUrl` | Primary image (highest-res available) |
| `marketplace`, `keyword`, `scrapedAt` | Provenance |

**Free analytics record** (`_type: "price_distribution_summary"`): `count, mean, median, stdDev, p10, p25, p75, p90, min, max, conditionBreakdown, listingTypeBreakdown, soldPerDay, periodDays, confidenceGrade (A=50+, B=20–49, C=10–19, D<10)`. Computed from the already-fetched data — zero extra requests, not billed. Notes: distribution stats use only **single-value, unmasked** prices (Best Offer and multi-variation prices are excluded, so `bestOffer.median` is `null` by design); `soldPerDay = items ÷ observedSpanDays` where `observedSpanDays` is the actual span between the earliest and latest sold dates in the result set (`soldPerDayBasis` tells you whether it fell back to the requested period).

### Marketplaces

| Domain | Currency | | Domain | Currency |
|---|---|---|---|---|
| ebay.com | USD | | ebay.it | EUR |
| ebay.co.uk | GBP | | ebay.es | EUR |
| ebay.de | EUR | | ebay.ca | CAD |
| ebay.fr | EUR | | ebay.com.au | AUD |

### Pricing

Pay-per-result: **$2.50 / 1,000 sold listings** (`$0.0025` each), no run-start fee. The price-distribution analytics record is **free**. You're only charged for listings actually returned.

### Use cases

- **Know real value before you buy** — run the keyword first: median sold price, p25–p75 range, sell-through velocity, with masked Best Offers and outliers already stripped. The difference between a margin and a mistake.
- **Price a listing to actually sell** — the condition breakdown shows what *used* vs *new* commands; percentiles show where to price for a fast sale vs top dollar; the listing-type split reveals whether auctions or Buy-It-Now win for the SKU.
- **Validate dropshipping margin in real currency** — US in USD, UK in GBP, DE in EUR (proxy auto-pinned per market) vs landed cost; kill a product before spending a cent on ads.
- **Feed an AI repricing / comps tool** — clean structured sold records plus a ready-made analytics object, so your app doesn't crunch stats or babysit a browser.
- **Market & demand research at scale** — batch dozens of keywords; the free per-keyword analytics turns raw sales into instant signal (what moves fast, where prices cluster, how confident each read is, grade A–D).
- **Settle what a collectible is really worth** — recent sold comps for a card, coin, watch or rare item, date-stamped and condition-tagged, masked Best Offers excluded.

### Limitations

- eBay exposes only a **90-day** sold window — older sales can't be retrieved.
- **Best Offer** final prices are hidden by eBay; `priceIsMasked` flags these and returns the listed price.
- **Multi-variation** listings show a price *range* (`priceIsRange: true`); these are excluded from the distribution stats to avoid skew.
- High volume or non-US marketplaces may require switching the proxy to **Residential** (datacenter works at low volume).
- Per-query eBay caps results at ~10,000; split by price range or date window for very broad searches.

### FAQ

**Does this give me what stuff actually SOLD for, or just what sellers are asking?** Sold, not asking. It pulls eBay's completed/SOLD listings — the real number a buyer paid, with currency, the sold date (ISO UTC), and whether it closed via Auction, Buy-It-Now or Best Offer. The difference between "I think it's worth $80" and "eleven closed at a median of $62 in the last three weeks."

**How does the free analytics work, and is it really free?** Genuinely free — it's computed from data already fetched for your query, so it costs nothing extra. Per keyword you get count, mean, median, std-dev, p10/p25/p75/p90, breakdowns by condition and listing type, sell-through velocity (sold/day), and an A–D confidence grade. It's descriptive statistics on historical sold facts — not a forecast or appraisal. You pay only $2.50/1k for the raw results; the verdict on top is on the house.

**Why are you cheaper than the other sold-listings scrapers — what's the catch?** No catch, just leaner. At $2.50/1k you pay 37.5% less than the category leader ($4.00/1k) and a fraction of the only other tool that bundles analytics ($25/1k). It's HTTP-only — no headless browser burning compute — so the savings are structural, not a downgrade. Run a small batch and check it against the leader yourself.

**Is this legal? Are you scraping personal data?** It reads only **public** sold facts eBay itself publishes on completed-listing pages — price, date, condition, listing type, shipping, item location, image. **Zero buyer data, zero bidder identities.** The only person named is the seller, exactly as eBay already publishes their public storefront. For individual sellers a username may be personal data under GDPR/UK-GDPR, so handle the output accordingly. This is independent public-data scraping, not an official eBay feed; you are responsible for compliance with eBay's User Agreement and applicable law.

**Accepted Best Offer prices are hidden on eBay — how do you handle that?** We flag them and exclude them from the stats. eBay deliberately masks the final accepted price on Best Offer sales — any tool claiming to know that number is guessing. We tag those listings (`priceIsMasked: true`) and leave them out of the mean/median/percentiles, so your analytics are built only on prices we can actually verify.

**How far back does the data go?** 90 days — that's eBay's public limit, not ours. For pricing decisions that's the window you want: a comp from nine months ago is stale, the last 90 days is what the market pays now. Want a longer trend? Run it on a schedule and accumulate your own verified history.

**Which marketplaces?** Eight: US, UK, DE, FR, IT, ES, CA, AU. The proxy auto-pins to the right country per marketplace, so a UK query returns GBP, a German one EUR — comps in the currency you actually buy and sell in.

**Why fewer results than `maxResults`?** `maxResults` is a ceiling for the whole run; you may simply have fewer matching sold listings in the chosen window.

***

*Price research on public data. No buyer or bidder personal data is collected; public seller identity is included as published by eBay.*

# Actor input Schema

## `keywords` (type: `array`):

Search terms to look up sold/completed listings for (1-20). Either this or Category URL is required.

## `categoryUrl` (type: `string`):

An eBay search or category URL to scrape directly. Sold/Completed filters are added automatically. Use instead of keywords.

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

eBay domain to search. Currency is derived from the domain.

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

Filter by item condition.

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

Maximum number of sold listings to return across the whole run.

## `daysBack` (type: `integer`):

Only include items sold within this many days (eBay caps the sold window at 90 days).

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

Lower bound of the sold price filter (in the marketplace currency).

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

Upper bound of the sold price filter (in the marketplace currency).

## `withAnalytics` (type: `boolean`):

Append a free price-distribution summary record (median, percentiles, condition & listing-type breakdown, sell-through velocity) per keyword.

## `proxy` (type: `object`):

Proxy configuration. Datacenter (AUTO) works at low volume on ebay.com; for non-US marketplaces the proxy country is auto-pinned to the marketplace, and RESIDENTIAL is recommended for high volume or regional sites.

## Actor input object example

```json
{
  "keywords": [
    "iphone 13"
  ],
  "marketplace": "ebay.com",
  "condition": "any",
  "maxResults": 100,
  "daysBack": 30,
  "withAnalytics": true,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "keywords": [
        "iphone 13"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("alextyt/ebay-sold-listings-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 = { "keywords": ["iphone 13"] }

# Run the Actor and wait for it to finish
run = client.actor("alextyt/ebay-sold-listings-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 '{
  "keywords": [
    "iphone 13"
  ]
}' |
apify call alextyt/ebay-sold-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "eBay Sold Price Scraper + Free Comp Analytics",
        "description": "eBay sold-price scraper: real completed-listing prices across 8 markets plus a free median/percentile/velocity analytics record. $2.50/1k, under the leader.",
        "version": "0.1",
        "x-build-id": "qIdsq0lfcT8K3Mvn4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/alextyt~ebay-sold-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-alextyt-ebay-sold-listings-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/alextyt~ebay-sold-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-alextyt-ebay-sold-listings-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/alextyt~ebay-sold-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-alextyt-ebay-sold-listings-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": {
                    "keywords": {
                        "title": "Keywords",
                        "maxItems": 20,
                        "type": "array",
                        "description": "Search terms to look up sold/completed listings for (1-20). Either this or Category URL is required.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryUrl": {
                        "title": "Category / search URL",
                        "type": "string",
                        "description": "An eBay search or category URL to scrape directly. Sold/Completed filters are added automatically. Use instead of keywords."
                    },
                    "marketplace": {
                        "title": "Marketplace",
                        "enum": [
                            "ebay.com",
                            "ebay.co.uk",
                            "ebay.de",
                            "ebay.fr",
                            "ebay.it",
                            "ebay.es",
                            "ebay.ca",
                            "ebay.com.au"
                        ],
                        "type": "string",
                        "description": "eBay domain to search. Currency is derived from the domain.",
                        "default": "ebay.com"
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "any",
                            "new",
                            "used",
                            "refurbished",
                            "open_box",
                            "for_parts"
                        ],
                        "type": "string",
                        "description": "Filter by item condition.",
                        "default": "any"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 600,
                        "type": "integer",
                        "description": "Maximum number of sold listings to return across the whole run.",
                        "default": 100
                    },
                    "daysBack": {
                        "title": "Days back",
                        "minimum": 1,
                        "maximum": 90,
                        "type": "integer",
                        "description": "Only include items sold within this many days (eBay caps the sold window at 90 days).",
                        "default": 30
                    },
                    "minPrice": {
                        "title": "Min price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lower bound of the sold price filter (in the marketplace currency)."
                    },
                    "maxPrice": {
                        "title": "Max price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Upper bound of the sold price filter (in the marketplace currency)."
                    },
                    "withAnalytics": {
                        "title": "Include price analytics",
                        "type": "boolean",
                        "description": "Append a free price-distribution summary record (median, percentiles, condition & listing-type breakdown, sell-through velocity) per keyword.",
                        "default": true
                    },
                    "proxy": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy configuration. Datacenter (AUTO) works at low volume on ebay.com; for non-US marketplaces the proxy country is auto-pinned to the marketplace, and RESIDENTIAL is recommended for high volume or regional sites.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```