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

🚀 Rakuten Japan Email Scraper (rakuten-japan-email-scraper) extracts verified email contacts from Rakuten listings with speed & accuracy. Perfect for B2B outreach, lead generation, and market research. 📩 Enhance campaigns—automate data capture today!

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

## Pricing

from $3.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 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

### **Rakuten** Email Scraper 📱

**Rakuten** Japan Email Scraper allows users to **extract** a wide range of **data** from **Rakuten** Japan's ecommerce platform. This **data** includes customer **contact** information, seller details, and other relevant insights to support business operations.

The scraper is designed to retrieve accurate and up-to-date information, ensuring the reliability of your **data** collection. By using this tool, businesses can access essential **data** for marketing, outreach, and analysis.

The **Rakuten** email **extract**or is capable of gathering structured **data** that can be used to create targeted campaigns and improve customer engagement. It is an ideal solution for businesses operating in the Japanese ecommerce market, offering efficiency and precision in **data** **extract**ion.

Rakuten Japan Email Scraper is a powerful tool designed to help businesses extract valuable contact information from Rakuten Japan's ecommerce platform. It simplifies the process of gathering customer emails and other essential data for marketing and outreach purposes.

Rakuten is one of Japan's largest online shopping platforms, hosting millions of products and sellers. With the Rakuten Japan Email Scraper, you can efficiently collect data to enhance your business strategies and customer engagement.

This Japan email scraping tool is ideal for businesses looking to expand their reach in the Japanese ecommerce market. It provides accurate and reliable data extraction to support your marketing campaigns.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Customer emails | Extract verified customer email addresses for outreach and marketing purposes. |
| Seller contact information | Retrieve seller contact details including email addresses and phone numbers. |
| Product listings | Collect data on product titles, descriptions, and pricing information. |
| Customer reviews | Gather customer reviews and ratings for product analysis. |
| Seller ratings | Extract seller ratings and feedback for performance evaluation. |
| Category data | Retrieve product categories and subcategories for better classification. |
| Order details | Extract order history and transaction data for analysis. |
| Promotional offers | Collect details on discounts and promotional campaigns listed on Rakuten. |

### Key Features of **Rakuten** Email Scraper

Here are the **standout features** that make the **Rakuten** Email Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ **Automated** extraction of **Rakuten** Japan customer emails for faster data collection
- ⭐ **Accurate** and reliable data retrieval to ensure high-quality results
- ⭐ Ability to extract multiple data types including seller information and product listings
- ⭐ User-friendly interface designed for smooth and efficient operation
- ⭐ **Customizable** scraping settings to meet specific data collection needs
- ⭐ Supports large-scale data extraction for businesses with extensive requirements
- ⭐ **Secure** and compliant data extraction processes to protect user information
- ⭐ Detailed reporting and export options for seamless integration into business workflows
- ⭐ Real-time data updates to ensure the most current information is collected
- ⭐ Optimized for the Japanese ecommerce market providing localized functionality

### How to use **Rakuten** Email Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **Rakuten** emails today:

1. ✅ **Sign up** for an account on the **Rakuten** Japan Email Scraper platform
2. ✅ Log in to your account and navigate to the dashboard
3. ✅ Enter the specific **Rakuten** Japan URL or search query you want to scrape data from
4. ✅ **Configure** the scraping settings such as data types and filters based on your requirements
5. ✅ **Start** the scraping process by clicking the Run button on the dashboard
6. ✅ Monitor the progress of the scraping task through the real-time status updates provided
7. ✅ Once the scraping is complete download the extracted data in your preferred format
8. ✅ Use the exported data for analysis marketing campaigns or other business purposes

### Use Cases 🎯

Marketing Campaigns
🎯 Build targeted email lists for **Rakuten** customers
🎯 Enhance outreach efforts using verified contact information

Product Analysis
🎯 **Analyze** customer reviews and ratings for product improvement
🎯 Monitor competitor offerings and pricing strategies

Seller Performance Evaluation
🎯 Evaluate seller ratings and feedback to identify reliable partners
🎯 **Use** collected data to assess seller credibility

Ecommerce Expansion
🎯 Gather insights to enter the Japanese ecommerce market
🎯 Extract promotional offers and trends to optimize business strategies

### Why choose us? 💎

**Rakuten** Japan Email Scraper is designed to meet the unique needs of businesses operating in the Japanese ecommerce market. Our tool provides accurate and efficient data extraction, ensuring you have access to **reliable** information for your campaigns.

With features like automation and customizable settings, you can streamline your data collection process and save valuable time. We prioritize security and compliance, ensuring your data extraction activities adhere to legal standards.

Our scraper is optimized for **Rakuten** Japan, offering localized functionality that enhances usability and results. Whether you need to extract customer emails, seller information, or product data, our tool delivers seamless performance tailored to your requirements.

Choose **Rakuten** Japan Email Scraper for a **reliable**, **user-friendly**, and efficient solution to your data extraction needs.

### **Rakuten** Email Scraper Scalability 📈

**Rakuten** Japan Email Scraper is built to handle **large-scale** data extraction tasks, making it suitable for businesses of all sizes. Whether you need to collect data from a few pages or thousands of listings, our tool is designed to perform **efficient**ly under varying workloads.

The scraper offers **customizable** settings to meet specific requirements, allowing you to focus on the data that matters most. With real-time updates and robust performance, you can scale your data collection efforts without compromising accuracy or speed.

Our tool is optimized for high-volume operations, ensuring **seamless** integration into your business processes. Experience scalable and reliable data extraction with **Rakuten** Japan Email Scraper, tailored to support your growth in the Japanese ecommerce market.

### **Rakuten** Email Scraper Legal Guidelines ⚖️

**Yes**—scraping **Rakuten** is **legal** as long as you follow **ethical** and **compliant** practices. The **Rakuten** Email Scraper extracts only **publicly available** information from **public** **Rakuten** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with Japanese data protection laws when using **Rakuten** Japan Email Scraper
⚖️ **Do not** use the scraper to extract sensitive or personal data without proper authorization
⚖️ **Avoid** scraping data for malicious or unethical purposes such as spamming or fraud
⚖️ Respect **Rakuten**s terms of service and usage policies during data extraction activities
⚖️ **Use** extracted data responsibly and only for legitimate business purposes
⚖️ **Obtain** consent from individuals where required before using their contact information
⚖️ Regularly review legal updates to ensure your data scraping practices remain compliant
⚖️ Implement security measures to protect the extracted data from unauthorized access

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Rakuten Japan Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Rakuten",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxEmailNumbers | Maximum emails to collect (default 20) |
| platform | Platform to scrape (Rakuten) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Rakuten",
    "keyword": "Rakuten Japan Email Scraper",
    "title": "Google's Single-Benefit Marketing Strategy for Chrome ...",
    "description": "✓For years, once we created a Gmail account, we couldn't change the username (the part before @ gmail.com ). ... Grand Rapids Marketing Co. Read more",
    "url": "https://www.linkedin.com/posts/phill-agnew_heres-how-google-marketed-chrome-browser-activity-7404878510214914048-dLxI",
    "email": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies Rakuten as the source |
| keyword | Keyword that triggered the result (Rakuten Japan Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Rakuten profile link |
| email | Extracted email address |

### FAQ ❓

#### What is Rakuten Japan **Email Scraper**?

Rakuten Japan Email Scraper is a tool designed to extract contact information and other data from Rakuten Japan's ecommerce platform.

#### Can I use this tool for marketing campaigns?

**Yes**, Rakuten Japan Email Scraper helps you build targeted email lists for marketing and outreach purposes.

#### Is the scraper compliant with Japanese laws?

**Yes**, the tool is designed to comply with Japanese data protection regulations when used responsibly.

#### What types of data can I **extract**?

You can extract customer **emails**, seller contact details, product listings, reviews, ratings, and more.

#### How do I start using Rakuten Japan **Email Scraper**?

Sign up for an account, log in, configure your scraping settings, and start the data extraction process.

#### Is the tool suitable for **large-scale** data **extract**ion?

**Yes**, Rakuten Japan Email Scraper is optimized for handling high-volume data extraction tasks efficiently.

#### Can I customize the scraping settings?

**Yes**, the tool allows you to configure filters and settings based on your specific requirements.

#### What formats are available for **export**ing data?

Extracted data can be exported in formats such as **CSV**, Excel, or **JSON**.

#### Does the scraper provide real-time updates?

**Yes**, you can monitor the progress of your scraping tasks with real-time status updates.

#### Is the tool user-friendly?

**Yes**, Rakuten Japan Email Scraper features an intuitive interface for easy operation.

#### Can I **extract** promotional offers from Rakuten?

**Yes**, the tool can collect data on discounts and promotional campaigns listed on Rakuten.

#### Is the scraper **secure**?

**Yes**, Rakuten Japan Email Scraper implements security measures to protect extracted data.

#### Does the tool support localized functionality?

**Yes**, it is optimized for Rakuten Japan and tailored to the Japanese ecommerce market.

#### What happens if Rakuten updates its platform?

Our team regularly updates the scraper to ensure compatibility with Rakuten's platform changes.

#### Can I use the tool for competitor analysis?

**Yes**, you can extract data to monitor competitor pricing and product strategies on Rakuten.

# Actor input Schema

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

List of keywords to search for on Co-Rakuten (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Co-Rakuten profiles/posts containing these keywords and extract email addresses.

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

Select platform.

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

Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.

## `emailDomains` (type: `array`):

Optional: Filter results to only include emails from specific domains (e.g., \['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.

## `maxEmails` (type: `integer`):

Maximum number of emails to collect per keyword (default: 20).

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

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

Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Co-Rakuten",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeengine/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": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapeengine/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 (rakuten-japan-email-scraper) extracts verified email contacts from Rakuten listings with speed & accuracy. Perfect for B2B outreach, lead generation, and market research. 📩 Enhance campaigns—automate data capture today!",
        "version": "0.1",
        "x-build-id": "3WFhQQpciYndMvkZ2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeengine~rakuten-japan-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeengine-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/scrapeengine~rakuten-japan-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeengine-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/scrapeengine~rakuten-japan-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeengine-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": "List of keywords to search for on Co-Rakuten (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Co-Rakuten profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Co-Rakuten"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Co-Rakuten"
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter",
                        "type": "array",
                        "description": "Optional: Filter results to only include emails from specific domains (e.g., ['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect per keyword (default: 20).",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```