# Ebay Email Scraper (`solid-scraper/ebay-email-scraper`) Actor

📧 eBay Email Scraper quickly extracts seller emails from listings using keywords, categories & filters. ✅ Ideal for lead gen, outreach, agencies & sales teams—save time, find targeted contacts fast, and boost your campaigns.

- **URL**: https://apify.com/solid-scraper/ebay-email-scraper.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community)
- **Categories:** Lead generation, Automation, E-commerce
- **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 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/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

### eBay Email Scraper 📬

**eBay Email Scraper** is an automated actor that scrapes email addresses from publicly available eBay-related web content using your provided **keywords** and **custom email domains**. Whether you’re an email lead generator, a marketer building targeted outreach, or a data analyst researching contact patterns, this **eBay email scraper** helps you find relevant contacts faster by turning unstructured web data into structured results—saving you hours of manual work.

---

### Why choose eBay Email Scraper?

| Feature | Benefit |
|---|---|
| ✅ **Keyword-based discovery** | Searches for emails using your `keywords` list so you can focus on what matters |
| ✅ **Custom email domains filter** | Extracts only emails matching the domains you specify in `customDomains` |
| ✅ **Reliability with proxy configuration** | Uses your `proxyConfiguration` to improve scraping stability at runtime |
| ✅ **Fallback logic for resilience** | Includes fallbacks to continue extraction when no emails are found for a query |
| ✅ **Structured JSON output** | Produces consistent records with `keyword`, `title`, `description`, `url`, and `email` |
| ✅ **Scales across batches** | Loops through every keyword and domain combination and collects all unique emails |

---

### Key features

- 🔍 **Keyword + domain targeted extraction**: Uses your `keywords` and `customDomains` to find matching email addresses relevant to your use case (e.g., scrape eBay seller emails)
- 🧩 **Works directly with eBay context**: Uses the `platform` option (currently `eBay`) to keep results focused on eBay content
- 🛡️ **Proxy configuration support**: Lets you configure `proxyConfiguration` for improved reliability (eBay email scraping automation at scale)
- 🔁 **Fallback when no emails are found**: If a run yields no matches, it can switch to an alternative proxy strategy to try again
- 📊 **Deduplicated email results**: Ensures each extracted `email` appears once per actor run (`seen_emails` prevents duplicates)
- 💾 **Clean, structured records**: Outputs one result object per extracted email with context fields like `keyword`, `title`, `description`, and `url`
- ⚙️ **Accepts flexible input**: `keywords` can be provided as a list (and the actor also normalizes if a single string is supplied)

---

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "keywords": ["juicer", "wallet"],
  "location": "",
  "platform": "eBay",
  "customDomains": ["@gmail.com"],
  "proxyConfiguration": {}
}
````

#### Input Fields

| Key | Required | Description |
|---|---:|---|
| `keywords` | ✅ | A list of keywords to search for. The actor uses each keyword to run the email extraction workflow. |
| `location` | ❌ | A single location string to filter search results. Leave it empty (`""`) to not apply a location filter. |
| `platform` | ❌ | Select platform. The only available enum value is `eBay` (default: `eBay`). |
| `customDomains` | ❌ | A list of custom email domains used to filter extracted emails (default includes `@gmail.com`). |
| `proxyConfiguration` | ❌ | Configure proxies for this Actor. Provide an object compatible with the Apify “proxy” editor. |

Notes based on the actor behavior:

- `keywords` is required, while `location`, `platform`, `customDomains`, and `proxyConfiguration` are optional and have defaults.
- `keywords` is treated as a list; if a string is provided, the actor normalizes it into a list internally.

***

### Output

The actor saves all collected results as JSON via `Actor.push_data(results)`.

A result record looks like this:

```json
[
  {
    "keyword": "juicer",
    "title": "Some listing or page title",
    "description": "No data",
    "url": "http://example.com",
    "email": "example@gmail.com"
  }
]
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `keyword` | string | The keyword that produced this email match |
| `title` | string | null | Title text extracted from the source entry (may be missing depending on the item) |
| `description` | string | Extracted text content used to search for email addresses (or `No data`) |
| `url` | string | null | Link URL associated with the extracted entry |
| `email` | string | The extracted email address (filtered by your `customDomains`) |

You can typically export the dataset to JSON/CSV from the Apify Console after the run completes.

***

### How to use eBay Email Scraper (via Apify Console)

1. **Open Apify Console**\
   Log in at https://console.apify.com and go to the **Actors** section.

2. **Find eBay Email Scraper**\
   Search for the actor by its title and open its details page.

3. **Go to the INPUT panel**\
   Use the built-in form to fill in `keywords`, and optionally `location`, `customDomains`, and `proxyConfiguration`.

4. **Set your `keywords`**\
   Add the terms you want to focus on (this is required). This is the foundation for the “scrape eBay seller emails” style workflow.

5. **Optional: narrow by `location`**\
   If you want region-specific leads, enter a location string; otherwise keep `location` empty (`""`).

6. **Optional: filter with `customDomains`**\
   Enter email domains you care about (for example, keep only `@gmail.com`). This is how the actor behaves like an eBay user email finder with domain control.

7. **Optional: configure `proxyConfiguration`**\
   Provide proxy settings if you have them. The actor will use your configuration when provided and also includes fallback behavior if needed.

8. **Run the actor & monitor logs**\
   Start the run and watch for progress logs. The actor processes each keyword and each domain and logs extracted records as they’re found.

9. **Open the OUTPUT dataset and export**\
   After completion, open the dataset in the **OUTPUT** tab and export your results (commonly JSON or CSV).

No coding required—get accurate results in minutes with **eBay Email Scraper**. 🚀

***

### Advanced features & SEO optimization

- 🧠 **Engineered for “eBay email scraper” lead generation workflows**: Uses your keywords and domain filters to support eBay contact email extraction tool use cases like targeted outreach.
- 🌐 **Domain-restricted extraction for cleaner leads**: By filtering against `customDomains`, it behaves like an eBay email harvesting software focused on the domains you choose (useful for finding eBay store email scraper leads).
- 🔁 **Resilience via fallback logic**: If one proxy configuration yields no matches for a query, it can automatically attempt extraction again using an alternative approach.
- 🧾 **Context-rich output for analysis**: Each extracted email includes the originating `keyword`, plus `title`, `description`, and `url` to help analysts understand where the email came from.

***

### Best use cases

- 📈 **Outbound lead generation**: Extract emails to speed up prospecting for brands and sellers you can follow up with via targeted outreach
- 🧑‍💼 **Market research**: Build a dataset of contact points related to specific product/service keywords from eBay-focused public web data
- ✉️ **Email marketing list building**: Collect domain-filtered contacts to create cleaner, segment-ready lead pools using an eBay listing email scraper workflow
- 🏬 **Seller discovery**: Identify eBay seller contact scraper targets tied to product-related keywords for partnership opportunities
- 🔎 **Research & compliance-minded audits**: Analyze which types of listings/pages surface emails for domain-specific studies using eBay contact data scraper outputs
- 💻 **CRM or automation pipelines**: Feed structured JSON records (`keyword`, `email`, `url`, and context fields) into downstream systems for enrichment and deduplication

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `keywords`: array of keywords (default provided in actor input)
  - ✅ `location`: string (empty string supported)
  - ✅ `platform`: string enum (default `eBay`)
  - ✅ `customDomains`: array of email domains (e.g., `@gmail.com`)
  - ✅ `proxyConfiguration`: object using Apify proxy editor format

- **Proxy Support**
  - ✅ Uses your provided `proxyConfiguration` when available
  - ✅ Includes built-in fallback behavior to continue extraction when no emails are found

- **Retry Mechanism**
  - ⚠️ Included resilience via fallback logic (exact retry counts are not specified in the provided source)

- **Dataset Structure**
  - ✅ One dataset record per extracted email
  - ✅ Fields: `keyword`, `title`, `description`, `url`, `email`

- **Rate Limits & Performance**
  - ⚠️ Performance varies by external responsiveness and proxy behavior; the actor processes keyword/domain combinations in nested loops

- **Limitations**
  - ❌ Only extracts emails that match the provided `customDomains` filter
  - ❌ If no matching email content is found for a keyword/domain run, fewer or no results are returned for that combination
  - ❌ Extraction depends on publicly available content; there is no guarantee that every page contains an email

***

### FAQ

#### What does eBay Email Scraper extract?

✅ eBay Email Scraper extracts email addresses that match the domains you provide in `customDomains`. For each extracted email, it also returns context fields like `keyword`, `title`, `description`, and `url`.

#### Do I need to provide keywords?

✅ Yes. `keywords` is required. The actor loops through each keyword and each custom domain you specify to find matching emails.

#### Can I limit results to specific email domains?

✅ Yes. Use `customDomains` to filter what emails are considered valid matches (for example, restricting results to `@gmail.com`).

#### Does it support location targeting?

✅ Yes. If you set `location` to a non-empty string, the actor uses it to filter results. If you leave it empty (`""`), no location filter is applied.

#### What platforms are supported?

✅ The actor input schema defines `platform` with an enum of `eBay`, and the default is `eBay`.

#### Can I use proxies?

✅ Yes. The actor accepts `proxyConfiguration`. If you don’t provide proxy settings, it attempts to proceed using its built-in proxy handling and may use fallback behavior when needed.

#### How do I export the results?

✅ After the run completes, open the **OUTPUT** dataset in Apify Console and export the dataset. The output produced by the actor is a JSON array of result objects.

#### Is this actor compliant with privacy and platform rules?

❌ You are responsible for using the extracted data legally and ethically in line with applicable regulations and platform terms. The actor is designed to work with publicly accessible sources, but compliance requirements (including GDPR/CCPA considerations) are your responsibility.

***

### Support & feature requests

Want to improve eBay Email Scraper or request enhancements for your eBay email scraper workflows? 💡\
Share ideas like CSV export improvements, additional filtering options, or better output shaping.

📧 Contact: <dataforleads@gmail.com>

Your feedback helps shape future iterations of **eBay Email Scraper**.

***

*Get accurate, structured **eBay Email Scraper** results faster—built for keyword-driven email extraction at scale.*

# 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": [
    "juicer",
    "wallet"
  ],
  "location": "",
  "platform": "eBay",
  "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": [
        "juicer",
        "wallet"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/ebay-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": [
        "juicer",
        "wallet",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ebay Email Scraper",
        "description": "📧 eBay Email Scraper quickly extracts seller emails from listings using keywords, categories & filters. ✅ Ideal for lead gen, outreach, agencies & sales teams—save time, find targeted contacts fast, and boost your campaigns.",
        "version": "0.0",
        "x-build-id": "5GgguEN5Z8fgQYtG6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~ebay-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-ebay-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/solid-scraper~ebay-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-ebay-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/solid-scraper~ebay-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-ebay-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": [
                            "juicer",
                            "wallet"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "eBay"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "eBay"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
