# Zozotown Listings Scraper (`piotrv1001/zozotown-listings-scraper`) Actor

The ZOZOTOWN Listings Scraper extracts product listings from zozo.jp, Japan's largest fashion marketplace, capturing names, JPY prices, sale discounts, brands, shops, colors, stock, review scores, and images — ideal for price monitoring, trend analysis, and fashion market research.

- **URL**: https://apify.com/piotrv1001/zozotown-listings-scraper.md
- **Developed by:** [FalconScrape](https://apify.com/piotrv1001) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 product listings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What does ZOZOTOWN Listings Scraper do?

Scrape product listings from **[ZOZOTOWN (zozo.jp)](https://zozo.jp)**, Japan's largest fashion e-commerce platform with 1,500+ shops and 8,000+ brands. The **ZOZOTOWN Listings Scraper** extracts structured product data — names, JPY prices, sale discounts, brands, shops, colors, per-size stock availability, review scores, and image URLs — from keyword searches, brand pages, category pages, and individual product pages.

Run it on the Apify platform and you get scheduling, API access, webhooks, integrations (Zapier, Make, Google Sheets), automatic proxy rotation, and run monitoring out of the box.

### ✨ Features

- 🏷️ **Rich product data**: 25+ fields per listing — prices, discount %, time-sale flags, brand (EN + JP), shop, color variants, sold-out status, and CDN image URLs.
- 🔍 **Multiple input modes**: keyword searches (Japanese or English), brand pages, category pages, or direct product URLs.
- 👗 **Deep product details** (optional): manufacturer SKU, full description, materials, country of origin, per-size stock and back-order status, review count and average, category path, tags, and shipping fee.
- 🇯🇵 **Native Japanese support**: search in Japanese (ワンピース) or English (nike) — keyword encoding for ZOZOTOWN's search engine is handled automatically.
- ⚡ **Efficient listing mode**: ~120 products per page request keeps costs low on large crawls.

### 🛠️ How to use ZOZOTOWN Listings Scraper

1. **Enter search keywords** (e.g. `nike`, `ワンピース`) and/or **ZOZOTOWN URLs** (brand, category, search, or product pages) in the Input tab.
2. **Toggle "Scrape product details"** if you want full product records with per-size stock, reviews, SKU, and materials.
3. **Set "Max items"** to cap the run size and your spend.
4. **Run the scraper** — results stream into the Dataset as they're scraped.
5. **Export** as JSON, CSV, Excel, or HTML, or pull via the Apify API / integrations.

### 📥 Input

| Field | Type | Description |
|---|---|---|
| `searchKeywords` | string[] | Keywords to search on ZOZOTOWN. Japanese or English. Each keyword crawls its full result listing. |
| `startUrls` | array | ZOZOTOWN URLs — brand pages (`zozo.jp/brand/nike/`), category pages (`zozo.jp/category/onepiece/`), search result pages, or product pages (`zozo.jp/shop/nike/goods/88470490/`). |
| `scrapeProductDetails` | boolean | If `true`, every product found in listings is also visited for full details. Bills both PPE events per product (see Pricing). Default `false`. |
| `maxItems` | integer | Global cap on total products saved to the dataset. Default `50`. |
| `proxyConfiguration` | object | Proxy settings. ZOZOTOWN only serves visitors from Japan — keep the default Japanese residential proxy unless you have your own Japan-based pool. |

Example minimal input:

```json
{
    "searchKeywords": ["nike", "ワンピース"],
    "scrapeProductDetails": false,
    "maxItems": 200
}
````

### 📊 Output

The scraper produces structured JSON, one record per product. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
[
    {
        "type": "listing",
        "goodsId": 88470490,
        "name": "ナイキ エア フォース 1 '07 メンズシューズ / Nike Air Force 1 '07 Men's Shoes CW2288-111 White",
        "url": "https://zozo.jp/shop/nike/goods/88470490/",
        "category": "スニーカー",
        "properPrice": 16500,
        "salePrice": 7700,
        "currency": "JPY",
        "discountPercent": 53,
        "isOnSale": true,
        "isTimeSale": false,
        "isSoldOut": false,
        "brandName": "NIKE",
        "brandNameJp": "ナイキ",
        "shopName": "NIKE",
        "colorName": "ホワイト",
        "colorCount": 1,
        "imageUrl": "https://c.imgz.jp/490/89470490/89470490b_b_44_500.jpg",
        "keyword": "nike",
        "sourceUrl": "https://zozo.jp/brand/nike/",
        "scrapedAt": "2026-06-04T07:56:53.684Z"
    }
]
```

With `scrapeProductDetails: true` (or direct product URLs), records additionally include:

```json
{
    "type": "detail",
    "productCode": "CW2288-111",
    "description": "ナイキ エア フォース 1 '07...",
    "availabilityStatus": "IN_STOCK_NORMAL",
    "madeIn": "インド/-/中国",
    "material": "甲(アッパー): 天然皮革 + 合成繊維 / 底(アウトソール): ゴム底",
    "targetGenders": ["men", "women"],
    "tags": ["ローカット", "紐", "合成皮革/人工皮革"],
    "reviewCount": 72,
    "reviewAverage": 4.86,
    "sizes": [
        { "sizeName": "24", "colorName": "ホワイト", "status": "INSTOCK", "isInStock": true, "isBackOrder": false }
    ],
    "shippingFee": 330,
    "shopUrl": "https://zozo.jp/shop/nike/",
    "brandUrl": "https://zozo.jp/brand/nike/"
}
```

#### Main data fields

| Field | Description |
|---|---|
| `goodsId` / `goodsCode` | ZOZOTOWN product identifiers |
| `name` | Product name (Japanese, often with English) |
| `properPrice` / `salePrice` | Regular and current price in JPY |
| `discountPercent` | Discount percentage when on sale |
| `brandName` / `brandNameJp` | Brand name in English and Japanese |
| `colorName` / `colorCount` | Color variant info |
| `isSoldOut` / `availabilityStatus` | Stock status |
| `sizes` | Per-size stock availability (detail mode) |
| `productCode` | Manufacturer SKU, e.g. `CW2288-111` (detail mode) |
| `reviewCount` / `reviewAverage` | Customer review stats (detail mode) |

### 💰 How much does it cost to scrape ZOZOTOWN?

This Actor uses **Pay Per Event** pricing — you pay only for products successfully scraped.

| Event | Price | When it fires |
|---|---|---|
| `product-listing` | **$2.00 per 1,000 results** ($0.002 each) | Charged once per product extracted from a search/brand/category listing page. |
| `item-detail` | **$5.00 per 1,000 results** ($0.005 each) | Charged once per product detail page parsed — when `scrapeProductDetails: true`, or when you supply direct product URLs. |

#### How it adds up

| Scenario | Listing events | Detail events | Total cost |
|---|---|---|---|
| 1,000 products, listings only | 1,000 × $0.002 | — | **$2.00** |
| 1,000 products, with details | 1,000 × $0.002 | 1,000 × $0.005 | **$7.00** |
| 100 direct product URLs | — | 100 × $0.005 | **$0.50** |

Use `maxItems` to cap your spend per run, or set a **Max charge per run** in the Apify Console — the Actor stops issuing charges as soon as the limit is reached.

### 💡 Tips

- **Listing mode is the cheapest way to monitor prices** — each request returns ~120 products, so even 10,000-item crawls finish quickly.
- **Japanese keywords usually match better** than English ones (e.g. ワンピース returns 80,000+ dresses), but brand names like `nike` work fine and redirect to the brand page automatically.
- **Use category URLs for full-catalog monitoring** — e.g. `https://zozo.jp/category/onepiece/onepiece-dress/` paired with a high `maxItems`.
- **Sale tracking**: `salePrice`, `discountPercent`, and `isTimeSale` make it easy to filter for discounted items in your export.

### ❓ FAQ, disclaimers, and support

**Is it legal to scrape ZOZOTOWN?** This scraper only extracts publicly available product data and does not collect personal information. Ensure your use of the data complies with ZOZOTOWN's Terms of Service and applicable laws in your jurisdiction; this Actor and its output are provided for lawful purposes such as market research and price monitoring.

**Why do I see retries in the log?** ZOZOTOWN restricts traffic from outside Japan. The Actor rotates Japanese residential sessions automatically — occasional retries are normal and don't bill you anything extra.

**Found a bug or missing field?** Open an issue on the Actor's **Issues** tab — feedback is welcome. Custom solutions (other Japanese e-commerce platforms, tailored output formats) are available on request.

Optimize your Japanese fashion e-commerce research with **ZOZOTOWN Listings Scraper** today! 🚀

# Actor input Schema

## `searchKeywords` (type: `array`):

Keywords to search on ZOZOTOWN (Japanese or English, e.g. ナイキ, ワンピース, nike). Each keyword crawls its full result listing.

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

ZOZOTOWN URLs to scrape — brand pages (zozo.jp/brand/nike/), category pages (zozo.jp/category/onepiece/), search result pages, or direct product pages (zozo.jp/shop/nike/goods/88470490/).

## `scrapeProductDetails` (type: `boolean`):

If enabled, every product found in listings is also visited for full details: description, SKU/product code, materials, country of origin, per-size stock availability, review score, tags, and shipping fee. Slower and billed at the higher product-detail rate.

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

Maximum total number of products saved to the dataset across all keywords and URLs. Keeps run costs predictable on broad searches (popular keywords can return 80,000+ products).

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

ZOZOTOWN only serves visitors from Japan, so Japanese residential proxies are required. Keep the default unless you have your own Japan-based proxy pool.

## Actor input object example

```json
{
  "searchKeywords": [
    "nike"
  ],
  "startUrls": [],
  "scrapeProductDetails": false,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "JP"
  }
}
```

# Actor output Schema

## `results` (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 = {
    "searchKeywords": [
        "nike"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "JP"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("piotrv1001/zozotown-listings-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 = {
    "searchKeywords": ["nike"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "JP",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("piotrv1001/zozotown-listings-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 '{
  "searchKeywords": [
    "nike"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "JP"
  }
}' |
apify call piotrv1001/zozotown-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zozotown Listings Scraper",
        "description": "The ZOZOTOWN Listings Scraper extracts product listings from zozo.jp, Japan's largest fashion marketplace, capturing names, JPY prices, sale discounts, brands, shops, colors, stock, review scores, and images — ideal for price monitoring, trend analysis, and fashion market research.",
        "version": "0.0",
        "x-build-id": "Dofar7cMoLIIauOJi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/piotrv1001~zozotown-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-piotrv1001-zozotown-listings-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/piotrv1001~zozotown-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-piotrv1001-zozotown-listings-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/piotrv1001~zozotown-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-piotrv1001-zozotown-listings-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": {
                    "searchKeywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Keywords to search on ZOZOTOWN (Japanese or English, e.g. ナイキ, ワンピース, nike). Each keyword crawls its full result listing.",
                        "default": [
                            "nike"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "ZOZOTOWN URLs to scrape — brand pages (zozo.jp/brand/nike/), category pages (zozo.jp/category/onepiece/), search result pages, or direct product pages (zozo.jp/shop/nike/goods/88470490/).",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "scrapeProductDetails": {
                        "title": "Scrape product details",
                        "type": "boolean",
                        "description": "If enabled, every product found in listings is also visited for full details: description, SKU/product code, materials, country of origin, per-size stock availability, review score, tags, and shipping fee. Slower and billed at the higher product-detail rate.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum total number of products saved to the dataset across all keywords and URLs. Keeps run costs predictable on broad searches (popular keywords can return 80,000+ products).",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "ZOZOTOWN only serves visitors from Japan, so Japanese residential proxies are required. Keep the default unless you have your own Japan-based proxy pool.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "JP"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
