# Lazada Email Scraper (`scrapio/lazada-email-scraper`) Actor

Lazada Email Scraper helps you collect seller and brand emails directly from Lazada listings and profiles. Use the data for B2B sales, dropshipping outreach, and marketplace expansion campaigns.

- **URL**: https://apify.com/scrapio/lazada-email-scraper.md
- **Developed by:** [Scrapio](https://apify.com/scrapio) (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

$14.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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

### **Lazada** Email Scraper 📱

The **Lazada** Email Scraper allows you to **extract** a wide range of **data** from **Lazada**'s platform. This includes seller email addresses, store names, and additional **contact** information.

By using this tool, you can build a comprehensive **data**base of **Lazada** sellers for marketing, analysis, or outreach purposes. The **data** **extract**ion process is designed to be accurate and efficient, ensuring you receive up-to-date and relevant information.

With this tool, you can also **extract** product-related details to better understand the sellers' offerings. Whether you are a marketer, researcher, or business owner, this tool provides the essential **data** you need to achieve your goals.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.scrapio@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Seller Email Addresses | Extract verified email addresses of Lazada sellers for direct communication. |
| Store Names | Retrieve the names of Lazada stores for identification and categorization. |
| Contact Numbers | Access available phone numbers associated with Lazada sellers. |
| Product Listings | Collect details about the products listed by Lazada sellers. |
| Seller Ratings | Extract seller ratings to evaluate their reputation and performance. |
| Location Data | Gather location information of Lazada sellers for regional analysis. |
| Social Media Links | Retrieve any linked social media profiles of Lazada sellers. |
| Business Descriptions | Extract descriptions or overviews provided by sellers about their businesses. |

### Key Features of **Lazada** Email Scraper

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

- ⭐ Effortlessly extract email addresses of **Lazada** sellers in bulk
- ⭐ Retrieve additional contact details such as phone numbers and social media links
- ⭐ **Accurate** and up-to-date data extraction from **Lazada**s platform
- ⭐ User-friendly interface requiring no technical expertise
- ⭐ **Customizable** scraping options to target specific seller data
- ⭐ **High**-speed data extraction to save time and maximize efficiency
- ⭐ Supports large-scale data collection for extensive projects
- ⭐ **Secure** and compliant with ethical scraping standards
- ⭐ Detailed logs and reports for transparency and tracking
- ⭐ **Automated** scheduling for regular data extraction tasks
- ⭐ Seamless integration with other tools and databases
- ⭐ Reliable customer support to assist with any issues

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

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

1. ✅ **Sign up** or **log in** to your Apify account
2. ✅ Search for the **Lazada** Email Scraper in the Apify library
3. ✅ Click on the scraper and select the Try for Free option or subscribe to a plan
4. ✅ **Configure** the scraper settings including target keywords and filters
5. ✅ Enter the URLs or categories you want to scrape from **Lazada**
6. ✅ Run the scraper and monitor the progress in real-time
7. ✅ Download the extracted data in your preferred format such as CSV or JSON
8. ✅ Analyze the collected data for your business or marketing needs

### Use Cases 🎯

Marketing and Outreach
🎯 Build a targeted email list of **Lazada** sellers for marketing campaigns
🎯 **Identify** potential business partners or collaborators on **Lazada**

Market Research
🎯 **Analyze** seller data to understand market trends and competition
🎯 Gather insights on product offerings and pricing strategies

Business Expansion
🎯 **Identify** top-performing sellers for potential partnerships
🎯 Expand your network by connecting with **Lazada** sellers in new regions

Data Analysis
🎯 Evaluate seller ratings and reviews for quality assessment
🎯 **Study** location data to identify regional business opportunities

### Why choose us? 💎

Our **Lazada** Email Scraper is designed with precision and efficiency in mind. It offers businesses a **reliable** way to extract valuable contact information from **Lazada** sellers without manual effort.

With its **user-friendly** interface, even non-technical users can easily navigate and utilize the tool. The scraper is highly customizable, allowing you to tailor the data extraction process to your specific needs.

Whether you need a **Lazada** email extraction tool for marketing, research, or outreach, our software delivers accurate and up-to-date results. We prioritize security and compliance, ensuring that your data extraction activities align with ethical standards.

Our dedicated customer support team is always available to assist you with any questions or issues. Choose our **Lazada** Email Scraper for a seamless, efficient, and **reliable** data extraction experience.

### **Lazada** Email Scraper Scalability 📈

The **Lazada** Email Scraper is built to handle projects of all sizes, from small-scale data collection to **large-scale** email database extraction. Its robust infrastructure ensures fast and **efficient** performance, even when dealing with **extensive** datasets.

The tool supports automated scheduling, enabling you to run scraping tasks regularly without manual intervention. Whether you need to extract emails from **Lazada** for a single campaign or ongoing projects, our scraper adapts to your requirements.

It is optimized for high-speed processing, ensuring minimal downtime and maximum productivity. Our **Lazada** email scraper software is scalable, making it the best choice for businesses looking to grow and expand their operations.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Lazada**s terms of service when using the scraper
⚖️ **Do not** use the extracted data for spamming or unsolicited communication
⚖️ Respect privacy laws and regulations in your region when handling personal data
⚖️ **Use** the scraper only for legitimate business or research purposes
⚖️ **Avoid** scraping sensitive or restricted information from **Lazada**s platform
⚖️ Always disclose your intentions transparently when contacting sellers
⚖️ Regularly review and update your compliance practices to align with legal standards
⚖️ Seek legal advice if you are unsure about the ethical use of scraped data

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Lazada Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Lazada",
  "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 (Lazada) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Lazada",
    "keyword": "Lazada 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 Lazada as the source |
| keyword | Keyword that triggered the result (Lazada Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Lazada profile link |
| email | Extracted email address |

### FAQ ❓

#### What is Lazada **Email Scraper**?

Lazada Email Scraper is a tool designed to extract email addresses and other contact information from Lazada sellers.

#### Is the scraper easy to use?

**Yes**, the Lazada Email Scraper is **user-friendly** and requires no technical expertise.

#### Can I **extract** data in bulk?

**Yes**, the scraper supports bulk data extraction for large-scale projects.

#### What formats are supported for data **export**?

You can export the extracted data in formats such as **CSV** or **JSON**.

# Actor input Schema

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

List of keywords to search for on Lazada (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Lazada 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": "Lazada",
  "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("scrapio/lazada-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("scrapio/lazada-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 scrapio/lazada-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lazada Email Scraper",
        "description": "Lazada Email Scraper helps you collect seller and brand emails directly from Lazada listings and profiles. Use the data for B2B sales, dropshipping outreach, and marketplace expansion campaigns.",
        "version": "0.1",
        "x-build-id": "GfB33ew9I79HcZ6RG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapio~lazada-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapio-lazada-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/scrapio~lazada-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapio-lazada-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/scrapio~lazada-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapio-lazada-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 Lazada (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Lazada profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Lazada"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Lazada"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```