# Reddit Trends Scraper (`simpleapi/reddit-trends-scraper`) Actor

Reddit Trends Scraper provides clean data on trending Reddit topics and discussions. Track popular posts, engagement patterns, and subreddit activity to uncover insights for marketing, research, and content planning.

- **URL**: https://apify.com/simpleapi/reddit-trends-scraper.md
- **Developed by:** [SimpleAPI](https://apify.com/simpleapi) (community)
- **Categories:** Social media, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

Reddit Trends Scraper helps you uncover real-time Reddit discussions, trending posts, and viral topics with ease 🚀. By extracting high-engagement data from subreddits, it empowers SEO professionals, marketers, and researchers to spot emerging trends early and make data-driven decisions using clean, ready Reddit insights.

### 🚀 What is Reddit Trends Scraper?

Reddit Trends Scraper is a powerful data extraction tool designed to identify trending topics, posts, subreddits, and discussions across Reddit in real time 📊. It helps marketers, researchers, and businesses uncover what people are talking about right now—without manual browsing.

By using a Reddit trends scraper online, you can collect high-performing posts, upvote counts, comment activity, and timestamps to understand audience intent and emerging trends. This makes it extremely valuable for SEO, content ideation, competitor research, and market analysis.

Whether you’re using a Reddit scraper API, Reddit scraper Python, or an Apify Reddit Scraper, this tool saves time, scales effortlessly, and delivers actionable insights. Even better, many users look for a Reddit trends scraper free option to test ideas quickly ⚡.

* * *

### 📊 What can you extract with Reddit Trends Scraper?

With Reddit Trends Scraper, you can extract a wide range of valuable Reddit data that fuels content strategy, SEO optimization, and trend analysis 🔍.

#### 🗂️ Extractable Data Types

| Data Type | Description |
| --- | --- |
| 🔥 Trending Posts | Most upvoted and fastest-growing Reddit posts |
| 📌 Subreddit Names | Source communities where trends originate |
| 👍 Upvotes | Popularity indicator for posts |
| 💬 Comment Count | Engagement level of each post |
| 🧵 Reddit Comments | Extract full discussions using reddit comment scraper |
| 🕒 Post Timestamp | Track when trends start and peak |
| 🧑 Author Username | Identify influencers or frequent contributors |
| 🔗 Post URL | Direct link for analysis or sharing |
| 🏷️ Keywords & Topics | Core themes driving Reddit trends |

This data can be collected via reddit scraper API, reddit scraper Python, reddit scraper GitHub, or Apify-Reddit scraper integrations—making it flexible for both technical and non-technical users.

* * *

#### ✨ Key Features of Reddit Trends Scraper

Reddit Trends Scraper is built for speed, scalability, and accuracy 💡. Below are the standout features that make it a top choice:

*   🚀 Real-Time Trend Detection – Identify trending Reddit topics before they go mainstream  
      
    
*   🧠 NLP-Optimized Data – Extract clean, structured data ideal for AI and NLP analysis  
      
    
*   🔗 API Access – Seamless integration via Reddit scraper API  
      
    
*   🐍 Python-Friendly – Perfect for developers using Reddit scraper Python  
      
    
*   🧩 Automation Ready – Works smoothly with reddit scraper n8n workflows  
      
    
*   🌐 Apify Reddit Scraper Support – Cloud-based scraping with high reliability  
      
    
*   🆓 Free Usage Options – Try Reddit trends scraper free plans  
      
    
*   🧾 Comment-Level Scraping – Advanced reddit comment scraper support  
      
    
*   🧑‍💻 GitHub Compatible – Easy adoption for users searching reddit scraper GitHub  
      
    

This combination of features ensures high-quality trend intelligence without complexity.

* * *

### 🛠️ How to use Reddit Trends Scraper

Getting started with Reddit Trends Scraper is simple—even if you’re not a developer 👌. Follow this step-by-step guide:

#### 🔢 Step-by-Step Guide

1.  Log in to Apify  
      
    

*   Create a free account or sign in to access the platform 🔐  
      
    

3.  Select the Actor  
      
    

*   Search for “Reddit Trends Scraper” or Apify Reddit Scraper in the store  
      
    

5.  Enter Input Data  
      
    

*   Add subreddit names, keywords, or trend filters  
      
    

7.  Choose Options  
      
    

*   Select post limits, comment depth, and sorting (hot, new, top)  
      
    

9.  Run the Actor  
      
    

*   Click start and let the scraper collect trending Reddit data ⚙️  
      
    

11.  Download Results  
      
    

*   Export data in JSON, CSV, or via reddit scraper API  
      
    

This workflow also supports reddit scraper extension and reddit scraper n8n automation.

* * *

### 🎯 Use Cases

Reddit Trends Scraper is widely used across industries 🌍. Here’s how professionals apply it:

*   📈 SEO & Content Marketing – Discover high-intent topics before competitors  
      
    
*   🧠 Market Research – Analyze consumer pain points from real discussions  
      
    
*   📢 Product Validation – Test ideas using trending Reddit conversations  
      
    
*   🤖 AI & NLP Training – Use structured data for sentiment analysis  
      
    
*   📰 Journalism & Media – Spot breaking stories early  
      
    
*   🛍️ Ecommerce Insights – Track product demand and feedback  
      
    

Whether you need a Reddit trends scraper online or a Reddit scraper free solution, the use cases are endless.

* * *

### ⭐ Why choose us?

We don’t just offer a scraper—we deliver trend intelligence 🧠.

*   ✅ Trusted Apify Infrastructure  
      
    
*   🔒 Ethical & Compliant Data Collection  
      
    
*   ⚡ High-Speed Performance at Scale  
      
    
*   🧩 Flexible API & Automation Support  
      
    
*   🆓 Free & Paid Plans Available  
      
    
*   💬 Dedicated Support Team  
      
    

From Reddit scraper GitHub users to enterprise clients using Reddit scraper API, we’re built for everyone.

* * *

### 📈 How many results can you scrape with Reddit Trends Scraper?

Reddit Trends Scraper is designed to scale effortlessly—from small experiments to enterprise-grade data extraction 🚀.

You can scrape hundreds to thousands of trending Reddit posts per run, depending on your configuration. With Apify Reddit Scraper, scalability is handled in the cloud, ensuring consistent performance even during peak usage.

#### 🔧 Scalability Highlights

*   🔁 Unlimited runs with automation  
      
    
*   📊 Thousands of posts & comments per job  
      
    
*   ⚙️ Adjustable rate limits for safety  
      
    
*   🔌 API-based continuous data collection  
      
    
*   🧠 Ideal for long-term trend monitoring  
      
    

Whether you’re running a Reddit trends scraper free test or a full reddit scraper API pipeline, performance remains reliable and efficient.

* * *

### ⚖️ Is it legal to scrape Reddit?

Scraping Reddit data is a gray area that depends on usage, compliance, and intent ⚠️.

#### ✅ Best Practices

*   Follow Reddit’s Terms of Service  
      
    
*   Avoid private or restricted content  
      
    
*   Respect rate limits and ethical usage  
      
    
*   Use data for research, analysis, and insights  
      
    

Tools like Reddit Trends Scraper, Apify-Reddit scraper, and reddit scraper API are designed to support responsible and compliant scraping.

* * *

### 🧩 Input Parameters

#### 📥 Example Input JSON
```json
{
    "proxyConfiguration": {
        "useApifyProxy": false
    },
    "startUrls": [
        "https://old.reddit.com/r/popular/"
    ]
}
````

### 📤 Output Format

#### 📦 Example Output JSON

```json
 {
    "title": "Superman (1948) used animation before CGI was invented.",
    "postUrl": "https://reddit.com/r/Damnthatsinteresting/comments/1psslfh/superman_1948_used_animation_before_cgi_was/",
    "upvotes": 0,
    "comments": 254,
    "subreddit": "r/Damnthatsinteresting",
    "subredditUrl": "https://reddit.com/r/Damnthatsinteresting/",
    "subredditType": "link",
    "author": "helveticanuu",
    "authorProfile": "https://reddit.com/user/helveticanuu",
    "postTime": "2025-12-22 06:29:29"
  },
```

### ❓ FAQ – Reddit Trends Scraper

#### 1. Is Reddit Trends Scraper free?

Yes, you can start with a Reddit trends scraper free plan.

#### 2. Does it support Python?

Absolutely—perfect for Reddit scraper Python workflows 🐍.

#### 3. Is there an API available?

Yes, use the Reddit scraper API for automation.

#### 4. Can I scrape comments?

Yes, built-in reddit comment scraper support.

#### 5. Does it work with Apify?

Yes, it’s fully compatible with Apify Reddit Scraper.

#### 6. Can I automate with n8n?

Yes, integrate easily using reddit scraper n8n.

#### 7. Is GitHub supported?

Many users deploy via reddit scraper GitHub repositories.

### ✅ Conclusion

With Reddit Trends Scraper, tracking Reddit trends becomes fast, scalable, and reliable 📊. Whether you need a Reddit trends scraper free, API-based automation, or Python integration, this tool delivers actionable insights at scale. Stay ahead of competitors, validate ideas, and turn Reddit conversations into powerful growth opportunities.

***

✨ Reddit Trends Scraper is your all-in-one solution for discovering what’s trending on Reddit—fast, scalable, and SEO-ready.

### What are other Reddit scraping tools?

If you want to scrape specific Reddit data, you can use any of the dedicated scrapers below for faster and more targeted results.

| Scraper Name | Scraper Name |
|---|---|
| [Reddit API Scraper](https://apify.com/simpleapi/reddit-api-scraper) | [Reddit Posts Scraper](https://apify.com/simpleapi/reddit-posts-scraper) |
| [Reddit Comments Scraper](https://apify.com/simpleapi/reddit-comments-scraper) | [Reddit Scraper](https://apify.com/simpleapi/reddit-scraper) |
| [Reddit Email Scraper](https://apify.com/simpleapi/reddit-email-scraper) | [Reddit Subreddit Members Scraper](https://apify.com/simpleapi/reddit-subreddit-members-scraper) |
| [Reddit Lead Scraper](https://apify.com/simpleapi/reddit-lead-scraper) | [Reddit User Profile Posts And Comments Scraper](https://apify.com/simpleapi/reddit-user-profile-posts-and-comments-scraper) |
| [Reddit Phone Number Scraper](https://apify.com/simpleapi/reddit-phone-number-scraper) |  |

# Actor input Schema

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

List of Reddit URLs (e.g., https://old.reddit.com/r/popular/), usernames (e.g., username), or keywords to search. Supports bulk input.

## `maxPosts` (type: `integer`):

Maximum number of posts to scrape

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

Choose which proxies to use. The actor will automatically fallback: no proxy → datacenter → residential (with 3 retries).

## Actor input object example

```json
{
  "startUrls": [
    "https://old.reddit.com/r/popular/"
  ],
  "maxPosts": 20,
  "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 = {
    "startUrls": [
        "https://old.reddit.com/r/popular/"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("simpleapi/reddit-trends-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": ["https://old.reddit.com/r/popular/"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("simpleapi/reddit-trends-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": [
    "https://old.reddit.com/r/popular/"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call simpleapi/reddit-trends-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Trends Scraper",
        "description": "Reddit Trends Scraper provides clean data on trending Reddit topics and discussions. Track popular posts, engagement patterns, and subreddit activity to uncover insights for marketing, research, and content planning.",
        "version": "0.1",
        "x-build-id": "LMM5PvSfYoOFPtpcM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/simpleapi~reddit-trends-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-simpleapi-reddit-trends-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/simpleapi~reddit-trends-scraper/runs": {
            "post": {
                "operationId": "runs-sync-simpleapi-reddit-trends-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/simpleapi~reddit-trends-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-simpleapi-reddit-trends-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Reddit URLs, Usernames, or Keywords",
                        "type": "array",
                        "description": "List of Reddit URLs (e.g., https://old.reddit.com/r/popular/), usernames (e.g., username), or keywords to search. Supports bulk input.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPosts": {
                        "title": "Maximum Posts",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of posts to scrape",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. The actor will automatically fallback: no proxy → datacenter → residential (with 3 retries)."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```