# Mercari Japan Sold Listings Scraper (`japandatalab/mercari-japan-sold-listings-scraper`) Actor

Scrapes sold (sold\_out) listings from jp.mercari.com by keyword and returns per-item price records plus per-keyword price aggregates (median/avg/min/max/p25/p75).

- **URL**: https://apify.com/japandatalab/mercari-japan-sold-listings-scraper.md
- **Developed by:** [Japan Data Lab](https://apify.com/japandatalab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 results

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

## Mercari Japan Sold Listings Scraper

**This Actor is for Mercari Japan (jp.mercari.com) — not Mercari US.** If you're
looking for the US Mercari marketplace, this is the wrong Actor. This one
searches Japan's largest C2C marketplace and returns **sold** listings with
their final sale price, so you can see what things actually sold for, not
just what sellers are asking.

Give it one or more keywords, get back:
- A record per sold item — title, price in JPY, condition, seller, images, link.
- Per-keyword price statistics — median, average, min, max, 25th/75th percentile.

### Who this is for

- **Reseller sourcing** — before you list Japanese goods on eBay/Etsy/Poshmark,
  check what comparable items actually sold for on Mercari Japan to price
  competitively and gauge demand.
- **Proxy-buying / daikou pricing** — if you run a proxy-buying service (in the
  ZenMarket/Buyee space) sourcing from Mercari on behalf of overseas customers,
  use sold-price data to quote realistic item costs before you commit to a purchase.
- **Market research** — track how prices for a category (trading cards,
  streetwear, retro electronics, anime merch, etc.) move over time by running
  the same keywords periodically and comparing the aggregate stats.

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `keywords` | string[] | — (required) | Search terms. **Japanese keywords return more precise results than romanized/English ones** — Mercari Japan's search is tuned for Japanese input. E.g. use `ポケモンカード` rather than `pokemon card`. |
| `soldOnly` | boolean | `true` | Keep only sold listings. See "How sold-only filtering works" below. |
| `priceMin` / `priceMax` | number | — | JPY price bounds. |
| `itemCondition` | string[] | — | Any of `new`, `like_new`, `no_signs_of_wear`, `some_signs_of_wear`, `signs_of_wear`, `poor`. Leave empty for all conditions. |
| `categoryId` | string | — | Mercari's numeric `category_id` (as seen in jp.mercari.com search URLs). |
| `maxItemsPerKeyword` | integer | `100` | Upper bound per keyword (max 100). |
| `includeAggregates` | boolean | `true` | Emit per-keyword price statistics (see Output). |

Example input:

```json
{
  "keywords": ["ポケモンカード", "iPhone 13"],
  "soldOnly": true,
  "priceMin": 1000,
  "priceMax": 50000,
  "maxItemsPerKeyword": 50,
  "includeAggregates": true
}
````

### Output

#### Item records (default dataset)

One record per sold item found:

```json
{
  "id": "m36432422259",
  "title": "【未使用美品】ピカチュウ ジムプロモ wcs 10枚セット",
  "priceJpy": 9999,
  "currency": "JPY",
  "status": "sold_out",
  "condition": "新品、未使用",
  "brand": null,
  "imageUrl": "https://static.mercdn.net/item/detail/orig/photos/m36432422259_1.jpg",
  "itemUrl": "https://jp.mercari.com/item/m36432422259",
  "sellerId": "515310776",
  "keyword": "ポケモンカード",
  "scrapedAt": "2026-07-09T05:35:52.515Z"
}
```

`condition` and `brand` are Mercari's own Japanese-language labels (e.g.
`新品、未使用` = "new, unused"), passed through as-is rather than translated,
since translation can lose nuance sellers rely on. `brand` is `null` for
listings where the seller didn't tag a brand (common outside fashion/goods
categories). This Actor does not report a sold date — see the FAQ entry
"Why doesn't this Actor report a sold date?" below.

#### Per-keyword aggregates (named dataset `aggregates`)

When `includeAggregates` is `true`, one extra record per keyword goes to a
**separate named dataset** called `aggregates` (kept apart from item records
so the two shapes never mix in one dataset). Access it via the Apify API/SDK
as `<run>/aggregates` or through the Actor run's dataset list in the console.

```json
{
  "keyword": "ポケモンカード",
  "count": 3,
  "medianPriceJpy": 4500,
  "avgPriceJpy": 5400,
  "minPriceJpy": 1700,
  "maxPriceJpy": 9999,
  "p25PriceJpy": 3100,
  "p75PriceJpy": 7250
}
```

### How sold-only filtering works

Mercari's search accepts a `status=sold_out` URL parameter, but we verified
live (2026-07-09) that it does **not** reliably restrict server-side results —
a plain search page mixed sold and actively-listed items together. This Actor
therefore always enforces "sold only" itself, by checking each result card's
own "売り切れ" (sold) badge before deciding to visit it. This is more robust
than trusting the query parameter, and means results are correctly sold-only
regardless of whether Mercari's server-side behavior changes in the future.
One side effect: sold items are a minority of any given result page, so
collecting many sold items for a keyword may take several search-result pages
even though `maxItemsPerKeyword` looks small.

### Known limitations

- **`itemCondition` filtering happens after fetching each item's detail page**,
  not via a Mercari search-time filter, because the numeric IDs Mercari uses
  for its own condition filter weren't reverse-engineered for this version.
  This costs one extra page load per candidate item but is otherwise
  transparent to you.
- **`itemCondition` matching relies on Mercari's own Japanese condition
  labels** (e.g. `新品、未使用`). Only the `new` label was confirmed against a
  live item during this version's development; the other five values are
  inferred from Mercari's published condition taxonomy and have not
  individually been re-verified against live pages yet (planned for a future
  version). If a run using `itemCondition` returns unexpectedly few or zero
  items, a label mismatch here — not an absence of matching listings — is the
  first thing to suspect; the Actor logs a warning when this happens.
- **`status` for non-sold items is best-effort.** When `soldOnly` is `false`,
  items without a "sold" badge are reported as `on_sale`, but Mercari also has
  an in-progress-transaction state ("取引中") this Actor does not currently
  distinguish from active listings.

### What this Actor won't do

It only reads public pages (`/search`, `/item/...`) that jp.mercari.com's
robots.txt allows. It never calls Mercari's internal API endpoints
(`jp.mercari.com/v1`, `/v2`, or `api.mercari.jp`), and it never logs in. It
also runs at a fixed, deliberately slow pace — one request at a time, at
least 3.5 seconds apart — and this is hard-coded, not something you can turn
up from the input even if you wanted faster results. Sold-price data is a
delicate thing to make freely scrapable at scale; going slow is the price of
staying invited.

### FAQ

**Is this Mercari US or Mercari Japan?**
Japan (jp.mercari.com) only. Mercari US has an entirely separate site and
catalog; this Actor cannot search it.

**Why does the same keyword return different items each run?**
Mercari's search ranks by relevance/recency, and new items sell continuously.
Re-running periodically is the intended way to track price trends via the
aggregate stats.

**Why are there fewer results than `maxItemsPerKeyword`?**
`maxItemsPerKeyword` caps how many *candidate* items we queue up for a
detail-page visit — not how many end up in your output. Fewer final results
than that number can happen because: (1) fewer than that many sold items
exist for the keyword within the pages we crawled, (2) `itemCondition`/
`priceMin`/`priceMax` filtered some out after the detail page was fetched, or
(3) a request failed after retries — check the `failed-requests` named
dataset for details on any skipped items. Using `itemCondition` alongside a
low `maxItemsPerKeyword` makes this more likely, since every candidate that
gets filtered out post-fetch reduces your final count without being replaced.

**Why doesn't this Actor report a sold date?**
Because Mercari's public search and item pages genuinely don't expose one —
we checked the rendered HTML and the embedded JSON-LD structured data on live
item pages and found no "listed at," "sold at," or "last updated" timestamp
anywhere. Any tool that claims to give you a Mercari Japan sold date is
either estimating it from something else or reading Mercari's non-public
internal API, which this Actor deliberately does not call (see "What this
Actor won't do"). We'd rather ship a smaller, honest set of fields than a
field we can't back up. `scrapedAt` tells you when *we* observed the item —
it is not, and should not be read as, the sale date.

**Can I get more than 100 items per keyword?**
Not in this version — the cap is intentionally conservative while the Actor
is new. Run the same keyword again later, or split a broad search into
several narrower keywords.

**Should I use Japanese or English keywords?**
Japanese. Mercari Japan's search is built for Japanese text; romanized or
translated keywords typically return far fewer or less relevant matches.

# Actor input Schema

## `keywords` (type: `array`):

Search keywords to look up on jp.mercari.com. Japanese keywords (e.g. ポケモンカード) generally return more precise results than romanized/English equivalents, since Mercari Japan's search is tuned for Japanese input.

## `soldOnly` (type: `boolean`):

Restrict results to sold (status=sold\_out) listings. This is the Actor's core purpose; turning it off returns active listings instead.

## `priceMin` (type: `integer`):

Only include listings priced at or above this amount, in Japanese yen.

## `priceMax` (type: `integer`):

Only include listings priced at or below this amount, in Japanese yen.

## `itemCondition` (type: `array`):

Filter by Mercari's condition categories. Leave empty to include all conditions.

## `categoryId` (type: `string`):

Optional Mercari category ID to restrict the search to (as used in jp.mercari.com's category\_id search parameter).

## `maxItemsPerKeyword` (type: `integer`):

Upper limit of items collected per keyword. Kept deliberately conservative.

## `includeAggregates` (type: `boolean`):

If enabled, an extra dataset record per keyword is emitted with count/median/avg/min/max/p25/p75 price statistics.

## Actor input object example

```json
{
  "keywords": [
    "ポケモンカード"
  ],
  "soldOnly": true,
  "maxItemsPerKeyword": 10,
  "includeAggregates": true
}
```

# 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 = {
    "keywords": [
        "ポケモンカード"
    ],
    "maxItemsPerKeyword": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("japandatalab/mercari-japan-sold-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 = {
    "keywords": ["ポケモンカード"],
    "maxItemsPerKeyword": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("japandatalab/mercari-japan-sold-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 '{
  "keywords": [
    "ポケモンカード"
  ],
  "maxItemsPerKeyword": 10
}' |
apify call japandatalab/mercari-japan-sold-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mercari Japan Sold Listings Scraper",
        "description": "Scrapes sold (sold_out) listings from jp.mercari.com by keyword and returns per-item price records plus per-keyword price aggregates (median/avg/min/max/p25/p75).",
        "version": "0.1",
        "x-build-id": "476xsSCT1TOHHH0PR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/japandatalab~mercari-japan-sold-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-japandatalab-mercari-japan-sold-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/japandatalab~mercari-japan-sold-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-japandatalab-mercari-japan-sold-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/japandatalab~mercari-japan-sold-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-japandatalab-mercari-japan-sold-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",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "minItems": 1,
                        "type": "array",
                        "description": "Search keywords to look up on jp.mercari.com. Japanese keywords (e.g. ポケモンカード) generally return more precise results than romanized/English equivalents, since Mercari Japan's search is tuned for Japanese input.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "soldOnly": {
                        "title": "Sold listings only",
                        "type": "boolean",
                        "description": "Restrict results to sold (status=sold_out) listings. This is the Actor's core purpose; turning it off returns active listings instead.",
                        "default": true
                    },
                    "priceMin": {
                        "title": "Minimum price (JPY)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings priced at or above this amount, in Japanese yen."
                    },
                    "priceMax": {
                        "title": "Maximum price (JPY)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings priced at or below this amount, in Japanese yen."
                    },
                    "itemCondition": {
                        "title": "Item condition",
                        "type": "array",
                        "description": "Filter by Mercari's condition categories. Leave empty to include all conditions.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "new",
                                "like_new",
                                "no_signs_of_wear",
                                "some_signs_of_wear",
                                "signs_of_wear",
                                "poor"
                            ],
                            "enumTitles": [
                                "New (新品、未使用)",
                                "Like new (未使用に近い)",
                                "No visible scratches or dirt (目立った傷や汚れなし)",
                                "Some scratches or dirt (やや傷や汚れあり)",
                                "Visible scratches or dirt (傷や汚れあり)",
                                "Poor overall condition (全体的に状態が悪い)"
                            ]
                        }
                    },
                    "categoryId": {
                        "title": "Category ID",
                        "type": "string",
                        "description": "Optional Mercari category ID to restrict the search to (as used in jp.mercari.com's category_id search parameter)."
                    },
                    "maxItemsPerKeyword": {
                        "title": "Max items per keyword",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Upper limit of items collected per keyword. Kept deliberately conservative.",
                        "default": 100
                    },
                    "includeAggregates": {
                        "title": "Include per-keyword aggregates",
                        "type": "boolean",
                        "description": "If enabled, an extra dataset record per keyword is emitted with count/median/avg/min/max/p25/p75 price statistics.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```