# Etsy Reviews Scraper (`khadinakbar/etsy-reviews-scraper`) Actor

Scrape Etsy product reviews from listing URLs and shop pages. Extract rating, review text, reviewer, date, images, listing metadata, and shop context for sentiment analysis, competitor research, and AI agents.

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

## Pricing

from $5.00 / 1,000 etsy 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

## Etsy Reviews Scraper: Product Feedback, Ratings, Review Text

Scrape Etsy customer reviews from product listing URLs and shop pages for sentiment analysis, competitor research, product-market research, and AI-agent workflows.

### What It Extracts

| Field | Description |
| --- | --- |
| `rating` | Customer star rating from 1 to 5 when Etsy exposes it |
| `reviewText` | Full review body text |
| `reviewDate` | Review date from the Etsy page |
| `reviewerName` | Public reviewer display name |
| `reviewerProfileUrl` | Public Etsy reviewer profile URL when visible |
| `reviewImages` | URLs for review photos when available |
| `listingId` | Etsy listing ID |
| `listingTitle` | Product title from the listing page |
| `listingUrl` | Canonical Etsy product URL |
| `listingRating` | Listing or shop rating context |
| `listingReviewCount` | Visible review count context |
| `shopName` | Etsy shop name |
| `shopUrl` | Etsy shop URL |
| `diagnosticStatus` | `blocked` or `empty` when no review rows could be extracted |

### When To Use This Actor

Use Etsy Reviews Scraper when you need structured customer feedback from specific Etsy products. It is useful for tracking competitor reviews, finding recurring complaints, collecting user-generated product language, training sentiment classifiers, monitoring quality changes, and building buyer-research datasets for handmade, vintage, craft supply, and digital product niches.

This actor is also designed for Apify MCP and AI agents. A model can pass one or more Etsy product URLs, receive a flat dataset of review rows, and chain the result into a sentiment analyzer, spreadsheet export, or product research report.

### When Not To Use It

Do not use this actor for broad Etsy keyword search, price monitoring, or catalog scraping. Use `etsy-all-in-one-scraper` when you need product listings, shop catalogs, prices, badges, and reviews in one run. Use this narrower actor when the job is specifically review extraction from known listings or shop pages.

Do not use this actor for private account data, buyer messages, seller dashboards, or logged-in-only Etsy data. It extracts public review content visible from Etsy listing and shop pages.

### Input

#### Product URLs

Pass one or more direct Etsy listing URLs:

```json
{
  "productUrls": [
    "https://www.etsy.com/listing/1071878058/charger-plate-pumpkin-set-pumpkin"
  ],
  "maxReviewsPerListing": 25,
  "maxResults": 25
}
````

Direct listing URLs are the most reliable path because the actor can go straight to the review section and avoid unnecessary discovery pages.

#### Shop URLs

You can also pass Etsy shop URLs. The actor opens the shop, discovers visible listing URLs, and then scrapes reviews from those listings:

```json
{
  "shopUrls": [
    "https://www.etsy.com/shop/GlassMystique"
  ],
  "maxReviewsPerListing": 10,
  "maxResults": 50
}
```

Shop crawling is slower and more sensitive to Etsy layout changes than direct product URLs. For production pipelines, feed product URLs whenever possible.

#### Limits

`maxReviewsPerListing` caps review rows per product. `maxResults` caps the total review rows saved across the full run. The actor stops before charging beyond the total cap.

### Output Example

```json
{
  "recordType": "review",
  "reviewId": "1234567890",
  "reviewUrl": "https://www.etsy.com/listing/1071878058/charger-plate-pumpkin-set-pumpkin#review-1234567890",
  "rating": 5,
  "reviewText": "Beautiful quality and shipped quickly.",
  "reviewDate": "2026-05-21",
  "reviewerName": "Avery",
  "reviewerProfileUrl": "https://www.etsy.com/people/example",
  "reviewImages": ["https://i.etsystatic.com/example.jpg"],
  "listingId": "1071878058",
  "listingTitle": "Charger Plate Pumpkin Set",
  "listingUrl": "https://www.etsy.com/listing/1071878058/charger-plate-pumpkin-set-pumpkin",
  "listingRating": 4.8,
  "listingReviewCount": 327,
  "shopName": "GlassMystique",
  "shopUrl": "https://www.etsy.com/shop/GlassMystique",
  "sourceUrl": "https://www.etsy.com/listing/1071878058/charger-plate-pumpkin-set-pumpkin",
  "scrapedAt": "2026-06-12T12:00:00.000Z",
  "diagnosticStatus": null,
  "diagnosticMessage": null
}
```

### Pricing

This actor uses pay per event pricing.

| Event | Price | When it is charged |
| --- | ---: | --- |
| Actor start | $0.00005 | Once when the actor starts, scaled by memory |
| Etsy review scraped | $0.005 | Each review row successfully saved to the dataset |

Typical run cost examples:

| Run | Approximate PPE cost |
| --- | ---: |
| 10 reviews | $0.05005 |
| 25 reviews | $0.12505 |
| 100 reviews | $0.50005 |

The actor logs the estimated maximum charge before scraping starts. Diagnostic rows are not charged as review rows.

### Reliability Notes

Etsy uses DataDome anti-bot protection. The actor defaults to Apify Residential proxies and uses a real Chrome Playwright browser with a warmup step before visiting product pages. If Etsy returns a DataDome challenge that cannot be resolved, the actor saves a diagnostic row and writes `RUN_SUMMARY` and `OUTPUT` records to the key-value store. This avoids silent empty datasets and gives agents a clear explanation of what happened.

For stronger DataDome bypass on protected runs, configure `TWO_CAPTCHA_API_KEY` as an actor environment variable or provide a high-quality rotating residential proxy through `CUSTOM_PROXY_URL`. The actor never requires Etsy login credentials.

### API Example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('khadinakbar/etsy-reviews-scraper').call({
  productUrls: ['https://www.etsy.com/listing/1071878058/charger-plate-pumpkin-set-pumpkin'],
  maxReviewsPerListing: 10,
  maxResults: 10
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### MCP And AI Agent Use

Tool description: Scrape Etsy product reviews for sentiment and competitor research. Use for listing URLs or shop URLs, not broad Etsy product search. Returns one review per row with rating, text, reviewer, date, listing, shop, and diagnostic fields. Charged $0.005 per review plus a tiny start fee.

Agents should call this actor when the user asks for Etsy review text, customer sentiment, complaint themes, review exports, or competitor product feedback. Agents should not call it for price search, product discovery, private seller analytics, or logged-in data.

### Legal And Compliance

This actor extracts public web data from Etsy pages. Review Etsy's terms and applicable laws before using the data in production. Do not use the output to spam, harass, deanonymize buyers, or make automated decisions that violate privacy or marketplace rules.

# Actor input Schema

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

Use this when you have direct Etsy listing URLs to collect reviews from. Enter one URL per line, for example https://www.etsy.com/listing/1071878058/charger-plate-pumpkin-set-pumpkin. Defaults to one sample listing when no input is provided. Do not use search result URLs here; use shopUrls only for Etsy shop pages.

## `shopUrls` (type: `array`):

Use this when you want the actor to discover listings from Etsy shop pages before scraping reviews. Enter full shop URLs such as https://www.etsy.com/shop/GlassMystique. Defaults to empty and is slower than direct listing URLs. This is not a keyword search field.

## `maxReviewsPerListing` (type: `integer`):

Use this to cap the number of reviews collected from each Etsy listing. Accepts integers from 1 to 500, with 25 as the default. Lower this for quick sentiment samples and raise it for deeper product research. This does not cap the total run across all listings; use maxResults for that.

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

Use this to cap the total number of review records saved across the whole run. Accepts integers from 1 to 5000, with 25 as the default. The actor stops before charging beyond this cap. This is a review count, not a page count.

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

Use this to prefer newest Etsy reviews or Etsy's recommended order. Choose most\_recent for monitoring fresh feedback, or recommended for Etsy's default display. Defaults to most\_recent. This does not filter by star rating.

## `includeListingMetadata` (type: `boolean`):

Use this to include listing title, shop name, listing rating, and review count on each review row. Defaults to true because agents and analysts need product context with each review. Disable it only when you need the smallest possible rows. This does not scrape full product descriptions.

## `includeReviewImages` (type: `boolean`):

Use this to include image URLs attached to customer reviews when Etsy exposes them. Defaults to true for richer quality and UGC analysis. Disable it to reduce output size. This does not download image files; it only returns URLs.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.etsy.com/listing/1071878058/charger-plate-pumpkin-set-pumpkin"
  ],
  "shopUrls": [],
  "maxReviewsPerListing": 10,
  "maxResults": 10,
  "sortBy": "most_recent",
  "includeListingMetadata": true,
  "includeReviewImages": true
}
```

# Actor output Schema

## `reviews` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `datasetId` (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": [
        "https://www.etsy.com/listing/1071878058/charger-plate-pumpkin-set-pumpkin"
    ],
    "shopUrls": [],
    "maxReviewsPerListing": 10,
    "maxResults": 10,
    "sortBy": "most_recent"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/etsy-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.etsy.com/listing/1071878058/charger-plate-pumpkin-set-pumpkin"],
    "shopUrls": [],
    "maxReviewsPerListing": 10,
    "maxResults": 10,
    "sortBy": "most_recent",
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/etsy-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.etsy.com/listing/1071878058/charger-plate-pumpkin-set-pumpkin"
  ],
  "shopUrls": [],
  "maxReviewsPerListing": 10,
  "maxResults": 10,
  "sortBy": "most_recent"
}' |
apify call khadinakbar/etsy-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Etsy Reviews Scraper",
        "description": "Scrape Etsy product reviews from listing URLs and shop pages. Extract rating, review text, reviewer, date, images, listing metadata, and shop context for sentiment analysis, competitor research, and AI agents.",
        "version": "1.0",
        "x-build-id": "Cln0S0oROZSe0FkZT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~etsy-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-etsy-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~etsy-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-etsy-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~etsy-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-etsy-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",
                "properties": {
                    "productUrls": {
                        "title": "Etsy Product URLs",
                        "type": "array",
                        "description": "Use this when you have direct Etsy listing URLs to collect reviews from. Enter one URL per line, for example https://www.etsy.com/listing/1071878058/charger-plate-pumpkin-set-pumpkin. Defaults to one sample listing when no input is provided. Do not use search result URLs here; use shopUrls only for Etsy shop pages.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "shopUrls": {
                        "title": "Etsy Shop URLs",
                        "type": "array",
                        "description": "Use this when you want the actor to discover listings from Etsy shop pages before scraping reviews. Enter full shop URLs such as https://www.etsy.com/shop/GlassMystique. Defaults to empty and is slower than direct listing URLs. This is not a keyword search field.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerListing": {
                        "title": "Max Reviews Per Listing",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Use this to cap the number of reviews collected from each Etsy listing. Accepts integers from 1 to 500, with 25 as the default. Lower this for quick sentiment samples and raise it for deeper product research. This does not cap the total run across all listings; use maxResults for that.",
                        "default": 25
                    },
                    "maxResults": {
                        "title": "Max Total Reviews",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Use this to cap the total number of review records saved across the whole run. Accepts integers from 1 to 5000, with 25 as the default. The actor stops before charging beyond this cap. This is a review count, not a page count.",
                        "default": 25
                    },
                    "sortBy": {
                        "title": "Review Sort Order",
                        "enum": [
                            "most_recent",
                            "recommended"
                        ],
                        "type": "string",
                        "description": "Use this to prefer newest Etsy reviews or Etsy's recommended order. Choose most_recent for monitoring fresh feedback, or recommended for Etsy's default display. Defaults to most_recent. This does not filter by star rating.",
                        "default": "most_recent"
                    },
                    "includeListingMetadata": {
                        "title": "Include Listing Metadata",
                        "type": "boolean",
                        "description": "Use this to include listing title, shop name, listing rating, and review count on each review row. Defaults to true because agents and analysts need product context with each review. Disable it only when you need the smallest possible rows. This does not scrape full product descriptions.",
                        "default": true
                    },
                    "includeReviewImages": {
                        "title": "Include Review Images",
                        "type": "boolean",
                        "description": "Use this to include image URLs attached to customer reviews when Etsy exposes them. Defaults to true for richer quality and UGC analysis. Disable it to reduce output size. This does not download image files; it only returns URLs.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
