# JD.com Product Scraper (`automation-lab/jd-com-product-scraper`) Actor

Extract JD.com product details, prices, images, shops, categories, availability, and review signals from public item URLs or SKU IDs.

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

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## JD.com Product Scraper

Extract public JD.com product data from item URLs or SKU IDs.

The actor is built for ecommerce sourcing, retail intelligence, and competitor price-monitoring teams that need repeatable product snapshots from JD.com without manually opening every product page.

It focuses on stable JD.com detail pages first. Search pages can redirect or throttle, so keyword discovery is intentionally not part of the default MVP.

### What does JD.com Product Scraper do?

JD.com Product Scraper loads public product detail pages such as `https://item.jd.com/100012043978.html`.

It saves one dataset row per product.

Each row can include title, SKU, canonical URL, brand/shop IDs, shop name, category breadcrumbs, images, current public price when available, review summary signals when available, and scrape timestamp.

### Who is it for?

- 🛒 Ecommerce sourcing teams comparing products across China retail channels.
- 📊 Competitor price-monitoring analysts tracking JD.com SKU changes.
- 🧾 Catalog operations teams enriching internal SKU lists with public JD.com metadata.
- 🧪 Data teams building scheduled product availability checks.
- 🤖 Automation teams feeding dashboards, alerts, and BI warehouses.

### Why use this actor?

- It accepts both product URLs and numeric SKU IDs.
- It normalizes SKU IDs into JD.com item URLs automatically.
- It uses HTTP extraction for low overhead instead of a browser-heavy workflow.
- It stores structured fields ready for CSV, JSON, Excel, API, or database export.
- It keeps the first-run input small and inexpensive.

### What data can I extract?

| Field | Description |
| --- | --- |
| `sku` | JD.com numeric product SKU. |
| `url` | Product detail URL used for extraction. |
| `title` | Clean product title from the item page. |
| `shortTitle` | Browser/page title. |
| `brandId` | Brand identifier when exposed in page scripts. |
| `brandName` | Brand name when exposed. |
| `shopId` | JD.com shop ID when exposed. |
| `vendorId` | Vendor identifier when exposed. |
| `shopName` | Shop or seller name visible on the page. |
| `categoryIds` | JD.com category identifiers from page scripts. |
| `categoryNames` | Category names from breadcrumbs. |
| `price` | Public price when the JD.com endpoint or page exposes it. |
| `listPrice` | List/reference price when exposed. |
| `currency` | Currency code, currently `CNY`. |
| `imageUrls` | Product and page image URLs. |
| `mainImageUrl` | First product image URL. |
| `commentCount` | Review/comment count when public summary endpoint responds. |
| `goodRate` | Positive rating ratio when exposed. |
| `averageScore` | Average review score when exposed. |
| `productStatus` | Availability/status hint such as `listed`. |
| `metaDescription` | Page meta description. |
| `breadcrumbs` | JD.com breadcrumb labels. |
| `rawApi` | Optional raw public price/comment API snippets. |
| `scrapedAt` | ISO timestamp for the extraction. |

### How much does it cost to scrape JD.com products?

This actor uses pay-per-event pricing.

You pay a small start fee per run and a per-product fee for each saved product row.

Keep test runs small while validating your SKU list.

For scheduled monitoring, batch products into sensible groups so every run produces useful output.

### How to use it

1. Open the actor on Apify.
2. Paste one or more JD.com item URLs into **JD.com product URLs**.
3. Or paste numeric SKU IDs into **JD.com SKU IDs**.
4. Set **Maximum products** to a safe limit.
5. Leave **Fetch price and review APIs** enabled if you want optional enrichment.
6. Run the actor.
7. Export the dataset as JSON, CSV, Excel, or via API.

### Input options

#### JD.com product URLs

Use public product item pages.

Example:

```json
[
  { "url": "https://item.jd.com/100012043978.html" }
]
````

#### JD.com SKU IDs

Use numeric JD.com SKU IDs.

Example:

```json
["100012043978"]
```

The actor converts that SKU to:

```text
https://item.jd.com/100012043978.html
```

#### Maximum products

Use this field to cap output volume.

The prefill is intentionally low so the first run is cheap.

#### Fetch price and review APIs

When enabled, the actor attempts public JD.com price and review summary endpoints.

If those endpoints timeout, redirect, or block, the actor still saves the product page fields.

### Output example

```json
{
  "sku": "100012043978",
  "url": "https://item.jd.com/100012043978.html",
  "title": "茅台飞天 53%vol 500ml 贵州茅台酒（带杯）",
  "shopName": "贵州茅台",
  "categoryNames": ["酒类", "白酒", "茅台（MOUTAI）"],
  "price": null,
  "currency": "CNY",
  "mainImageUrl": "https://img13.360buyimg.com/n1/...jpg",
  "productStatus": "listed",
  "scrapedAt": "2026-06-20T22:00:00.000Z"
}
```

### Tips for reliable runs

- Use exact JD.com item URLs or SKU IDs.
- Avoid keyword search URLs for now; detail pages are the supported path.
- Start with 1-5 products, then scale after reviewing output quality.
- Keep scheduled runs focused on products you actually monitor.
- If a product disappears from JD.com, the actor may skip it or mark it unavailable.

### Integrations

Use this actor in repeatable ecommerce workflows.

- Send dataset rows to Google Sheets for daily price checks.
- Push JSON output into a warehouse for SKU-level trend analysis.
- Trigger alerts when a product status or price changes.
- Combine JD.com rows with other marketplace scrapers in a catalog monitor.
- Feed product images and titles into enrichment or matching pipelines.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/jd-com-product-scraper').call({
  skus: ['100012043978'],
  maxItems: 1,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/jd-com-product-scraper').call(run_input={
    'skus': ['100012043978'],
    'maxItems': 1,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~jd-com-product-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"skus":["100012043978"],"maxItems":1}'
```

### MCP usage

Use the Apify MCP server with Claude Code or Claude Desktop to run this actor from your AI workflow.

MCP endpoint:

```text
https://mcp.apify.com/?tools=automation-lab/jd-com-product-scraper
```

Claude Code setup:

```bash
claude mcp add apify-jd-com-product-scraper https://mcp.apify.com/?tools=automation-lab/jd-com-product-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-jd-com-product-scraper": {
      "url": "https://mcp.apify.com/?tools=automation-lab/jd-com-product-scraper"
    }
  }
}
```

Example prompts:

- "Run the JD.com Product Scraper for SKU 100012043978 and summarize the catalog fields."
- "Monitor these JD.com product URLs and tell me which rows have missing prices."
- "Export the latest JD.com scraper dataset as CSV."

### Scheduling

For monitoring, schedule the actor daily or weekly.

Use a stable SKU list.

Export each run to your dashboard or warehouse.

Compare rows by `sku` and `scrapedAt`.

### Limitations

- The actor supports public product detail pages.
- Keyword search pages are not the default workflow.
- Member-only, cart-only, coupon, login-only, or personalized prices are excluded.
- Some price/review endpoints may occasionally fail; page-level extraction still continues.
- JD.com can change page markup, so monitor critical production workflows.

### FAQ and troubleshooting

#### Why is price empty?

JD.com may not expose a public price for that SKU in the current region or request context, or the optional price endpoint may be temporarily unavailable.

The actor still saves page fields so you can see the product identity and status.

#### Why was my URL skipped?

The actor needs a JD.com SKU in the URL or input.

Use a URL like `https://item.jd.com/100012043978.html` or provide `100012043978` in `skus`.

#### Why not support keyword search?

Search pages may redirect or behave differently from product detail pages.

The MVP prioritizes reliable URL/SKU monitoring.

### Legality

This actor extracts publicly available product information from JD.com pages.

You are responsible for using the data lawfully and respecting JD.com terms, robots policies, applicable laws, and privacy requirements.

Do not scrape private account data, checkout data, or login-only content.

### Related scrapers

You may also need marketplace and ecommerce actors from Automation Lab.

- https://apify.com/automation-lab/amazon-product-scraper
- https://apify.com/automation-lab/google-shopping-scraper
- https://apify.com/automation-lab/competitor-price-monitor

### Changelog

#### 0.1

Initial URL/SKU-based JD.com product detail scraper.

### Support

If a public JD.com product page fails, include the URL, SKU, run ID, and whether optional API details were enabled.

# Actor input Schema

## `productUrls` (type: `array`):

Public JD.com item detail pages such as https://item.jd.com/100012043978.html.

## `skus` (type: `array`):

Optional JD.com numeric SKU IDs. Each SKU is normalized to https://item.jd.com/{sku}.html.

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

Maximum number of product records to save in this run. Keep low for test runs.

## `includeApiDetails` (type: `boolean`):

Call public JD.com endpoints for current price and comment summary data when available.

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

Cloud runs use Apify Residential Proxy routed through Japan by default because JD.com often redirects generic datacenter/residential requests to a verification page. Keep the default unless you know your own route works.

## Actor input object example

```json
{
  "productUrls": [
    {
      "url": "https://item.jd.com/100012043978.html"
    }
  ],
  "skus": [
    "100012043978"
  ],
  "maxItems": 3,
  "includeApiDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "JP"
  }
}
```

# 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 = {
    "productUrls": [
        {
            "url": "https://item.jd.com/100012043978.html"
        }
    ],
    "skus": [
        "100012043978"
    ],
    "maxItems": 3,
    "includeApiDetails": false,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "JP"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/jd-com-product-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 = {
    "productUrls": [{ "url": "https://item.jd.com/100012043978.html" }],
    "skus": ["100012043978"],
    "maxItems": 3,
    "includeApiDetails": False,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "JP",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/jd-com-product-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 '{
  "productUrls": [
    {
      "url": "https://item.jd.com/100012043978.html"
    }
  ],
  "skus": [
    "100012043978"
  ],
  "maxItems": 3,
  "includeApiDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "JP"
  }
}' |
apify call automation-lab/jd-com-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "JD.com Product Scraper",
        "description": "Extract JD.com product details, prices, images, shops, categories, availability, and review signals from public item URLs or SKU IDs.",
        "version": "0.1",
        "x-build-id": "e8D8zSq6sztwPrYmA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~jd-com-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-jd-com-product-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~jd-com-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-jd-com-product-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~jd-com-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-jd-com-product-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": {
                    "productUrls": {
                        "title": "JD.com product URLs",
                        "type": "array",
                        "description": "Public JD.com item detail pages such as https://item.jd.com/100012043978.html.",
                        "default": [
                            {
                                "url": "https://item.jd.com/100012043978.html"
                            }
                        ],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "skus": {
                        "title": "JD.com SKU IDs",
                        "type": "array",
                        "description": "Optional JD.com numeric SKU IDs. Each SKU is normalized to https://item.jd.com/{sku}.html.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum products",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of product records to save in this run. Keep low for test runs.",
                        "default": 10
                    },
                    "includeApiDetails": {
                        "title": "Fetch price and review APIs",
                        "type": "boolean",
                        "description": "Call public JD.com endpoints for current price and comment summary data when available.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Cloud runs use Apify Residential Proxy routed through Japan by default because JD.com often redirects generic datacenter/residential requests to a verification page. Keep the default unless you know your own route works.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "JP"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```