# Target Reviews Scraper (`fetch_cat/target-reviews-scraper`) Actor

Scrape public Target product reviews, star ratings, recommendation signals, review text, authors, and dates from product URLs or TCINs.

- **URL**: https://apify.com/fetch\_cat/target-reviews-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / 1,000 review saveds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Target Reviews Scraper

Export public Target product reviews from product URLs or TCIN item IDs, including star ratings, review text, authors, recommendation signals, helpful votes, dates, and product summary fields.

Use this Actor when you need a repeatable CSV, JSON, Excel, API, or AI-agent export of Target customer feedback for ecommerce research, product quality analysis, brand monitoring, or review intelligence.

### What Does Target Reviews Scraper Do?

Target Reviews Scraper turns public Target review pages into structured review rows.

- **Scrape by product URL**: paste one or more Target product URLs.
- **Scrape by TCIN**: use Target item IDs directly when you already have them.
- **Collect review details**: export rating, review title, review text, author nickname, date, recommendation status, helpful votes, and verified-purchaser signals.
- **Include product context**: repeat product URL, TCIN, title, brand, average rating, review count, and recommendation percentage on each row.
- **Sort reviews**: request most recent, highest rating, or lowest rating reviews.

### Ready-to-run examples

- [Scrape Recent Target AirPods Reviews](https://apify.com/fetch_cat/target-reviews-scraper/examples/scrape-recent-target-airpods-reviews)
- [Scrape Target Reviews By TCIN](https://apify.com/fetch_cat/target-reviews-scraper/examples/scrape-target-reviews-by-tcin)
- [Monitor Target Product Feedback](https://apify.com/fetch_cat/target-reviews-scraper/examples/monitor-target-product-feedback)
- [Find Lowest Rated Target Product Reviews](https://apify.com/fetch_cat/target-reviews-scraper/examples/find-lowest-rated-target-product-reviews)
- [Find Highest Rated Target Product Reviews](https://apify.com/fetch_cat/target-reviews-scraper/examples/find-highest-rated-target-product-reviews)
- [Build AI Dataset From Target Reviews](https://apify.com/fetch_cat/target-reviews-scraper/examples/build-ai-dataset-from-target-reviews)

### Input Example

```json
{
  "startUrls": [
    {
      "url": "https://www.target.com/p/apple-airpods-pro-2nd-generation-with-magsafe-case-usb-c/-/A-85978622"
    }
  ],
  "maxReviews": 25,
  "sortBy": "most_recent"
}
````

You can also run by TCIN:

```json
{
  "tcins": ["85978622"],
  "maxReviews": 50,
  "sortBy": "lowest_rating"
}
```

### Output Example

```json
{
  "productUrl": "https://www.target.com/p/example/-/A-85978622",
  "tcin": "85978622",
  "productTitle": "Example Product",
  "brand": "Example Brand",
  "averageRating": 4.6,
  "ratingCount": 1240,
  "reviewCount": 1180,
  "recommendedPercentage": 91,
  "reviewId": "abc123",
  "reviewTitle": "Great sound quality",
  "reviewText": "Easy to use and good battery life.",
  "rating": 5,
  "authorNickname": "target_customer",
  "submittedAt": "2026-07-01",
  "isRecommended": true,
  "helpfulVotes": 12,
  "verifiedPurchaser": true,
  "isSyndicated": false,
  "dataSourceName": "Target",
  "sortBy": "most_recent",
  "scrapedAt": "2026-07-07T10:00:00.000Z"
}
```

### Who Is It For?

| User | Use case |
| --- | --- |
| Ecommerce teams | Monitor product feedback and recurring customer complaints. |
| Brands | Track ratings, review text, recommendation signals, and verified-purchase feedback. |
| Market researchers | Compare products, categories, sentiment themes, and rating distributions. |
| Data teams | Export Target reviews to spreadsheets, BI tools, warehouses, or AI pipelines. |
| AI agents | Run review exports through Apify API or MCP and summarize customer themes. |

### Input Settings

| Setting | JSON key | What it does |
| --- | --- | --- |
| Target product URLs | `startUrls` | One or more Target product URLs. URLs containing `/A-12345678` are supported. |
| Target TCIN item IDs | `tcins` | Optional Target item IDs, such as `85978622`. Use this when you already have item IDs. |
| Maximum reviews | `maxReviews` | Maximum review rows to save across all products. |
| Review sort order | `sortBy` | Use `most_recent`, `highest_rating`, or `lowest_rating`. |
| Proxy configuration | `proxyConfiguration` | Optional Apify Proxy settings. Leave default unless Target blocks your run. |

### Output Fields

| Field | Description |
| --- | --- |
| `productUrl`, `tcin` | Target product URL and item ID. |
| `productTitle`, `brand` | Product name and brand when available. |
| `averageRating`, `ratingCount`, `reviewCount` | Product-level rating summary fields. |
| `recommendedCount`, `notRecommendedCount`, `recommendedPercentage` | Product-level recommendation signals. |
| `reviewId` | Review identifier. |
| `reviewTitle`, `reviewText` | Review headline and body text. |
| `rating` | Star rating for the review. |
| `authorNickname` | Public reviewer nickname when available. |
| `submittedAt` | Review submission date. |
| `isRecommended` | Whether the reviewer recommends the product. |
| `helpfulVotes`, `notHelpfulVotes` | Review helpfulness counts. |
| `verifiedPurchaser` | Whether Target marks the reviewer as a verified purchaser. |
| `isSyndicated`, `dataSourceName` | Source metadata for syndicated or external review content. |
| `sortBy`, `scrapedAt` | Sort mode used and timestamp when the row was saved. |

### Pricing

This Actor uses pay-per-event pricing.

| Event | Price |
| --- | --- |
| Run started | `$0.005` per run |
| Item extracted | BRONZE tier: `$0.000024924` per saved review row, about `$0.025` per 1,000 rows |

The exact item price depends on your Apify plan tier. Runs that save fewer rows still include the one-time run-start event.

### Tips For Better Results

- **Use TCINs for stable inputs**: product URLs are convenient, but TCINs are the cleanest identifier.
- **Start with 20-50 reviews**: test a product before increasing `maxReviews`.
- **Use low-rating sort for issue discovery**: `lowest_rating` is useful for product quality analysis.
- **Use recent sort for monitoring**: `most_recent` is best for recurring scheduled runs.
- **Expect nulls**: Target may omit author, verified status, brand, helpful votes, or recommendation fields for some reviews.

### API Usage

Run the Actor with cURL:

```bash
curl "https://api.apify.com/v2/acts/fetch_cat~target-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"tcins":["85978622"],"maxReviews":25,"sortBy":"most_recent"}'
```

Run from JavaScript:

```javascript
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor("fetch_cat/target-reviews-scraper").call({
  tcins: ["85978622"],
  maxReviews: 25,
  sortBy: "most_recent",
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

### MCP And AI Agents

This Actor works with the official Apify MCP server. Use the focused MCP URL when you want your AI tool to expose only this Actor:

```text
https://mcp.apify.com?tools=fetch_cat/target-reviews-scraper
```

Example prompts:

- "Run Target Reviews Scraper for this TCIN and summarize the most common complaints."
- "Collect the lowest-rated reviews for these Target products and group quality issues."
- "Export recent Target reviews and identify whether verified purchasers mention shipping or sizing."

### Limits And Notes

- The Actor extracts public Target review data; it does not access private customer information.
- Product summary fields are repeated on review rows for easier filtering and grouping.
- Target can return fewer reviews than requested if fewer public reviews are available for the selected sort.
- If Target blocks requests, try Apify Proxy settings and keep runs modest.

### FAQ

#### Can I scrape multiple Target products in one run?

Yes. Add multiple product URLs in `startUrls` or multiple item IDs in `tcins`.

#### Can I export Target reviews to CSV or Excel?

Yes. Export the Apify dataset as CSV, Excel, JSON, XML, or RSS after the run.

#### Can I collect only one-star reviews?

The Actor supports `lowest_rating` sorting. You can export low-rated reviews first, then filter the dataset by `rating`.

#### Does the Actor return product summary rows?

No separate product summary rows are created. Product summary fields are included on each review row.

#### Is this a Target reviews API alternative?

It can be used as an API-style export for public Target reviews through Apify API, datasets, schedules, webhooks, and MCP.

### Related Actors

- [ProductReview.com.au Scraper](https://apify.com/fetch_cat/productreview-com-au-scraper)
- [Steam Reviews Scraper](https://apify.com/fetch_cat/steam-reviews-scraper)
- [Google Shopping Results Scraper](https://apify.com/fetch_cat/google-shopping-results-scraper)
- [Shopify Products Scraper](https://apify.com/fetch_cat/shopify-products-scraper)
- [Poshmark Sold Listings Scraper](https://apify.com/fetch_cat/poshmark-sold-listings-scraper)

### Support

If a run fails or output looks wrong, report the issue from the Actor page and include the Apify run ID or run URL, your input JSON, expected output, actual output, and one reproducible public Target product URL or TCIN.

### Changelog

#### 0.1

- Initial public release.

# Actor input Schema

## `startUrls` (type: `array`):

Paste one or more Target product URLs. URLs containing /A-12345678 are supported.

## `tcins` (type: `array`):

Optional Target item IDs (TCINs), for example 85978622. Use this when you already have item IDs instead of URLs.

## `maxReviews` (type: `integer`):

Maximum number of review rows to save across all products.

## `sortBy` (type: `string`):

Order used when requesting Target reviews.

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

Optional Apify Proxy settings. Leave the default unless Target blocks your run.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.target.com/p/apple-airpods-pro-2nd-generation-with-magsafe-case-usb-c/-/A-85978622"
    }
  ],
  "tcins": [],
  "maxReviews": 20,
  "sortBy": "most_recent",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://www.target.com/p/apple-airpods-pro-2nd-generation-with-magsafe-case-usb-c/-/A-85978622"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/target-reviews-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 = { "startUrls": [{ "url": "https://www.target.com/p/apple-airpods-pro-2nd-generation-with-magsafe-case-usb-c/-/A-85978622" }] }

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/target-reviews-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 '{
  "startUrls": [
    {
      "url": "https://www.target.com/p/apple-airpods-pro-2nd-generation-with-magsafe-case-usb-c/-/A-85978622"
    }
  ]
}' |
apify call fetch_cat/target-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Target Reviews Scraper",
        "description": "Scrape public Target product reviews, star ratings, recommendation signals, review text, authors, and dates from product URLs or TCINs.",
        "version": "0.1",
        "x-build-id": "4dfysfBeq1WwSrEvn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~target-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-target-reviews-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/fetch_cat~target-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-target-reviews-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/fetch_cat~target-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-target-reviews-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",
                "properties": {
                    "startUrls": {
                        "title": "Target product URLs",
                        "type": "array",
                        "description": "Paste one or more Target product URLs. URLs containing /A-12345678 are supported.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "tcins": {
                        "title": "Target TCIN item IDs",
                        "type": "array",
                        "description": "Optional Target item IDs (TCINs), for example 85978622. Use this when you already have item IDs instead of URLs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Maximum reviews",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of review rows to save across all products.",
                        "default": 20
                    },
                    "sortBy": {
                        "title": "Review sort order",
                        "enum": [
                            "most_recent",
                            "highest_rating",
                            "lowest_rating"
                        ],
                        "type": "string",
                        "description": "Order used when requesting Target reviews.",
                        "default": "most_recent"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Leave the default unless Target blocks your run.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
