# eBay Seller Listings Scraper - Any Store's Full Inventory (`scrapeworks/ebay-seller-listings`) Actor

Scrape ALL active listings of any eBay seller or eBay Store - titles, prices, condition, shipping, sold counts, watchers and images as clean JSON. No eBay API key needed. Many sellers per run, keyword/condition filters, deep pagination, any eBay marketplace.

- **URL**: https://apify.com/scrapeworks/ebay-seller-listings.md
- **Developed by:** [Nicolas van Arkens](https://apify.com/scrapeworks) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Seller Listings Scraper — All Items from Any eBay Store or Seller

Scrape **every active listing of any eBay seller or eBay Store** and get it as
clean, structured JSON — **no eBay API key, no developer account, no login
required.** Just enter seller usernames (or paste their profile / store URLs) and
the actor returns titles, prices, condition, shipping, sold counts, watchers and
image URLs for the seller's whole inventory, paginating deep automatically.

Built for **bulk**: pass a whole list of sellers in a single run, set how many
listings you want per seller (up to thousands), and optionally filter each
seller's items by keyword, condition, buying format or free shipping. Works on
**any eBay marketplace** (ebay.com, ebay.co.uk, ebay.de, ebay.com.au, ebay.ca and
more). Every row also carries the seller's **total live-listing count**, so one
cheap run tells you exactly how big each competitor's inventory is.

### What you can do with it

- **Competitor monitoring** — pull a rival seller's full catalog with prices; sort `newly_listed` and re-run daily to see exactly what they add.
- **Dropshipping & arbitrage sourcing** — harvest a supplier-style seller's inventory (titles, images, prices) to source or seed your own catalog.
- **Repricing** — feed your repricer the live prices of the sellers you compete with, item by item.
- **Store size & assortment intel** — `sellerListingsTotal` + condition/format mix across many sellers in one run.
- **Brand protection / MAP enforcement** — watch resellers of your brand with a `keywordFilter` and check every listed price.

### Input

| Field | Type | What it does |
|---|---|---|
| `sellers` | array of strings | Seller usernames (`medimops`) or URLs (`https://www.ebay.com/usr/...`, `/str/...`, or any search URL with `_ssn=`). Each seller is scraped separately. Add as many as you want. |
| `keywordFilter` | string | Optional. Only return the sellers' listings matching these keywords. |
| `domain` | string | eBay marketplace: `ebay.com`, `ebay.co.uk`, `ebay.de`, `ebay.com.au`, `ebay.ca`, `ebay.fr`, `ebay.it`, `ebay.es`, `ebay.nl`, `ebay.ie`, `ebay.in`. |
| `maxResultsPerSeller` | integer | Max listings to return per seller (default 200, up to 10000). Paginates 240 per page. |
| `sortBy` | string | `newly_listed` (default — perfect for monitoring), `best_match`, `ending_soonest`, `price_low`, `price_high`. |
| `conditionFilter` | string | `any`, `new`, `used`, `open_box`, `refurbished`. |
| `buyingFormat` | string | `any`, `buy_it_now`, `auction`. |
| `freeShippingOnly` | boolean | Only listings with free shipping. |
| `proxyConfiguration` | object | Proxy. **RESIDENTIAL Apify Proxy is strongly recommended** — eBay blocks datacenter IPs. |

#### Example input

```json
{
  "sellers": ["medimops", "https://www.ebay.com/usr/worldofbooks08"],
  "domain": "ebay.com",
  "maxResultsPerSeller": 500,
  "sortBy": "newly_listed",
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
````

### Output

One JSON object per listing (real sample from a live run):

```json
{
  "seller": "medimops",
  "sellerListingsTotal": 4400000,
  "listingId": "137188191598",
  "title": "Red Dead Redemption 2 [PlayStation 4] by Rockstar... | Game | Condition Very Good",
  "url": "https://www.ebay.com/itm/137188191598",
  "condition": "Pre-Owned",
  "subtitle": "Save money and shop sustainably!",
  "price": "110.13 SEK",
  "priceValue": 110.13,
  "priceMax": null,
  "currency": "SEK",
  "buyingFormat": "Buy It Now",
  "bids": null,
  "shipping": "+33.00 SEK shipping",
  "watchers": null,
  "sold": 90,
  "image": "https://i.ebayimg.com/images/g/ONIAAeSwxfNpzZ9w/s-l500.jpg",
  "domain": "ebay.com",
  "scrapedAt": "2026-07-17T19:42:40.130218+00:00"
}
```

| Field | Meaning |
|---|---|
| `seller` | The seller username this listing belongs to. |
| `sellerListingsTotal` | The seller's TOTAL number of live listings matching your filters (from the page heading). |
| `listingId` / `url` | eBay item ID and direct item URL. |
| `title`, `subtitle`, `condition` | Listing title, secondary line, item condition (works on non-English marketplaces too). |
| `price`, `priceValue`, `priceMax`, `currency` | Raw price text plus parsed numeric value(s). Price ranges fill `priceMax`. |
| `buyingFormat`, `bids` | Buy It Now / Best Offer / auction (with current bid count). |
| `shipping` | Shipping / delivery line as displayed. |
| `watchers`, `sold` | Demand signals when eBay displays them (watch count, units sold). |
| `image` | Main gallery image URL (i.ebayimg.com). |

Note on currency: eBay converts displayed prices to the currency of the IP that
loads the page. With the default RESIDENTIAL proxy this actor automatically pins
the proxy exit country to the marketplace's home country (US for ebay.com, DE for
ebay.de, ...), so prices come back in the site's own currency.

### FAQ

**Where do I find a seller's username?** On any of their item pages (seller info
box), or in their profile URL `ebay.com/usr/<username>`. You can also just paste
that URL — the actor extracts the username itself.

**Can it really get a seller's ENTIRE inventory?** It paginates 240 listings per
page as deep as eBay serves results (a few thousand per result set). For
mega-sellers with millions of items, use `keywordFilter`, `conditionFilter` or a
price sort to target the slice you need — `sellerListingsTotal` still reports the
full count either way.

**Does it work for private sellers, not just stores?** Yes — anything with a
username: eBay Stores, business sellers and private sellers alike.

**Do I need an eBay API key?** No. The actor reads eBay's public, server-rendered
pages. No login, no OAuth, no developer account.

**How am I charged?** Pay per event: you pay a small fee **per listing returned**.
Blocked pages, empty pages and failed sellers are never charged.

**Why residential proxy?** eBay blocks datacenter IPs. The default configuration
(Apify RESIDENTIAL proxy) is the reliable path; the actor also rotates proxy
sessions automatically when it detects a block page.

***

Sibling actors from the same family: **eBay Search Scraper** (keyword search
results), **eBay Listing Details** (full item pages by ID/URL), **eBay Sold Price
Analytics** (sold/completed listings).

# Actor input Schema

## `sellers` (type: `array`):

One or more eBay sellers to scrape. Accepts the bare username (e.g. 'medimops'), a profile URL (https://www.ebay.com/usr/medimops), a store URL (https://www.ebay.com/str/medimops) or any eBay search URL containing \_ssn=. Each seller's FULL inventory is paginated deep, up to 'Max listings per seller'. Add as many sellers as you like in a single run.

## `keywordFilter` (type: `string`):

Only return the seller's listings matching these keywords (e.g. 'nintendo switch'). Leave empty to get the seller's entire inventory.

## `domain` (type: `string`):

Which eBay site to read. Prices are returned in that site's local currency. Sellers are global: a German seller's items are visible on ebay.com too, but their home marketplace usually lists the most items.

## `maxResultsPerSeller` (type: `integer`):

Maximum listings to return for EACH seller. The actor paginates automatically (240 listings per page). eBay itself caps a single result set at a few thousand listings — for mega-sellers combine with 'Keyword filter' or sort to target the slice you need.

## `sortBy` (type: `string`):

Result order, same as eBay's own sort dropdown. 'Time: newly listed' is ideal for monitoring what a competitor added since your last run.

## `conditionFilter` (type: `string`):

Only return listings of this condition. 'Any' returns everything.

## `buyingFormat` (type: `string`):

Restrict to a buying format. 'Any' returns both fixed-price and auction listings.

## `freeShippingOnly` (type: `boolean`):

If on, only return listings that offer free shipping.

## `proxyConfiguration` (type: `object`):

Proxy used to reach eBay. eBay blocks datacenter traffic, so RESIDENTIAL Apify Proxy is strongly recommended for reliable results. With RESIDENTIAL, the proxy country is automatically matched to the chosen marketplace (US for ebay.com etc.) so prices come back in the site's local currency — pick a country yourself to override.

## Actor input object example

```json
{
  "sellers": [
    "medimops",
    "worldofbooks08"
  ],
  "domain": "ebay.com",
  "maxResultsPerSeller": 200,
  "sortBy": "newly_listed",
  "conditionFilter": "any",
  "buyingFormat": "any",
  "freeShippingOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "sellers": [
        "medimops",
        "worldofbooks08"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeworks/ebay-seller-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "sellers": [
        "medimops",
        "worldofbooks08",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapeworks/ebay-seller-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 '{
  "sellers": [
    "medimops",
    "worldofbooks08"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapeworks/ebay-seller-listings --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "eBay Seller Listings Scraper - Any Store's Full Inventory",
        "description": "Scrape ALL active listings of any eBay seller or eBay Store - titles, prices, condition, shipping, sold counts, watchers and images as clean JSON. No eBay API key needed. Many sellers per run, keyword/condition filters, deep pagination, any eBay marketplace.",
        "version": "0.1",
        "x-build-id": "wGTBkdreZXqvpFdaV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeworks~ebay-seller-listings/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeworks-ebay-seller-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/scrapeworks~ebay-seller-listings/runs": {
            "post": {
                "operationId": "runs-sync-scrapeworks-ebay-seller-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/scrapeworks~ebay-seller-listings/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeworks-ebay-seller-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",
                "required": [
                    "sellers"
                ],
                "properties": {
                    "sellers": {
                        "title": "Seller usernames or URLs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "One or more eBay sellers to scrape. Accepts the bare username (e.g. 'medimops'), a profile URL (https://www.ebay.com/usr/medimops), a store URL (https://www.ebay.com/str/medimops) or any eBay search URL containing _ssn=. Each seller's FULL inventory is paginated deep, up to 'Max listings per seller'. Add as many sellers as you like in a single run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywordFilter": {
                        "title": "Keyword filter (optional)",
                        "type": "string",
                        "description": "Only return the seller's listings matching these keywords (e.g. 'nintendo switch'). Leave empty to get the seller's entire inventory."
                    },
                    "domain": {
                        "title": "eBay marketplace",
                        "enum": [
                            "ebay.com",
                            "ebay.co.uk",
                            "ebay.de",
                            "ebay.com.au",
                            "ebay.ca",
                            "ebay.fr",
                            "ebay.it",
                            "ebay.es",
                            "ebay.nl",
                            "ebay.ie",
                            "ebay.in"
                        ],
                        "type": "string",
                        "description": "Which eBay site to read. Prices are returned in that site's local currency. Sellers are global: a German seller's items are visible on ebay.com too, but their home marketplace usually lists the most items.",
                        "default": "ebay.com"
                    },
                    "maxResultsPerSeller": {
                        "title": "Max listings per seller",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum listings to return for EACH seller. The actor paginates automatically (240 listings per page). eBay itself caps a single result set at a few thousand listings — for mega-sellers combine with 'Keyword filter' or sort to target the slice you need.",
                        "default": 200
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "best_match",
                            "ending_soonest",
                            "newly_listed",
                            "price_low",
                            "price_high"
                        ],
                        "type": "string",
                        "description": "Result order, same as eBay's own sort dropdown. 'Time: newly listed' is ideal for monitoring what a competitor added since your last run.",
                        "default": "newly_listed"
                    },
                    "conditionFilter": {
                        "title": "Item condition",
                        "enum": [
                            "any",
                            "new",
                            "used",
                            "open_box",
                            "refurbished"
                        ],
                        "type": "string",
                        "description": "Only return listings of this condition. 'Any' returns everything.",
                        "default": "any"
                    },
                    "buyingFormat": {
                        "title": "Buying format",
                        "enum": [
                            "any",
                            "buy_it_now",
                            "auction"
                        ],
                        "type": "string",
                        "description": "Restrict to a buying format. 'Any' returns both fixed-price and auction listings.",
                        "default": "any"
                    },
                    "freeShippingOnly": {
                        "title": "Free shipping only",
                        "type": "boolean",
                        "description": "If on, only return listings that offer free shipping.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used to reach eBay. eBay blocks datacenter traffic, so RESIDENTIAL Apify Proxy is strongly recommended for reliable results. With RESIDENTIAL, the proxy country is automatically matched to the chosen marketplace (US for ebay.com etc.) so prices come back in the site's local currency — pick a country yourself to override.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
