# Ebay Seller Scraper (`scrapier/ebay-seller-scraper`) Actor

🛒 eBay Seller Scraper extracts seller profiles, store info, active listings, prices, ratings & feedback. 📊 Ideal for competitor analysis, pricing, product research & lead gen. ⚡ Fast, reliable; export CSV/JSON for analytics & automation.

- **URL**: https://apify.com/scrapier/ebay-seller-scraper.md
- **Developed by:** [Scrapier](https://apify.com/scrapier) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

### Ebay Seller Scraper

Ebay Seller Scraper is an Apify actor that extracts public seller profiles, feedback snapshots, and live listing titles with prices from eBay — all in a clean, structured dataset. It solves the repetitive, manual task of checking seller pages by automating data collection across multiple profiles at once. As an eBay seller scraper tool and eBay store scraper, it’s built for marketers, developers, data analysts, and researchers who need to scrape eBay seller listings at scale for competitor analysis, product research, and pricing insights.

### What data / output can you get?

Below are the exact fields the actor saves to the dataset. Each row represents one seller, with an array of their active listing snippets.

| Data type            | Description                                                   | Example value                               |
| -------------------- | ------------------------------------------------------------- | ------------------------------------------- |
| url                  | Normalized seller profile URL                                 | https://www.ebay.co.uk/usr/USERNAME         |
| name                 | Seller username parsed from the page                          | USERNAME                                    |
| feedback_score       | Feedback snapshot text as displayed on the page               | 100%                                        |
| listings[].title     | Listing title text (cleaned for encoding issues)              | Some item                                   |
| listings[].price     | Listing price as displayed (currency/format preserved)        | £10.00                                      |

Notes:
- The actor writes results continuously to the Apify dataset so you can export to CSV or JSON for analytics and automation.  
- Titles and prices are de-duplicated and cleaned for common encoding glitches. Non-relevant “shop on eBay” entries are filtered automatically.

### Key features

- ⚡ Automatic connection fallback
  Direct first, then Apify Proxy fallback: datacenter → residential when a page isn’t available. Keeps runs resilient and reduces manual restarts for your eBay competitor analysis scraper workflows.

- 🧼 Clean, structured output
  Parses embedded JSON and HTML, fixes common text encoding issues, removes duplicates, and filters non-product “shop” entries for a tidy eBay seller data scraper result.

- 📦 Batch scraping & bulk automation
  Feed one or many seller profile URLs via urls and scrape eBay seller listings at scale. Ideal for eBay store inventory scraper tasks and recurring seller watchlists.

- 🔐 No login required
  Works on publicly visible seller pages only — no cookies or account setup needed for your eBay shop scraper use cases.

- 💾 Flexible exports
  Results stream to the Apify dataset so you can export as JSON or CSV for dashboards, enrichment, and pipelines using your favorite tools.

- 👨‍💻 Developer-friendly
  Built on the Apify platform with Python requests and BeautifulSoup parsing. Integrate with the Apify API or your stack to power eBay seller analytics software and automation.

- 📈 Reliable, production-ready behavior
  Realistic headers, 1–2s randomized delays between requests, and proxy fallback improve stability for large batches and ongoing eBay seller research tool operations.

### How to use Ebay Seller Scraper — step by step

1. Sign in to your Apify account.
2. Open the “Ebay Seller Scraper” actor.
3. Add input data:
   - Paste one or more seller profile links into urls. Use one URL per line in the string list editor (e.g., https://www.ebay.co.uk/usr/your_seller_name).
4. (Optional) Configure proxyConfiguration:
   - Choose No proxy for normal runs, or enable Apify Proxy and select a Datacenter or Residential group. You can also provide your Own proxies.
5. Start the run.
6. Watch progress in the run logs. The actor saves each seller as soon as it’s parsed, and you’ll see status updates as rows are added.
7. Export results. Go to the Output (dataset) and download JSON or CSV for further analysis or automation.

Pro Tip: Trigger runs via the Apify API and wire the dataset export into Make, n8n, or your data warehouse to automate recurring eBay seller listings scraper workflows end-to-end.

### Use cases

| Use case name | Description |
| --- | --- |
| Market research for eCommerce | Benchmark pricing and product positioning by exporting seller listings to CSV/JSON for quick comparison across categories. |
| Competitor monitoring for eBay stores | Track competitor assortments and price changes using an eBay competitor analysis scraper workflow on a schedule. |
| Product research & assortment planning | Identify trending titles and price points with an eBay seller product extractor to inform your catalog. |
| Lead generation for B2B sellers | Build watchlists of active sellers by category and export for outreach campaigns and partnerships. |
| Analytics dashboards | Feed structured rows to your BI stack as an eBay seller analytics software dataset for KPI tracking. |
| Automation pipelines (API) | Orchestrate runs via the Apify API and route outputs into CRMs or internal tools for ongoing enrichment. |
| Academic & policy research | Collect public seller data consistently for studies on pricing, availability, and marketplace dynamics. |

### Why choose Ebay Seller Scraper?

Ebay Seller Scraper is built for precision, automation, and reliability — a focused eBay store data extractor that’s ready for production use.

- 🎯 Accurate parsing: Extracts ownerUsername and feedback snapshots from embedded JSON with HTML fallbacks for titles and prices.
- 🌍 Public-only data: Uses only data visible to buyers on seller pages; no login or cookies.
- 🚀 Scales with your needs: Submit many urls in a single run to automate bulk collection.
- 🧰 Developer access: Apify-native actor with dataset outputs for JSON/CSV exports and API-driven workflows.
- 🧱 Robust vs. extensions: Avoid brittle browser plugins; rely on realistic headers, retry logic, 1–2s randomized delays, and proxy fallback.
- 💡 Integration-ready: Connect dataset exports to your tooling for repeatable eBay seller research tool pipelines.
- 💸 Cost-effective: Export only the structured fields you need for analysis and automation.

In short, it’s the eBay seller listings scraper you can depend on — not a fragile one-off script.

### Is it legal / ethical to use Ebay Seller Scraper?

Yes — when used responsibly. This actor only collects publicly visible information from eBay seller pages. It does not log in or access private data.

Guidelines:
- Scrape public pages only and avoid accessing personal or private data.
- Review and comply with eBay’s terms and your local regulations (e.g., GDPR/CCPA).
- Use the data responsibly for analysis, research, or operations — not for spam or misuse.
- Consult your legal team for edge cases or jurisdiction-specific requirements.

### Input parameters & output format

Example JSON input
```json
{
  "urls": [
    "https://www.ebay.co.uk/usr/chrisjoh7639"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

Parameters

- urls (array, required)
  - Description: Add your targets here. One URL per line — supports a single seller or a whole list for bulk runs. Example format: https://www.ebay.co.uk/usr/your\_seller\_name Tip: Copy the link from the seller’s “About” page or profile header on eBay.
  - Prefill: \["https://www.ebay.co.uk/usr/chrisjoh7639"]
  - Default: none

- proxyConfiguration (object, optional)
  - Description: You can skip this section — the actor works with seller URLs only. If you open this block: choose No proxy for normal runs, or turn on Apify Proxy (Datacenter / Residential), or add your Own proxies. Do not select Own proxies and leave it empty — pick No proxy instead.
  - Prefill: { "useApifyProxy": false }
  - Default: none

Example JSON output

```json
{
  "url": "https://www.ebay.co.uk/usr/USERNAME",
  "name": "USERNAME",
  "feedback_score": "100%",
  "listings": [
    { "title": "Some item", "price": "£10.00" }
  ]
}
```

Notes:

- If specific fields aren’t present on the page, name and feedback\_score may be empty strings and listings may be an empty array.
- Titles and prices are cleaned for encoding issues; duplicate (title, price) pairs are removed.

### FAQ

#### Do I need an eBay login or API key to use this?

No. The actor only accesses publicly visible seller pages and does not require login, cookies, or private API keys. It functions as an eBay seller scraper tool without authentication.

#### What seller data does the actor extract?

It saves url, name, feedback\_score, and an array of listings with title and price. These fields are written to the dataset for easy export as CSV or JSON.

#### Can I scrape many sellers in one run?

Yes. Provide multiple profile links in urls to run bulk collection. This is ideal for eBay store scraper and eBay seller research tool workflows at scale.

#### How does proxy handling work?

By default the actor tries direct connections. If a page isn’t available, it automatically falls back to Apify Proxy groups in tiers: DATACENTER → RESIDENTIAL. You can also configure proxyConfiguration explicitly.

#### How fast does it run and does it avoid blocks?

The actor uses realistic headers and a randomized 1–2 second delay between requests. Combined with the connection fallback, this improves reliability for eBay seller API scraping style pipelines.

#### What formats can I export?

All results stream to an Apify dataset. From there, you can export JSON or CSV to feed dashboards, BI tools, and automations in your eBay seller analytics software stack.

#### Does it work for all eBay domains?

The actor queries the ebay.co.uk search endpoint and normalizes seller profile URLs to https://www.ebay.co.uk/usr/{username}. Provide seller profile links in that format for best results.

#### Will it capture all listings and currencies?

The actor collects visible listing titles and prices as displayed. It filters non-relevant “shop” entries and, in fallback parsing, may exclude certain currency patterns to keep results consistent. Currency symbols are preserved as shown on the page.

### Final thoughts

Ebay Seller Scraper is built to turn public eBay seller pages into clean, structured data for analysis and automation. With automatic proxy fallback, batch inputs, and ready-to-export datasets, it’s ideal for marketers, developers, analysts, and researchers who need reliable eBay store data extraction. Integrate it with the Apify API to automate recurring runs and feed JSON/CSV into your analytics or CRM. Start extracting smarter seller insights and streamline your eBay competitor and product research workflows today.

# Actor input Schema

## `urls` (type: `array`):

📋 **Add your targets here.** One URL per line — supports a single seller or a whole list for bulk runs.

✅ Example format: `https://www.ebay.co.uk/usr/your_seller_name`

💡 Tip: Copy the link from the seller’s “About” page or profile header on eBay.

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

🌐 **You can skip this section** — the actor works with seller URLs only.

If you open this block:

- ✅ Choose **No proxy** for normal runs, **or**
- ✅ Turn on **Apify Proxy** and pick a group (Datacenter / Residential), **or**
- ✅ Add your own proxy URLs under **Own proxies**.

⚠️ **Do not** select **Own proxies** and leave it empty — Apify will show a validation error. Pick **No proxy** instead.

## Actor input object example

```json
{
  "urls": [
    "https://www.ebay.co.uk/usr/chrisjoh7639"
  ],
  "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 = {
    "urls": [
        "https://www.ebay.co.uk/usr/chrisjoh7639"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapier/ebay-seller-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 = {
    "urls": ["https://www.ebay.co.uk/usr/chrisjoh7639"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapier/ebay-seller-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 '{
  "urls": [
    "https://www.ebay.co.uk/usr/chrisjoh7639"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapier/ebay-seller-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ebay Seller Scraper",
        "description": "🛒 eBay Seller Scraper extracts seller profiles, store info, active listings, prices, ratings & feedback. 📊 Ideal for competitor analysis, pricing, product research & lead gen. ⚡ Fast, reliable; export CSV/JSON for analytics & automation.",
        "version": "0.1",
        "x-build-id": "LYJgIObMYYqcQ9IqQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapier~ebay-seller-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapier-ebay-seller-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/scrapier~ebay-seller-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapier-ebay-seller-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/scrapier~ebay-seller-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapier-ebay-seller-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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "🔗 Seller profile URLs",
                        "type": "array",
                        "description": "📋 **Add your targets here.** One URL per line — supports a single seller or a whole list for bulk runs.\n\n✅ Example format: `https://www.ebay.co.uk/usr/your_seller_name`\n\n💡 Tip: Copy the link from the seller’s “About” page or profile header on eBay.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "🛡️ Proxy & connection (optional)",
                        "type": "object",
                        "description": "🌐 **You can skip this section** — the actor works with seller URLs only.\n\nIf you open this block:\n- ✅ Choose **No proxy** for normal runs, **or**\n- ✅ Turn on **Apify Proxy** and pick a group (Datacenter / Residential), **or**\n- ✅ Add your own proxy URLs under **Own proxies**.\n\n⚠️ **Do not** select **Own proxies** and leave it empty — Apify will show a validation error. Pick **No proxy** instead."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```