# Moltbook Monitor & Keyword Alerts (`assmblr/moltbook-intel-scraper`) Actor

Monitor Moltbook ("Reddit for AI agents") with incremental sync, keyword alerts, optional comment scraping, and webhook notifications.

- **URL**: https://apify.com/assmblr/moltbook-intel-scraper.md
- **Developed by:** [Assmblr](https://apify.com/assmblr) (community)
- **Categories:** Agents, Automation, Social media
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Moltbook Monitor & Keyword Alerts

Monitor Moltbook ("Reddit for AI agents") with **incremental sync**, **keyword alerts**, optional **comment scraping**, and **webhook notifications**.

Use this actor when you want Moltbook to behave like a feed you can automate:
- schedule it (every 10 minutes / hourly)
- only get *new* posts/comments (stateful, deduped)
- get notified when something matches your keywords

### What you get
- **Incremental runs**: when `incremental=true`, the actor stores state in the Apify KV store and emits only new content.
- **Events for automation**: emits dataset items like `new_post`, `new_comment`, `keyword_match`, and (optionally) `comment_thread`.
- **Optional comments + thread trees**: fetch comments and optionally reconstruct nested reply trees.
- **Webhook delivery**: send events to your system (Slack/Discord/Zapier/custom endpoint).

### Quick start
#### 1) Monitor front page (incremental + keyword alerts)

```json
{
  "operation": "monitor",
  "sort": "new",
  "limit": 100,
  "incremental": true,
  "keywords": ["openclaw", "apify"],
  "keywordMode": "contains",
  "includeComments": false,
  "threadTree": false
}
````

#### 2) Monitor specific submolts + comments + webhook

```json
{
  "operation": "monitor",
  "submolts": ["general", "clawtasks"],
  "sort": "new",
  "limit": 50,
  "includeComments": true,
  "maxCommentsPerPost": 200,
  "threadTree": true,
  "keywords": ["USDC", "Base L2"],
  "webhookUrl": "https://example.com/webhook"
}
```

### One-off scraping (no monitoring)

If you just want a snapshot export, use one of these modes:

#### Posts (no comments)

```json
{
  "operation": "posts",
  "sort": "top",
  "limit": 200
}
```

#### Posts with comments

```json
{
  "operation": "posts_with_comments",
  "sort": "new",
  "limit": 50,
  "commentSort": "top",
  "maxCommentsPerPost": 100,
  "threadTree": true
}
```

#### Comments (recent)

```json
{
  "operation": "comments",
  "limit": 200
}
```

#### Agents (profiles)

```json
{
  "operation": "agents",
  "limit": 200
}
```

#### Submolts (communities)

```json
{
  "operation": "submolts",
  "limit": 200
}
```

#### Leaderboard

```json
{
  "operation": "leaderboard",
  "limit": 200
}
```

#### Search

```json
{
  "operation": "search",
  "limit": 200,
  "keywords": ["agents", "payments"]
}
```

### Output

Dataset contains:

- entities: `post`, `comment`, `agent`, `submolt`, `search_result`
- events: emitted as dataset items with `item_type: "event"`

KV store values:

- `state`: incremental cursor + seen IDs
- `events`: raw events array
- `verify-report`: run summary

### Pricing (Pay-per-event)

This actor uses **pay-per-event** pricing.

#### Chargeable events

The actor triggers these events in code via `Actor.charge({ eventName })`:

- `apify-actor-start` — charged once per run
- `include-comments` — charged when comments are fetched (`includeComments=true` or `operation=posts_with_comments`)
- `thread-tree` — charged when `threadTree=true` *and* comments are fetched
- `webhook-delivery` — charged when `webhookUrl` is set

#### Recommended prices (competitive)

Suggested values to stay competitive for frequent monitoring:

- `apify-actor-start`: **$0.01 / run**
- `include-comments`: **$0.02 / run**
- `thread-tree`: **$0.01 / run**
- `webhook-delivery`: **$0.005 / run**

> Note: these prices must be configured in the Actor’s **Monetization** settings on Apify.
> If pay-per-event isn’t enabled for the actor/run, `Actor.charge()` is a no-op and the run continues without charging.

### Moltbook API key

Moltbook’s official API may require an API key.

- If you provide `moltbookApiKey`, the actor uses official API endpoints (more reliable).
- Without a key, you may get authorization errors depending on Moltbook’s policy.

### Disclaimer

You are responsible for complying with Moltbook’s Terms and for how you use scraped data.

# Actor input Schema

## `operation` (type: `string`):

monitor = incremental sync + events. Other modes do one-off pulls.

## `sort` (type: `string`):

Sort for feeds.

## `submolts` (type: `array`):

Submolt slugs to scrape (e.g. general, clawtasks). Empty = front page (posts/posts\_with\_comments/monitor).

## `agentNames` (type: `array`):

Optional list of agent usernames to enrich (profiles) and/or filter.

## `postUrls` (type: `array`):

Specific post URLs to fetch (post\_urls mode).

## `limit` (type: `integer`):

Max posts/items to return for one-off modes. Monitor mode may return less depending on state.

## `includeComments` (type: `boolean`):

When enabled, fetch comments for each post (posts\_with\_comments / monitor).

## `commentSort` (type: `string`):

Sort to use when fetching comments.

## `maxCommentsPerPost` (type: `integer`):

0 = unlimited (not recommended).

## `threadTree` (type: `boolean`):

If enabled, comments are additionally emitted as a nested thread representation (events dataset).

## `incremental` (type: `boolean`):

If enabled, only new items since last run are emitted (uses KV store state).

## `since` (type: `string`):

Optional override for incremental cutoff. Example: 2026-02-01T00:00:00Z

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

Emit keyword\_match events when post/comment content matches any keyword.

## `keywordMode` (type: `string`):

contains = substring (case-insensitive), word = whole word match, regex = treat keywords as regex patterns.

## `webhookUrl` (type: `string`):

If set, keyword\_match and new\_\* events are POSTed here in batches.

## `webhookHeaders` (type: `object`):

Optional headers to include in webhook requests (e.g. Authorization).

## `webhookBatchSize` (type: `integer`):

How many events to send per webhook call.

## `moltbookApiKey` (type: `string`):

Optional Moltbook API key. If provided, the actor will use the official API endpoints (more reliable than HTML scraping).

## `maxConcurrency` (type: `integer`):

Parallel requests (posts/comments/profile enrich).

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout for Moltbook API calls (seconds).

## `maxRequestRetries` (type: `integer`):

How many times to retry failed requests (network/5xx/timeouts).

## Actor input object example

```json
{
  "operation": "monitor",
  "sort": "new",
  "submolts": [],
  "agentNames": [],
  "postUrls": [],
  "limit": 100,
  "includeComments": false,
  "commentSort": "top",
  "maxCommentsPerPost": 200,
  "threadTree": true,
  "incremental": true,
  "since": "",
  "keywords": [],
  "keywordMode": "contains",
  "webhookUrl": "",
  "webhookHeaders": {},
  "webhookBatchSize": 25,
  "maxConcurrency": 8,
  "requestTimeoutSecs": 30,
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `events` (type: `string`):

No description

## `verifyReport` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("assmblr/moltbook-intel-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("assmblr/moltbook-intel-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 '{}' |
apify call assmblr/moltbook-intel-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Moltbook Monitor & Keyword Alerts",
        "description": "Monitor Moltbook (\"Reddit for AI agents\") with incremental sync, keyword alerts, optional comment scraping, and webhook notifications.",
        "version": "0.2",
        "x-build-id": "1tPdqmlODFPvwL1uU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/assmblr~moltbook-intel-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-assmblr-moltbook-intel-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/assmblr~moltbook-intel-scraper/runs": {
            "post": {
                "operationId": "runs-sync-assmblr-moltbook-intel-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/assmblr~moltbook-intel-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-assmblr-moltbook-intel-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": [
                    "operation"
                ],
                "properties": {
                    "operation": {
                        "title": "Operation",
                        "enum": [
                            "monitor",
                            "posts",
                            "posts_with_comments",
                            "post_urls",
                            "comments",
                            "agents",
                            "submolts",
                            "leaderboard",
                            "search"
                        ],
                        "type": "string",
                        "description": "monitor = incremental sync + events. Other modes do one-off pulls.",
                        "default": "monitor"
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "hot",
                            "new",
                            "top",
                            "rising"
                        ],
                        "type": "string",
                        "description": "Sort for feeds.",
                        "default": "new"
                    },
                    "submolts": {
                        "title": "Submolts",
                        "type": "array",
                        "description": "Submolt slugs to scrape (e.g. general, clawtasks). Empty = front page (posts/posts_with_comments/monitor).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "agentNames": {
                        "title": "Agent names",
                        "type": "array",
                        "description": "Optional list of agent usernames to enrich (profiles) and/or filter.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "postUrls": {
                        "title": "Post URLs",
                        "type": "array",
                        "description": "Specific post URLs to fetch (post_urls mode).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "limit": {
                        "title": "Limit",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Max posts/items to return for one-off modes. Monitor mode may return less depending on state.",
                        "default": 100
                    },
                    "includeComments": {
                        "title": "Include comments",
                        "type": "boolean",
                        "description": "When enabled, fetch comments for each post (posts_with_comments / monitor).",
                        "default": false
                    },
                    "commentSort": {
                        "title": "Comment sort",
                        "enum": [
                            "top",
                            "new",
                            "controversial"
                        ],
                        "type": "string",
                        "description": "Sort to use when fetching comments.",
                        "default": "top"
                    },
                    "maxCommentsPerPost": {
                        "title": "Max comments per post",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "0 = unlimited (not recommended).",
                        "default": 200
                    },
                    "threadTree": {
                        "title": "Build thread tree",
                        "type": "boolean",
                        "description": "If enabled, comments are additionally emitted as a nested thread representation (events dataset).",
                        "default": true
                    },
                    "incremental": {
                        "title": "Incremental (stateful)",
                        "type": "boolean",
                        "description": "If enabled, only new items since last run are emitted (uses KV store state).",
                        "default": true
                    },
                    "since": {
                        "title": "Since (ISO timestamp)",
                        "type": "string",
                        "description": "Optional override for incremental cutoff. Example: 2026-02-01T00:00:00Z",
                        "default": ""
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Emit keyword_match events when post/comment content matches any keyword.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywordMode": {
                        "title": "Keyword mode",
                        "enum": [
                            "contains",
                            "word",
                            "regex"
                        ],
                        "type": "string",
                        "description": "contains = substring (case-insensitive), word = whole word match, regex = treat keywords as regex patterns.",
                        "default": "contains"
                    },
                    "webhookUrl": {
                        "title": "Webhook URL (optional)",
                        "type": "string",
                        "description": "If set, keyword_match and new_* events are POSTed here in batches.",
                        "default": ""
                    },
                    "webhookHeaders": {
                        "title": "Webhook headers",
                        "type": "object",
                        "description": "Optional headers to include in webhook requests (e.g. Authorization).",
                        "default": {}
                    },
                    "webhookBatchSize": {
                        "title": "Webhook batch size",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "How many events to send per webhook call.",
                        "default": 25
                    },
                    "moltbookApiKey": {
                        "title": "Moltbook API key (optional)",
                        "type": "string",
                        "description": "Optional Moltbook API key. If provided, the actor will use the official API endpoints (more reliable than HTML scraping)."
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Parallel requests (posts/comments/profile enrich).",
                        "default": 8
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (secs)",
                        "minimum": 5,
                        "maximum": 180,
                        "type": "integer",
                        "description": "Per-request timeout for Moltbook API calls (seconds).",
                        "default": 30
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many times to retry failed requests (network/5xx/timeouts).",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
