# eBay Seller Scraper (`automation-lab/ebay-seller-scraper`) Actor

Extract public eBay seller listings, prices, item URLs, images, conditions, and feedback snippets for marketplace competitor research.

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

## Pricing

from $1.22 / 1,000 dataset items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## eBay Seller Scraper

Extract public eBay seller inventory into clean rows for competitor monitoring, price tracking, product research, and marketplace analytics.

### What does eBay Seller Scraper do?

The actor opens public eBay seller listing pages and saves active listing cards.
It accepts seller usernames such as `best_buy` or direct eBay seller URLs.
Each output row represents one listing.
Rows include title, item URL, item ID, price, condition, image, seller feedback snippets, rank, and source URL.
The actor is designed for public marketplace intelligence, not private account scraping.

### Who is it for?

- Ecommerce sellers benchmarking competitors.
- Agencies monitoring client categories.
- Marketplace analysts building price snapshots.
- Dropshipping teams checking seller inventory movement.
- Brands watching unauthorized or competing sellers.
- Data teams exporting public eBay seller listings to BI tools.

### Why use it?

Manual seller-page checks are slow and hard to repeat.
This actor turns seller inventory pages into structured JSON, CSV, Excel, or API output.
You can run the same seller list repeatedly and compare prices, products, and listing counts over time.

### What data can you extract?

| Field | Description |
| --- | --- |
| sellerUsername | eBay seller inferred from the URL or input username |
| listingTitle | Listing title shown on the seller inventory page |
| itemUrl | Canonical eBay item URL |
| itemId | Numeric eBay item ID when available |
| price | Price text displayed by eBay |
| priceValue | Parsed first numeric price value |
| currency | Parsed currency code when obvious |
| shipping | Shipping snippet when shown |
| condition | New, used, open box, refurbished, or similar condition |
| imageUrl | Listing thumbnail URL |
| sellerFeedbackPercent | Positive feedback percentage snippet |
| rank | Position in the scraped result set |

### How much does it cost to scrape eBay seller listings?

The actor uses pay-per-event pricing.
A small run has a start event and a per-listing event.
For cheap tests, keep `maxItems` low.
For monitoring, run batches of sellers on a schedule and export only the fields you need.
Final tiered pricing is calculated from cloud validation costs before QA handoff.

### How to use

1. Open the actor on Apify.
2. Add one or more eBay seller usernames.
3. Optionally add direct seller listing URLs.
4. Set `maxItems` to control spend.
5. Keep Residential proxy enabled unless you know your target pages work with another proxy group.
6. Start the run.
7. Download results as JSON, CSV, Excel, XML, or RSS.

### Input options

#### sellerUsernames

Use seller usernames without the eBay domain.
Example: `best_buy`.
The actor opens `https://www.ebay.com/sch/best_buy/m.html`.

#### startUrls

Use this when you already have seller listing URLs.
Supported examples include `/sch/{seller}/m.html`, `/usr/{seller}`, `/str/{store}`, and search URLs with `_ssn`.

#### maxItems

Controls the total number of listing rows saved across all sellers.
Use a low number for the first run.

#### maxItemsPerSeller

Controls per-seller depth before the actor moves to the next seller.

#### proxyGroups

The default is `RESIDENTIAL` because eBay frequently blocks datacenter sessions.

#### requestDelayMs

Extra wait time after page load.
eBay can show a browser-check page before rendering seller inventory.

### Example input

```json
{
  "sellerUsernames": ["best_buy"],
  "maxItems": 25,
  "maxItemsPerSeller": 25,
  "countryCode": "US",
  "proxyGroups": ["RESIDENTIAL"],
  "requestDelayMs": 2500,
  "includeSponsored": true
}
````

### Example output

```json
{
  "sellerUsername": "best_buy",
  "listingTitle": "Acer - Aspire Go 15 15.6\" FHD Laptop...",
  "itemUrl": "https://www.ebay.com/itm/198044095345",
  "itemId": "198044095345",
  "price": "$699.99",
  "priceValue": 699.99,
  "currency": "USD",
  "condition": "Brand New",
  "sellerFeedbackPercent": "98.8%",
  "rank": 1
}
```

### Tips for reliable scraping

- Start with one seller and 10-25 listings.
- Prefer seller listing pages over generic search pages.
- Keep concurrency low; this actor intentionally uses sequential browsing.
- Use US proxy country for ebay.com pages.
- If a seller has no public active listings, the actor may save no rows for that seller.
- Increase `requestDelayMs` if eBay browser checks are slow.

### Integrations

Use the dataset API to feed dashboards, Google Sheets, BigQuery, or internal price-monitoring pipelines.
Schedule the actor daily or weekly to track seller inventory changes.
Trigger alerts when competitor prices drop below your floor price.
Join item IDs with your product catalog to identify overlaps.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ebay-seller-scraper').call({
  sellerUsernames: ['best_buy'],
  maxItems: 25
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/ebay-seller-scraper').call(run_input={
    'sellerUsernames': ['best_buy'],
    'maxItems': 25,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~ebay-seller-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"sellerUsernames":["best_buy"],"maxItems":25}'
```

### MCP usage

Use the Apify MCP server with `?tools=automation-lab/ebay-seller-scraper`.
Claude Code or Claude Desktop can run seller monitoring workflows from natural-language prompts.

Example prompts:

- "Scrape 25 public listings from eBay seller best\_buy and summarize the price range."
- "Monitor these eBay sellers weekly and flag products below $100."
- "Export seller inventory rows for my competitor research spreadsheet."

### Legal and ethical notes

This actor extracts public eBay listing data.
Do not use it for private account data, messages, orders, buyer information, or contact harvesting.
Respect eBay terms, robots guidance, and applicable laws.
Use reasonable limits and only collect data you have a lawful basis to process.

### Troubleshooting

#### Why did my run return no items?

The seller may have no active public listings, the URL may not point to seller inventory, or eBay may have challenged the session.
Try a known seller listing URL and increase `requestDelayMs`.

#### Why is Residential proxy the default?

Workspace HTTP and datacenter sessions can receive eBay error pages.
Residential proxy sessions are more reliable for public seller listing pages.

#### Why are sponsored rows included?

Some eBay seller pages label cards inconsistently.
The actor keeps sponsored/promoted cards by default so users do not miss visible inventory rows.
Turn off `includeSponsored` if you only want unsponsored cards.

### Related scrapers

- https://apify.com/automation-lab/amazon-product-scraper
- https://apify.com/automation-lab/walmart-product-scraper
- https://apify.com/automation-lab/shopify-product-scraper
- https://apify.com/automation-lab/google-shopping-scraper

### Changelog

Initial version extracts public seller listing cards from eBay seller inventory pages.

### Data quality notes

Price parsing keeps both raw price text and numeric first price value.
Range prices may expose only the first numeric value in `priceValue`.
Use the raw `price` field for exact display text.

### Monitoring workflow

Run the actor with the same seller list on a schedule.
Export item IDs and prices to your database.
Compare each run with the previous run.
Flag new listings, removed listings, and price changes.

### Inventory research workflow

Collect all active listings for one seller.
Group rows by condition and price bands.
Use item URLs for manual review or enrichment.
Combine images and titles for catalog matching.

### Agency workflow

Create one task per client category.
Use seller usernames supplied by your analyst.
Send CSV exports to account managers.
Archive historical datasets for monthly reports.

### Limitations

The actor depends on public eBay page rendering.
Page layout and anti-bot behavior can change.
Direct seller profiles may redirect; seller listing pages are preferred.
Feedback fields are snippets from public seller page chrome, not full feedback-history reviews.

### Support

If a run fails, include the run ID, seller username, input JSON, and whether the seller page opens in your browser.
This helps reproduce anti-bot or page-layout issues quickly.

# Actor input Schema

## `sellerUsernames` (type: `array`):

eBay seller usernames. The actor opens https://www.ebay.com/sch/{seller}/m.html for each seller.

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

Optional eBay seller listing URLs, store URLs, profile URLs, or search URLs that include \_ssn.

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

Maximum number of listing records to save across all sellers.

## `maxItemsPerSeller` (type: `integer`):

Upper limit per seller/source URL before moving to the next seller.

## `countryCode` (type: `string`):

Country code for Apify Proxy sessions. US works best for ebay.com.

## `proxyGroups` (type: `array`):

Apify Proxy groups. Residential is the default because eBay blocks datacenter sessions frequently.

## `requestDelayMs` (type: `integer`):

Extra wait time for eBay browser checks and listing rendering.

## `includeSponsored` (type: `boolean`):

Keep sponsored/promoted cards when eBay mixes them into seller inventory pages. Enabled by default because eBay may label seller inventory placements inconsistently.

## Actor input object example

```json
{
  "sellerUsernames": [
    "best_buy"
  ],
  "startUrls": [
    {
      "url": "https://www.ebay.com/sch/best_buy/m.html?_ipg=25"
    }
  ],
  "maxItems": 25,
  "maxItemsPerSeller": 25,
  "countryCode": "US",
  "proxyGroups": [
    "RESIDENTIAL"
  ],
  "requestDelayMs": 2500,
  "includeSponsored": true
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "sellerUsernames": [
        "best_buy"
    ],
    "startUrls": [
        {
            "url": "https://www.ebay.com/sch/best_buy/m.html?_ipg=25"
        }
    ],
    "maxItems": 25,
    "maxItemsPerSeller": 25,
    "countryCode": "US",
    "proxyGroups": [
        "RESIDENTIAL"
    ],
    "requestDelayMs": 2500,
    "includeSponsored": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ebay-seller-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 = {
    "sellerUsernames": ["best_buy"],
    "startUrls": [{ "url": "https://www.ebay.com/sch/best_buy/m.html?_ipg=25" }],
    "maxItems": 25,
    "maxItemsPerSeller": 25,
    "countryCode": "US",
    "proxyGroups": ["RESIDENTIAL"],
    "requestDelayMs": 2500,
    "includeSponsored": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ebay-seller-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 '{
  "sellerUsernames": [
    "best_buy"
  ],
  "startUrls": [
    {
      "url": "https://www.ebay.com/sch/best_buy/m.html?_ipg=25"
    }
  ],
  "maxItems": 25,
  "maxItemsPerSeller": 25,
  "countryCode": "US",
  "proxyGroups": [
    "RESIDENTIAL"
  ],
  "requestDelayMs": 2500,
  "includeSponsored": true
}' |
apify call automation-lab/ebay-seller-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "eBay Seller Scraper",
        "description": "Extract public eBay seller listings, prices, item URLs, images, conditions, and feedback snippets for marketplace competitor research.",
        "version": "0.1",
        "x-build-id": "cj7WsMYGE7ch6tmu4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~ebay-seller-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-ebay-seller-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~ebay-seller-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-ebay-seller-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~ebay-seller-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-ebay-seller-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": {
                    "sellerUsernames": {
                        "title": "Seller usernames",
                        "type": "array",
                        "description": "eBay seller usernames. The actor opens https://www.ebay.com/sch/{seller}/m.html for each seller.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Seller listing or store URLs",
                        "type": "array",
                        "description": "Optional eBay seller listing URLs, store URLs, profile URLs, or search URLs that include _ssn.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings total",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of listing records to save across all sellers.",
                        "default": 50
                    },
                    "maxItemsPerSeller": {
                        "title": "Maximum listings per seller",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Upper limit per seller/source URL before moving to the next seller.",
                        "default": 250
                    },
                    "countryCode": {
                        "title": "Proxy country",
                        "type": "string",
                        "description": "Country code for Apify Proxy sessions. US works best for ebay.com.",
                        "default": "US"
                    },
                    "proxyGroups": {
                        "title": "Proxy groups",
                        "type": "array",
                        "description": "Apify Proxy groups. Residential is the default because eBay blocks datacenter sessions frequently.",
                        "default": [
                            "RESIDENTIAL"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "requestDelayMs": {
                        "title": "Delay after page load (ms)",
                        "minimum": 0,
                        "maximum": 30000,
                        "type": "integer",
                        "description": "Extra wait time for eBay browser checks and listing rendering.",
                        "default": 2500
                    },
                    "includeSponsored": {
                        "title": "Include sponsored placements",
                        "type": "boolean",
                        "description": "Keep sponsored/promoted cards when eBay mixes them into seller inventory pages. Enabled by default because eBay may label seller inventory placements inconsistently.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```