# Mercari Japan Listings Scraper (`automation-lab/mercari-japan-listings-scraper`) Actor

🛒 Scrape public Mercari Japan listings with prices, status, item URLs, images, and IDs for resale research.

- **URL**: https://apify.com/automation-lab/mercari-japan-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Listings Scraper

Scrape public Mercari Japan search results for resale sourcing, marketplace monitoring, and price research.

### What does Mercari Japan Listings Scraper do?

Mercari Japan Listings Scraper extracts public listing cards from `jp.mercari.com` search result pages. Give it keywords such as `nintendo switch`, or paste Mercari Japan search URLs, and it returns structured rows with title, JPY price, item URL, image URL, listing ID, status, source URL, and scrape timestamp.

### Who is it for?

- 🛒 Resellers tracking Japanese second-hand marketplace prices.
- 🎮 Collectibles buyers monitoring games, cards, cameras, fashion, toys, and electronics.
- 📊 Marketplace analysts comparing on-sale and sold-out listing prices.
- 🧰 Automation teams feeding Mercari Japan data into spreadsheets, alerts, BI tools, or repricing workflows.

### Why use this scraper?

Mercari Japan is a fast-moving C2C marketplace. Manual checks are slow when you need to watch many keywords. This actor turns public search pages into exportable datasets that can be filtered, scheduled, and integrated through Apify.

### What data can you extract?

| Field | Description |
| --- | --- |
| `itemId` | Mercari item identifier when available. |
| `title` | Public listing title. |
| `price` | Parsed source price in Japanese yen. |
| `currency` | `JPY`. |
| `displayPrice` | Human-readable yen price. |
| `status` | `on_sale` or `sold_out` when detectable. |
| `itemUrl` | Absolute Mercari Japan item URL. |
| `imageUrl` | Main listing thumbnail URL. |
| `imageUrls` | Array of image URLs found on the card. |
| `sourceUrl` | Search URL that produced the row. |
| `keyword` | Keyword parsed from the source URL. |
| `scrapedAt` | ISO scrape timestamp. |

### How much does it cost to scrape Mercari Japan listings?

The actor uses pay-per-event pricing: a small start fee plus a per-listing event. The exact live price is shown on the Apify actor page before you run it. Keep first tests small, for example 20 listings, then scale after confirming the output matches your workflow.

### How to use

1. Open the actor on Apify.
2. Enter one or more keywords, such as `nintendo switch` or `sony camera`.
3. Or paste public Mercari Japan search URLs in `startUrls`.
4. Set `maxItems` to your desired limit.
5. Run the actor.
6. Download results as JSON, CSV, Excel, XML, or RSS from the dataset.

### Input options

#### Keywords

Use `keywords` for simple searches. Each keyword becomes a Mercari Japan search URL.

#### Start URLs

Use `startUrls` when you already have a filtered Mercari Japan search URL, for example a sold-out status filter or category URL.

#### Maximum listings

Use `maxItems` to cap the total number of saved rows across all keywords and URLs.

#### Proxy configuration

Proxy is optional. The default prefill keeps proxy disabled for the cheapest first run. Enable Apify Proxy if your run is blocked from your region.

### Example input

```json
{
  "keywords": ["nintendo switch"],
  "maxItems": 20,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

### Example URL input

```json
{
  "startUrls": [
    { "url": "https://jp.mercari.com/search?keyword=pokemon&status=sold_out" }
  ],
  "maxItems": 50
}
```

### Example output

```json
{
  "itemId": "m64388983006",
  "title": "Nintendo Switch 2 本体 日本国内専用　未開封",
  "price": 53800,
  "currency": "JPY",
  "displayPrice": "¥53,800",
  "status": "on_sale",
  "itemUrl": "https://jp.mercari.com/item/m64388983006",
  "imageUrl": "https://static.mercdn.net/thumb/item/webp/m64388983006_1.jpg",
  "imageUrls": ["https://static.mercdn.net/thumb/item/webp/m64388983006_1.jpg"],
  "sourceUrl": "https://jp.mercari.com/search?keyword=nintendo+switch",
  "keyword": "nintendo switch",
  "scrapedAt": "2026-06-06T08:12:48.772Z"
}
```

### Tips for better results

- Start with specific keywords such as model names, product codes, or Japanese terms.
- Use Mercari's own filters in the browser, then paste the filtered URL into `startUrls`.
- Use sold-out URLs for historical sold price research.
- Keep `maxItems` low while testing a new keyword set.
- Schedule recurring runs to monitor price changes over time.

### Common use cases

- Reseller sourcing lists for electronics, trading cards, toys, and fashion.
- Sold-price monitoring for Japanese marketplace comps.
- Alert workflows for newly listed items under a target price.
- Spreadsheet enrichment with Mercari Japan item URLs and thumbnails.
- Product research for cross-border shopping and import decisions.

### Integrations

Use Apify integrations to send Mercari Japan rows to:

- Google Sheets for sourcing dashboards.
- Zapier or Make for alerts and workflow automation.
- Webhooks for real-time notifications.
- Data warehouses for marketplace analytics.
- Custom apps through the Apify API.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/mercari-japan-listings-scraper').call({
  keywords: ['nintendo switch'],
  maxItems: 20,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/mercari-japan-listings-scraper').call(
    run_input={'keywords': ['nintendo switch'], 'maxItems': 20}
)
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~mercari-japan-listings-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["nintendo switch"],"maxItems":20}'
```

### MCP server usage

Connect this actor to AI tools through the Apify MCP server:

`https://mcp.apify.com/?tools=automation-lab/mercari-japan-listings-scraper`

Add the Apify MCP server in Claude Code:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/mercari-japan-listings-scraper
```

Claude Desktop MCP configuration example:

```json
{
  "mcpServers": {
    "apify-mercari-japan": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.apify.com/?tools=automation-lab/mercari-japan-listings-scraper"
      ]
    }
  }
}
```

Example prompts showing MCP usage:

#### Claude Code prompt

"Use the Apify MCP tool `automation-lab/mercari-japan-listings-scraper` for `sony camera`, return the 20 cheapest listings, and summarize title, price, and URL."

#### Claude Desktop prompt

"Run the Mercari Japan Listings Scraper through MCP for Pokemon cards, compare sold listings with on-sale listings, and create a pricing summary from the dataset."

### Scheduling

Create an Apify schedule to run the scraper daily or hourly. Scheduled runs are useful for price monitoring, new listing alerts, and sold-status tracking.

### Data quality notes

The actor extracts public search-card data. Some fields such as seller, brand, category, condition, or location may not be present on search cards and are left empty unless publicly visible in the rendered page.

### Limitations

- The actor does not log in.
- The actor does not scrape private account-only data.
- Search result availability may vary by region and Mercari UI changes.
- Very broad keywords can return many similar listings; use filters for cleaner results.

### Troubleshooting

#### The run returned no items

Check that the keyword has public Mercari Japan results. Try a smaller `maxItems` and a direct `startUrls` search URL copied from your browser.

#### The page is blocked

Enable Apify Proxy in the input. If the site still blocks your run, try again later with a lower concurrency and smaller item limit.

### Legality

This actor is designed to collect publicly visible marketplace search data. You are responsible for using the data legally, respecting Mercari's terms, and avoiding personal or private information.

### FAQ

#### Does this actor require a Mercari account?

No. It only opens public Mercari Japan search and category pages and does not log in.

#### Can it scrape sold listings?

Yes, if the public search URL includes Mercari's sold-status filter. The actor also detects sold badges when they are visible on search result cards.

#### Why are some seller, brand, or condition fields empty?

Mercari search cards do not always expose those fields publicly. The actor leaves unavailable fields empty rather than inventing values.

### Related scrapers

- https://apify.com/automation-lab/ebay-sold-listings-scraper
- https://apify.com/automation-lab/ebay-scraper
- https://apify.com/automation-lab/amazon-product-scraper

### Changelog

#### 0.1

Initial version for public Mercari Japan search result listings.

### Support

If you need a field that is publicly visible but missing from the dataset, open an issue on the actor page with a sample Mercari Japan URL and expected output.

### Practical workflow tips

Use the actor as part of a repeatable Mercari Japan research workflow rather than a one-off export.

#### Keyword planning

Start with precise product names, model numbers, character names, or Japanese terms. Broad English keywords can return unrelated goods, while exact Japanese searches usually produce cleaner price comparisons.

#### Sold listing analysis

For market comps, combine Mercari's sold-status filter with a moderate `maxItems` value. Export the dataset to CSV, sort by price, and remove incomplete or damaged goods before calculating averages.

#### Monitoring live inventory

For sourcing or arbitrage workflows, schedule the actor with the same keyword set and compare new `itemId` values against your previous dataset exports. The `scrapedAt` and `sourceUrl` fields make it easier to track when and where an item was observed.

#### Data quality checks

Before scaling a run, inspect the first rows in the Apify dataset preview. Confirm that prices are numeric JPY values, item URLs open correctly, and image URLs resolve. Increase `maxItems` only after the query produces relevant results.

#### Cost control

Keep exploratory runs small, then scale the item limit when the query is validated. Use the proxy option only if direct access is unreliable for your workload.

# Actor input Schema

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

Mercari Japan search keywords. Each keyword is converted to https://jp.mercari.com/search?keyword=...

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

Public Mercari Japan search/category URLs to scrape, for example https://jp.mercari.com/search?keyword=nintendo

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

Maximum number of listings to save across all keywords and URLs.

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

Optional proxy configuration. Leave disabled for the cheapest first run; enable Apify Proxy only if your run is blocked.

## Actor input object example

```json
{
  "keywords": [
    "nintendo switch"
  ],
  "startUrls": [
    {
      "url": "https://jp.mercari.com/search?keyword=nintendo"
    }
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "keywords": [
        "nintendo switch"
    ],
    "startUrls": [
        {
            "url": "https://jp.mercari.com/search?keyword=nintendo"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/mercari-japan-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": ["nintendo switch"],
    "startUrls": [{ "url": "https://jp.mercari.com/search?keyword=nintendo" }],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/mercari-japan-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": [
    "nintendo switch"
  ],
  "startUrls": [
    {
      "url": "https://jp.mercari.com/search?keyword=nintendo"
    }
  ]
}' |
apify call automation-lab/mercari-japan-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mercari Japan Listings Scraper",
        "description": "🛒 Scrape public Mercari Japan listings with prices, status, item URLs, images, and IDs for resale research.",
        "version": "0.1",
        "x-build-id": "6PedouLdKU0gSUBke"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~mercari-japan-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-mercari-japan-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/automation-lab~mercari-japan-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-mercari-japan-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/automation-lab~mercari-japan-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-mercari-japan-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": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Mercari Japan search keywords. Each keyword is converted to https://jp.mercari.com/search?keyword=...",
                        "default": [
                            "nintendo switch"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Mercari Japan search URLs",
                        "type": "array",
                        "description": "Public Mercari Japan search/category URLs to scrape, for example https://jp.mercari.com/search?keyword=nintendo",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of listings to save across all keywords and URLs.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy configuration. Leave disabled for the cheapest first run; enable Apify Proxy only if your run is blocked.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```