# Flipkart Reviews Scraper (`khadinakbar/flipkart-reviews-scraper`) Actor

Scrape Flipkart product reviews by product or product-reviews URL. Returns rating, title, text, reviewer name & location, verified-purchase flag, date, helpful/unhelpful votes, review images, and the product rating summary. PPE — $0.004 per review.

- **URL**: https://apify.com/khadinakbar/flipkart-reviews-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, MCP servers, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 review scrapeds

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Flipkart Reviews Scraper

Scrape **Flipkart product reviews** at scale by pasting a Flipkart product URL or product-reviews URL. Returns one clean record per review — star rating, title, full review text, reviewer name and location, verified-purchase flag, date, helpful/unhelpful votes, the reviewed variant, and any review images — plus a per-product rating summary. Built for AI agents (MCP-ready) and analysts alike.

### What you get

| Field | Description |
|-------|-------------|
| `rating` | Star rating 1–5 for the review |
| `title` | Flipkart review title / sentiment tag (e.g. "Value-for-money") |
| `body` | Full review text, expanded past the "READ MORE" / "more" toggle |
| `author` | Reviewer name |
| `location` | Reviewer city/region (when shown) |
| `isVerifiedPurchase` | `true` when marked "Certified Buyer" / "Verified Purchase" |
| `reviewDate` | Displayed date — absolute (`Aug, 2024`) or relative (`11 months ago`) |
| `helpfulCount` / `unhelpfulCount` | Up / down votes |
| `variant` | The variant the review is for (e.g. "Color Blue, Storage 128 GB") |
| `images` | Flipkart CDN image URLs attached to the review |
| `productUrl` / `reviewsUrl` | Source links |
| `scrapedAt` | ISO-8601 capture timestamp |

Plus, per product, one `recordType: "product_summary"` row with `totalRatings`, `totalReviews`, `averageRating`, and the 5→1 star `ratingDistribution`.

### When to use it

- Mine sentiment and feature feedback on your own or competitors' Flipkart listings
- Track ratings, verified-buyer share, and review velocity over time
- Pull review corpora for LLM summarization, topic modelling, or QA
- Feed an AI agent that needs structured Flipkart review data from a single product link

**Not** a search or category scraper — give it specific product links (each must contain an `itm...` id and a `pid=` parameter).

### Pricing

Pay-per-event:

- **Actor start** — $0.00005 per run
- **Review scraped** — **$0.004 per review** written to the dataset (the product summary record is free)

A run of 1 product × 100 reviews costs about **$0.40**. Use `maxReviews` to cap spend per product; the actor logs the maximum possible cost before charging anything.

### Input

```json
{
  "productUrls": [
    "https://www.flipkart.com/apple-iphone-15-black-128-gb/p/itm6ac6485515ae4?pid=MOBGTAGPAQNVFZZY"
  ],
  "maxReviews": 100,
  "sortBy": "MOST_HELPFUL",
  "includeProductSummary": true
}
````

| Input | Default | Notes |
|-------|---------|-------|
| `productUrls` | — (required) | Product or product-reviews URLs. Each needs `itm...` + `pid=`. |
| `maxReviews` | 100 | Per-product cap, 1–1000. 10 reviews per page. |
| `sortBy` | `MOST_HELPFUL` | Also `MOST_RECENT`, `POSITIVE_FIRST`, `NEGATIVE_FIRST`. |
| `includeProductSummary` | `true` | Emit the per-product rating summary record. |
| `proxyConfiguration` | Residential, India | Flipkart needs clean residential India IPs. |
| `maxConcurrency` | 3 | Lower to 1–2 if you see blocks. |

### Output sample

```json
{
  "recordType": "review",
  "productKey": "MOBGTAGPAQNVFZZY",
  "rating": 5,
  "title": "Mind-blowing purchase",
  "body": "Fully satisfied using iphone 15. Camera and battery are excellent.",
  "author": "subhabrata paul",
  "location": "Teliamura",
  "isVerifiedPurchase": true,
  "reviewDate": "Oct, 2024",
  "helpfulCount": 438,
  "unhelpfulCount": 83,
  "variant": "Color Black, Storage 128 GB",
  "images": ["https://rukminim2.flixcart.com/.../blobio-imr_...jpeg?q=90"],
  "scrapedAt": "2026-06-21T00:00:00.000Z"
}
```

### How it works

Flipkart protects its pages with reCAPTCHA Enterprise and serves two different review front-ends (a classic web build and a newer React-Native-Web build), both using rotating, obfuscated CSS class names. This actor uses a **real browser** (Chromium with fingerprinting) over **residential India IPs**, and a layout-agnostic extractor that anchors on the stable buyer-label text and reads fields by position — so it keeps working across Flipkart's front-end A/B variants and class-name churn. Reviews are paginated via `&page=N`, de-duplicated across pages, and truncated bodies are expanded before extraction. Image/media/font bytes are blocked to keep proxy bandwidth (and your cost) low while preserving image URLs.

If every page is blocked, the run fails honestly with an actionable message rather than silently returning an empty dataset.

### Tips & limits

- **Proxy:** datacenter IPs do not work on Flipkart. Keep the default Apify Residential / country `IN`, or supply your own residential/mobile proxy.
- **Review dates** are returned exactly as Flipkart displays them (absolute or relative); convert downstream if you need a normalized timestamp.
- **Region:** Flipkart serves India. Prices/availability shown reflect the India store.

### FAQ

**Can I pass a search results URL?** No — pass individual product or product-reviews URLs. Use Flipkart search yourself, then feed the product links here.

**Does it need login or cookies?** No. Reviews are public; no credentials required.

**How many reviews can I get?** Up to `maxReviews` per product (max 1000). Flipkart paginates 10 per page.

**Why might a run return fewer reviews than the product shows?** Flipkart caps how deep its public review pagination goes, and de-duplication removes repeats across pages.

### Legal

This actor scrapes only publicly available review content. You are responsible for using the data in compliance with Flipkart's Terms of Use, applicable laws (including data-protection and copyright law), and for not using personal data (reviewer names/locations) in violation of privacy regulations. This actor is not affiliated with or endorsed by Flipkart.

# Actor input Schema

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

Use this for the product(s) whose reviews you want. Paste full Flipkart product URLs (https://www.flipkart.com/<slug>/p/itm...?pid=...) or product-reviews URLs (.../product-reviews/itm...?pid=...). Each URL must contain an 'itm...' id and a 'pid=' parameter — that is all the scraper needs. NOT a search query or category URL; this scraper takes specific product links only.

## `maxReviews` (type: `integer`):

Maximum number of reviews to scrape per product URL (10 reviews per page are paginated automatically). Defaults to 100; range 1-1000. Lower it to cut cost and runtime. This is a per-product cap, not a total across all URLs.

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

Order in which Flipkart serves the reviews before paging. 'MOST\_HELPFUL' (default) surfaces the highest-voted reviews; 'MOST\_RECENT' the newest; 'POSITIVE\_FIRST' / 'NEGATIVE\_FIRST' bias by rating. This controls ordering only, not which reviews exist.

## `includeProductSummary` (type: `boolean`):

When enabled (default), emit one extra 'product\_summary' record per product with total ratings, total reviews, average rating, and the 5-to-1 star distribution. Disable to get only individual review records. Does not affect per-review billing.

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

Apify proxy settings. Flipkart needs clean residential India IPs — datacenter IPs hit reCAPTCHA. By default the Actor uses Apify Residential (India) as the primary proxy and automatically falls back to a built-in residential India proxy if Apify Residential is unavailable or blocked, so it works out of the box. To force a specific Apify proxy, set the group and country here and it will be used as-is.

## `customProxyUrls` (type: `array`):

Bring your own residential or mobile India proxy as full URLs (e.g. 'http://user:pass@host:port'). When set, these override every other proxy option. Use this if you have a dedicated India residential/mobile pool; NOT an Apify proxy group name. Leave empty to use the built-in residential India proxy.

## `maxConcurrency` (type: `integer`):

How many review pages to fetch in parallel. Defaults to 3; range 1-8. Lower it (1-2) if you see frequent blocks, raise it for faster large jobs at higher block risk. Advanced tuning — leave at default if unsure.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.flipkart.com/samsung-galaxy-m35-5g-thunder-grey-128-gb/p/itm24a2a82cf1782?pid=MOBH2Z9HJYYQBFGD"
  ],
  "maxReviews": 20,
  "sortBy": "MOST_HELPFUL",
  "includeProductSummary": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "customProxyUrls": [],
  "maxConcurrency": 3
}
```

# Actor output Schema

## `dataset` (type: `string`):

All scraped reviews (and one product\_summary per product when enabled). Download as JSON, CSV, Excel, HTML, or RSS.

## `runSummary` (type: `string`):

End-of-run JSON with counts, charges, blocked flag, and warning samples.

# 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": [
        "https://www.flipkart.com/apple-iphone-15-black-128-gb/product-reviews/itm6ac6485515ae4?pid=MOBGTAGPAQNVFZZY"
    ],
    "maxReviews": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/flipkart-reviews-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": ["https://www.flipkart.com/apple-iphone-15-black-128-gb/product-reviews/itm6ac6485515ae4?pid=MOBGTAGPAQNVFZZY"],
    "maxReviews": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/flipkart-reviews-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": [
    "https://www.flipkart.com/apple-iphone-15-black-128-gb/product-reviews/itm6ac6485515ae4?pid=MOBGTAGPAQNVFZZY"
  ],
  "maxReviews": 20
}' |
apify call khadinakbar/flipkart-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Flipkart Reviews Scraper",
        "description": "Scrape Flipkart product reviews by product or product-reviews URL. Returns rating, title, text, reviewer name & location, verified-purchase flag, date, helpful/unhelpful votes, review images, and the product rating summary. PPE — $0.004 per review.",
        "version": "0.1",
        "x-build-id": "RgBfM7ZafebIC10VH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~flipkart-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-flipkart-reviews-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/khadinakbar~flipkart-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-flipkart-reviews-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/khadinakbar~flipkart-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-flipkart-reviews-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",
                "required": [
                    "productUrls"
                ],
                "properties": {
                    "productUrls": {
                        "title": "Flipkart product or product-reviews URLs",
                        "type": "array",
                        "description": "Use this for the product(s) whose reviews you want. Paste full Flipkart product URLs (https://www.flipkart.com/<slug>/p/itm...?pid=...) or product-reviews URLs (.../product-reviews/itm...?pid=...). Each URL must contain an 'itm...' id and a 'pid=' parameter — that is all the scraper needs. NOT a search query or category URL; this scraper takes specific product links only.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Max reviews per product",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per product URL (10 reviews per page are paginated automatically). Defaults to 100; range 1-1000. Lower it to cut cost and runtime. This is a per-product cap, not a total across all URLs.",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort reviews by",
                        "enum": [
                            "MOST_HELPFUL",
                            "MOST_RECENT",
                            "POSITIVE_FIRST",
                            "NEGATIVE_FIRST"
                        ],
                        "type": "string",
                        "description": "Order in which Flipkart serves the reviews before paging. 'MOST_HELPFUL' (default) surfaces the highest-voted reviews; 'MOST_RECENT' the newest; 'POSITIVE_FIRST' / 'NEGATIVE_FIRST' bias by rating. This controls ordering only, not which reviews exist.",
                        "default": "MOST_HELPFUL"
                    },
                    "includeProductSummary": {
                        "title": "Include product rating summary",
                        "type": "boolean",
                        "description": "When enabled (default), emit one extra 'product_summary' record per product with total ratings, total reviews, average rating, and the 5-to-1 star distribution. Disable to get only individual review records. Does not affect per-review billing.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Flipkart needs clean residential India IPs — datacenter IPs hit reCAPTCHA. By default the Actor uses Apify Residential (India) as the primary proxy and automatically falls back to a built-in residential India proxy if Apify Residential is unavailable or blocked, so it works out of the box. To force a specific Apify proxy, set the group and country here and it will be used as-is.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "customProxyUrls": {
                        "title": "Custom proxy URLs (optional)",
                        "type": "array",
                        "description": "Bring your own residential or mobile India proxy as full URLs (e.g. 'http://user:pass@host:port'). When set, these override every other proxy option. Use this if you have a dedicated India residential/mobile pool; NOT an Apify proxy group name. Leave empty to use the built-in residential India proxy.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "How many review pages to fetch in parallel. Defaults to 3; range 1-8. Lower it (1-2) if you see frequent blocks, raise it for faster large jobs at higher block risk. Advanced tuning — leave at default if unsure.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
