# Rakuten Japan Email Scraper (`scraperoka/rakuten-japan-email-scraper`) Actor

📧 Rakuten Japan Email Scraper extracts verified contact emails from Rakuten Japan profiles & listings. ⚡ Fast, precise, and built for lead generation, sales outreach, and market research. ✅ Perfect for B2B teams seeking targeted prospects.

- **URL**: https://apify.com/scraperoka/rakuten-japan-email-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

### Rakuten Japan Email Scraper 🎯

Manually collecting seller or business contact emails from Rakuten Japan takes hours and doesn’t scale. **Rakuten Japan Email Scraper** (a Rakuten email extractor) helps you scrape emails from publicly available sources using your keywords and optional email-domain filters—ideal for marketers, recruiters, and growth teams. Use **Rakuten Japan email scraper** to build a Rakuten marketplace email list, then use **Rakuten Japan email lead generation** workflows to move from research to outreach fast. You can generate thousands of structured records in a single run.

---

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "keyword": "marketing",
  "title": "Rakuten Ichiba | Example Shop",
  "description": "Contact us at sales@example.com for business inquiries.",
  "url": "https://www.rakuten.co.jp/example-shop/",
  "email": "sales@example.com"
}
````

**Output Fields**

| Field | Type | What It Tells You |
|---|---|---|
| `keyword` | string | The exact keyword that triggered this result—useful for tracking lead sources |
| `title` | string | null | The listing title text captured alongside the email candidate |
| `description` | string | The extracted text where the email was found, helpful for context in CRM notes |
| `url` | string | null | The page URL associated with the record—ideal for source auditing |
| `email` | string | The actual extracted email address that matches your `customDomains` filter |
| `error_message` | (not present) | Not returned as a field in the output objects pushed by this actor |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Rakuten Japan Email Scraper?

There are many ways to pull contact info from Rakuten Japan—here’s what sets **Rakuten Japan Email Scraper** apart.

#### Keyword-first email extraction

You drive the process with the `keywords` you care about, producing results tied directly to your target themes (great for building a Rakuten seller email scraper outreach list).

#### Custom email-domain filtering

With `customDomains`, you can focus on specific email providers (for example, only business domains you want). This makes the Rakuten Japan email database more relevant and less noisy.

#### Deduplicated emails across runs

The actor deduplicates by email address using an internal `seen_emails` set, so repeated findings don’t flood your dataset—helpful for a clean Rakuten email extractor pipeline.

#### Resilient proxy support

You can configure proxy routing via `proxyConfiguration`, with the actor designed to keep scraping reliable and recover when no results are found using the initial setup.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "keywords": ["marketing", "john"],
  "location": "Tokyo",
  "platform": "Rakuten Japan",
  "customDomains": ["@gmail.com", "@example.com"],
  "proxyConfiguration": {}
}
```

| Parameter | Required | What It Does |
|---|---:|---|
| `keywords` | ✅ | A list of keywords used to find relevant Rakuten Japan email candidates |
| `location` | ⬜ | Adds a location filter to narrow results (leave empty for no location filter) |
| `platform` | ⬜ | Selects the platform. Only `Rakuten Japan` is available |
| `customDomains` | ⬜ | Limits extracted emails to addresses that match the provided domains |
| `proxyConfiguration` | ⬜ | Configure proxies for this Actor run (use Apify Proxy when you want more reliable scraping) |

***

### Core Capabilities

#### Keyword and domain driven targeting

**Rakuten Japan Email Scraper** uses your `keywords` and `customDomains` to concentrate results on contacts that match your outreach criteria—ideal when you’re building a Rakuten Japan lead generation emails list.

#### Structured, integration-ready output

Each output record is pushed with consistent fields: `keyword`, `title`, `description`, `url`, and `email`. That makes Rakuten Japan email extractor results straightforward to import into your CRM or spreadsheet.

#### Built-in deduplication for cleaner lists

The actor tracks `seen_emails` so the same email address isn’t added repeatedly, which helps keep your Rakuten store email finder dataset clean.

#### Resilient scraping flow with fallback behavior

If the initial setup doesn’t produce results, the actor is designed to attempt a fallback approach (while still using your configured proxy preferences when possible). This improves the odds of getting usable contacts from Rakuten product page email extraction runs.

#### Bulk run output in a single dataset

All collected results are pushed at the end of the run using `Actor.push_data(results, charged_event_name="result")`, so you can export once and move on to outreach immediately.

***

### Who Gets the Most Out of This

Here’s how different teams put **Rakuten Japan Email Scraper** to work:

**Growth and outreach teams** use the actor to scrape relevant business contact emails from publicly available Rakuten Japan pages, then assemble a Rakuten Japan outreach email list grouped by the `keywords` that generated each lead.

**B2B marketers and lead researchers** run **Rakuten Japan seller email scraper** jobs with tight `customDomains` filters to reduce noise, helping them focus on email addresses that match their preferred outreach identity (e.g., specific providers or business patterns).

**Recruiters and staffing teams** use the Rakuten email extractor workflow to discover seller-facing or company contact emails for partnerships and communications, speeding up prospect research without manual copy-paste.

**Data analysts and researchers** treat the dataset as a structured evidence trail: `title`, `description`, and `url` provide context while `keyword` and `email` support downstream matching, enrichment, and reporting.

**Developers and automation specialists** integrate **Rakuten Japan email scraper** runs into their pipeline by invoking the actor, then consuming the dataset records programmatically (for example, to feed a lead scoring model or CRM sync).

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Rakuten Japan Email Scraper from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and find “Rakuten Japan Email Scraper”.
2. **Enter your inputs** — set `keywords` (required), and optionally `location`, `customDomains`, and `platform`.
3. **Configure proxy settings** — open `proxyConfiguration` if you want more reliable scraping for your run.
4. **Hit Run and watch the live log** — monitor progress and see errors in the logs if a request fails.
5. **View results in the dataset tab** — exported records contain `keyword`, `title`, `description`, `url`, and `email`.
6. **Export as JSON, CSV, or Excel** — download directly from the Apify dataset.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, **Rakuten Japan Email Scraper** plugs directly into your existing workflow.

You can export results from the dataset tab as **JSON**, **CSV**, or **Excel**. For teams using CRMs and spreadsheets, this is the quickest path from Rakuten Japan business contact email scraper results to action.

For automation and orchestration, you can connect runs via **Apify API** (see https://apify.com/docs/api) and trigger downstream steps using **webhooks**. If you use **Zapier** or **Make**, you can push dataset items into your tools without writing custom code, and you can also set **scheduled runs** for continuous lead list building.

***

### Pricing & Free Trial

Rakuten Japan Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. After that, you typically pay as you go based on Apify platform usage (compute-related billing), so you don’t need to commit to a monthly contract. Exact costs depend on your run settings and usage level, and it’s best to confirm on the official Apify pricing page.

Start for free at [apify.com](https://apify.com) and scale when you’re ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limits & access stability | Supports proxy configuration to improve reliability |
| Proxy failures | Designed to continue collecting results when possible |
| Duplicate emails | Deduplicates extracted emails using internal tracking |
| Missing or sparse matches | Returns only records it can extract into the output fields |
| Error scenarios | Failed requests are logged and the actor continues with other keywords/domains |

**Limitations:** This actor only extracts emails found in publicly available sources and filters them by your `customDomains`. If the target pages don’t include matching emails, you may get fewer results for those keywords.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes—Apify offers a free tier for starting runs. You can use it to test your Rakuten Japan email scraper workflow with your chosen `keywords` and `customDomains`.

#### Do I need to log in to Rakuten Japan to use this?

No. This actor is designed to work with publicly available sources and does not require a Rakuten Japan login.

#### How accurate is the data?

Accuracy depends on what email addresses appear in the publicly available content the actor can access and what matches your `customDomains` filter. The output includes `url` and `description` so you can review context alongside the `email`.

#### How many results can I get per run?

There isn’t a dedicated “max results” input in this actor schema. Results depend on your `keywords`, optional `location`, and how many matching email addresses are discoverable in the publicly available sources.

#### How often is the data updated / how fresh is it?

Freshness is tied to when you run the actor. If you need ongoing updates to your Rakuten marketplace email list, schedule repeated runs.

#### Is this legal? Does it comply with GDPR / CCPA?

You should treat this as a tool for collecting contact data from **publicly available data**. It’s your responsibility to ensure your use complies with applicable laws and platform rules, including GDPR and CCPA.

#### Can I export results to Google Sheets or Excel?

Yes. You can export the dataset directly as **JSON, CSV, or Excel** from the Apify dashboard. From there, you can import into Google Sheets or your preferred CRM tool.

#### Can I run this on a schedule automatically?

Yes. You can use Apify’s scheduling features to run the actor automatically on a cron schedule and keep your Rakuten Japan outreach email list refreshed.

#### Can I access this via API?

Yes. You can call the actor programmatically and retrieve results using the Apify API. Documentation is available at https://apify.com/docs/api.

#### What happens if the actor hits an error?

If a request fails for a specific keyword/domain combination, the actor logs the error and continues processing other combinations. You’ll still get whatever results were successfully extracted into the dataset.

***

### Need Help or Have a Request?

Got a question about Rakuten Japan Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome ideas like batch CSV upload for keywords/domains and a webhook notification when a run completes. We actively maintain this actor based on user feedback to improve reliability and output usefulness.

***

### Disclaimer & Responsible Use

*Rakuten Japan Email Scraper is the fastest, most reliable way to build a Rakuten Japan email database — start your free run today.*

This actor collects **publicly available data** and does not access private accounts, login-gated content, or password-protected pages. You are responsible for ensuring your use complies with GDPR, CCPA, applicable regulations, and Rakuten’s Terms of Service. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

A list of keywords to search for.

## `location` (type: `string`):

Location to filter search results.

## `platform` (type: `string`):

Select platform.

## `customDomains` (type: `array`):

List of custom email domains

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

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "john",
    "marketing"
  ],
  "location": "",
  "platform": "Rakuten Japan",
  "customDomains": [
    "@gmail.com"
  ]
}
```

# 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": [
        "john",
        "marketing"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/rakuten-japan-email-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": [
        "john",
        "marketing",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/rakuten-japan-email-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": [
    "john",
    "marketing"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ]
}' |
apify call scraperoka/rakuten-japan-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Rakuten Japan Email Scraper",
        "description": "📧 Rakuten Japan Email Scraper extracts verified contact emails from Rakuten Japan profiles & listings. ⚡ Fast, precise, and built for lead generation, sales outreach, and market research. ✅ Perfect for B2B teams seeking targeted prospects.",
        "version": "0.0",
        "x-build-id": "vo0ur2FClv5HlQdIb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~rakuten-japan-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-rakuten-japan-email-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/scraperoka~rakuten-japan-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-rakuten-japan-email-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/scraperoka~rakuten-japan-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-rakuten-japan-email-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",
                        "type": "array",
                        "description": "A list of keywords to search for.",
                        "default": [
                            "john",
                            "marketing"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Rakuten Japan"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Rakuten Japan"
                    },
                    "customDomains": {
                        "title": "Custom Email Domains",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxies for this Actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
