# Etsy Listings & Seller Intel Scraper (No Login) (`scrapemint/etsy-listings-seller-intel`) Actor

Pull public Etsy listings and seller intel by keyword or shop. Each row carries listing ID, title, price, sale price, currency, favorites, rating, review count, shop name, shop sales, shop years active, location, star seller status, and tags. JSON. Pay per listing.

- **URL**: https://apify.com/scrapemint/etsy-listings-seller-intel.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** E-commerce
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 Listings & Seller Intel Scraper (No Login Required)

Pull public Etsy listings and seller intel from any keyword search or shop URL. No cookies. No login. No Etsy seller account. Each row ships the listing ID, title, price (sale and original), favorites, rating, review count, plus shop-level intel like total sales, years on Etsy, location, and star seller status. Pay per listing.

**Built for** dropshippers hunting trending products, niche makers benchmarking competitors, vintage and antique dealers tracking comps, DTC brands sourcing creative angles, and acquirers vetting shop-level seller intel.

**Keywords this actor ranks for:** etsy scraper, etsy listing scraper, etsy product api, etsy seller scraper, etsy shop intel, etsy bestseller tracker, etsy trend scraper, etsy competitor research, dropshipping etsy, etsy product hunt, etsy keyword research, etsy sales estimator.

---

### Why this actor

| Other Etsy scrapers | **This actor** |
|---|---|
| Need a seller cookie | Zero cookies, zero login |
| Return one HTML blob per page | Listing ID, title, price, sale price, favorites, rating, review count, tags parsed |
| Drop shop-level intel | Shop sales, years active, location, star seller status embedded on every listing row |
| Charge per page hit | Charge per listing row, no contract |
| Get rate limited at five rows | Built on residential proxy with session pooling for sustained runs |

---

### How it works

```mermaid
flowchart LR
    A[Keyword or shop URL] --> B[Build Etsy URL<br/>per region]
    B --> C[Open the public SPA<br/>no auth needed]
    C --> D[Paginate the listing grid<br/>respect maxListingsPerSource]
    D --> E[Anchor on data-listing-id<br/>walk to ad card]
    E --> F[Parse title, price, sale, favorites,<br/>rating, badges]
    F --> G[Lazy fetch shop intel<br/>once per unique shop]
    G --> H[Embed shop intel into row]
    H --> I[Push one row per listing]
    I --> J[(JSON CSV Excel API)]
````

The actor anchors extraction on the public `data-listing-id` attribute that Etsy renders on every listing card. That makes it resilient to the React class name churn that breaks most Etsy scrapers within weeks. Shop-level intel is fetched once per unique shop and embedded onto every listing row from that shop.

***

### What you get per row

```mermaid
flowchart LR
    R[Listing row] --> R1[Identity<br/>listingId url title]
    R --> R2[Pricing<br/>priceCurrent priceOriginal currency salePercent]
    R --> R3[Demand signals<br/>favorites rating reviewCount badges]
    R --> R4[Shop<br/>shopName shopUrl shopRating shopTotalSales shopOpenedYear shopLocation]
```

Pipe straight into a product hunt sheet, a competitor teardown, or a dropshipping spend tracker.

***

### Quick start

**Hunt a trending category by keyword**

```json
{
  "queries": ["leather wallet", "wedding invitation"],
  "maxListingsPerSource": 100
}
```

**Pull every active listing from a competitor shop**

```json
{
  "shopUrls": [
    "https://www.etsy.com/shop/Beardbrand",
    "https://www.etsy.com/shop/SimpleLoveDecor"
  ],
  "maxListingsPerSource": 200,
  "includeShopIntel": true
}
```

**Comp research for vintage dealers**

```json
{
  "queries": ["vintage typewriter olivetti", "vintage typewriter remington"],
  "country": "US",
  "maxListingsPerSource": 60
}
```

***

### Sample output

```json
{
  "listingId": "1248756093",
  "url": "https://www.etsy.com/listing/1248756093/",
  "title": "Handmade Full Grain Leather Bifold Wallet, Personalized Mens Gift",
  "priceCurrent": 38.50,
  "priceOriginal": 55.00,
  "currency": "USD",
  "salePercent": 30,
  "rating": 4.9,
  "reviewCount": 1384,
  "favorites": 4210,
  "isBestseller": true,
  "isStarSeller": true,
  "freeShipping": true,
  "shopName": "PineLeatherCo",
  "shopUrl": "https://www.etsy.com/shop/PineLeatherCo",
  "imageUrl": "https://i.etsystatic.com/.../il_794xN.123_abcd.jpg",
  "shopRating": 4.9,
  "shopReviewCount": 24320,
  "shopTotalSales": 58410,
  "shopOpenedYear": 2017,
  "shopLocation": "Austin, Texas, United States",
  "shopIsStarSeller": true,
  "shopAnnouncement": "All orders ship within 2 business days. Free monogram on every bifold.",
  "sourceType": "search",
  "searchQuery": "leather wallet",
  "sourceShop": null,
  "country": "US",
  "scrapedAt": "2026-05-10T09:30:00.000Z"
}
```

***

### Who uses this

| Role | Use case |
|---|---|
| Dropshipper | Hunt high-favorites, high-review listings to source via overseas suppliers |
| Niche maker | Benchmark competitor pricing, sale cadence, and badge mix in your category |
| Vintage dealer | Track comparable sold pricing for rare items by keyword |
| DTC brand | Source creative angles and copy patterns from top sellers |
| Etsy seller | Monitor your own bestsellers vs. shop competitors weekly |
| Acquirer | Vet shop-level intel before buying an established Etsy business |
| SEO | Pull keyword search results to map listing tag patterns |

***

### Input reference

| Field | Type | What it does |
|---|---|---|
| `queries` | string\[] | Search keywords. One Etsy search per query. |
| `shopUrls` | string\[] | Full Etsy shop URLs or raw shop names. Pulls every active listing per shop. |
| `maxListingsPerSource` | integer | Max listings collected per query or shop before pagination stops. Default 60. |
| `country` | string | Etsy regional storefront. Default US. |
| `includeShopIntel` | boolean | Embed shop sales, years active, location, star seller status onto every listing row. Default true. |
| `concurrency` | integer | Pages processed in parallel. Five is the safe default for Etsy. |
| `proxyConfiguration` | object | Apify proxy. Residential is required at any meaningful volume. |

***

### API call

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/YOUR_USER~etsy-listings-seller-intel/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "queries": ["leather wallet"],
    "maxListingsPerSource": 100
  }'
```

***

### Pricing

The first 30 listing rows per run are free so you can validate output before paying. After that, each listing row is charged. No surprise add on charges.

***

### FAQ

#### Do I need an Etsy seller account?

No. The actor only touches Etsy's public search and shop pages. Your account is never touched.

#### Can I get sold listing prices?

Etsy hides historical sold prices from anonymous visitors. The actor returns active listing prices, sale prices, and the favorites count, which together give a strong demand signal for trend tracking.

#### How many listings can I pull per shop?

Up to `maxListingsPerSource`, capped at 1000. Most Etsy shops surface their full active inventory through the shop grid.

#### Can I scrape regional Etsy storefronts?

Yes. Set `country` to GB, DE, FR, CA, AU, IN, or JP. Pricing currency and shipping defaults will reflect the chosen storefront.

#### What if a shop has no listings or is on vacation?

The actor returns nothing for that source and logs a warning. You only pay per pushed row, so an empty shop is a free lookup.

#### How fresh is the data?

Each run hits the live page, so prices, favorites, and badges reflect what Etsy renders at scrape time. Schedule weekly runs to track sale cadence and sentiment shifts.

#### Is scraping Etsy allowed?

This actor reads HTML any anonymous web visitor can see. Respect Etsy's terms and rate limit sensibly. Do not redistribute personal data you have no lawful basis to process.

***

### Related actors

- **Amazon Product Scraper** — pull product listings, prices, and badges from Amazon storefronts
- **E-commerce Scraper Pro** — pull product listings across major shop platforms
- **Facebook Marketplace Deal Finder** — pull live Marketplace listings with price, location, and seller
- **Google Maps Scraper** — pull local business listings with rating, address, and category
- **Trustpilot Brand Reputation** — pull TrustScore, review count, and review snippets per business

# Actor input Schema

## `queries` (type: `array`):

Keywords to search the Etsy catalog. Each query runs as one search. Examples: 'wedding invitation', 'vintage typewriter', 'leather wallet'.

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

Pull every active listing from these Etsy shops, plus shop-level intel. Accepts full shop URLs (e.g. 'https://www.etsy.com/shop/Beardbrand') or raw shop names ('Beardbrand').

## `maxListingsPerSource` (type: `integer`):

Stop paginating for a given query or shop once this many listings have been collected. Higher numbers add latency and proxy cost.

## `country` (type: `string`):

Etsy regional storefront. Determines pricing currency and shipping defaults shown.

## `includeShopIntel` (type: `boolean`):

Embed shop sales, years active, location, star seller status, and overall rating onto every listing row. Pulls one extra fetch per unique shop seen during the run.

## `concurrency` (type: `integer`):

Number of search and shop pages processed in parallel. Five is a safe default for Etsy.

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

Apify proxy. Residential is required at any meaningful volume.

## Actor input object example

```json
{
  "queries": [
    "leather wallet",
    "wedding invitation"
  ],
  "shopUrls": [],
  "maxListingsPerSource": 60,
  "country": "US",
  "includeShopIntel": true,
  "concurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "queries": [
        "leather wallet",
        "wedding invitation"
    ],
    "shopUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/etsy-listings-seller-intel").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 = {
    "queries": [
        "leather wallet",
        "wedding invitation",
    ],
    "shopUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/etsy-listings-seller-intel").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 '{
  "queries": [
    "leather wallet",
    "wedding invitation"
  ],
  "shopUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapemint/etsy-listings-seller-intel --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Etsy Listings & Seller Intel Scraper (No Login)",
        "description": "Pull public Etsy listings and seller intel by keyword or shop. Each row carries listing ID, title, price, sale price, currency, favorites, rating, review count, shop name, shop sales, shop years active, location, star seller status, and tags. JSON. Pay per listing.",
        "version": "0.1",
        "x-build-id": "79yjYGaGXgVQz56Wu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~etsy-listings-seller-intel/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-etsy-listings-seller-intel",
                "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/scrapemint~etsy-listings-seller-intel/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-etsy-listings-seller-intel",
                "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/scrapemint~etsy-listings-seller-intel/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-etsy-listings-seller-intel",
                "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": {
                    "queries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Keywords to search the Etsy catalog. Each query runs as one search. Examples: 'wedding invitation', 'vintage typewriter', 'leather wallet'.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "shopUrls": {
                        "title": "Shop URLs or names",
                        "type": "array",
                        "description": "Pull every active listing from these Etsy shops, plus shop-level intel. Accepts full shop URLs (e.g. 'https://www.etsy.com/shop/Beardbrand') or raw shop names ('Beardbrand').",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxListingsPerSource": {
                        "title": "Max listings per source",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Stop paginating for a given query or shop once this many listings have been collected. Higher numbers add latency and proxy cost.",
                        "default": 60
                    },
                    "country": {
                        "title": "Etsy region",
                        "enum": [
                            "US",
                            "GB",
                            "DE",
                            "FR",
                            "CA",
                            "AU",
                            "IN",
                            "JP"
                        ],
                        "type": "string",
                        "description": "Etsy regional storefront. Determines pricing currency and shipping defaults shown.",
                        "default": "US"
                    },
                    "includeShopIntel": {
                        "title": "Include shop-level intel on each row",
                        "type": "boolean",
                        "description": "Embed shop sales, years active, location, star seller status, and overall rating onto every listing row. Pulls one extra fetch per unique shop seen during the run.",
                        "default": true
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Number of search and shop pages processed in parallel. Five is a safe default for Etsy.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy. Residential is required at any meaningful volume.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
