# Rumble Channel & Video Intelligence Scraper (`automation-lab/rumble-channel-video-intelligence-scraper`) Actor

Extract public Rumble search, channel, video, Shorts, and embed metadata for media monitoring, creator research, and content intelligence.

- **URL**: https://apify.com/automation-lab/rumble-channel-video-intelligence-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 rumble records

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Rumble Channel & Video Intelligence Scraper

Extract public Rumble search, channel, video, Shorts, and embed metadata for media monitoring, creator research, and content intelligence.

### What does this Rumble scraper do?

Rumble Channel & Video Intelligence Scraper turns public Rumble search terms, channel URLs, video URLs, Shorts URLs, and raw video IDs into structured datasets.

It focuses on metadata and intelligence workflows rather than forcing a media download.

You can collect titles, channel names, channel URLs, view counts, comment counts, likes, thumbnails, durations, Shorts flags, and optional video file URLs when Rumble exposes them publicly.

### Who is it for?

- 📰 Media monitoring teams tracking narratives on Rumble.
- 🧑‍💻 OSINT and trust-and-safety researchers mapping creator activity.
- 📣 Agencies finding creators and channels in a niche.
- 🎥 Video teams auditing public Rumble metadata.
- 📊 Analysts exporting Rumble search results to BI tools.

### Why use this actor?

Rumble public HTML pages can show Cloudflare challenges to basic crawlers.

This actor uses Rumble public JSON surfaces for the default workflow, keeping runs fast and avoiding heavy browser sessions for normal metadata extraction.

It is built for repeatable, dataset-oriented intelligence instead of one-off manual copying.

### What data can you extract?

| Field | Description |
| --- | --- |
| `recordType` | Search video, search channel, or video embed record. |
| `title` | Video or channel title/name. |
| `canonicalUrl` | Public Rumble URL when available. |
| `channelName` | Creator or channel name. |
| `channelUrl` | Public channel URL. |
| `views` | Public view count when present. |
| `commentsCount` | Public comment count when present. |
| `likesCount` | Public positive vote count when present. |
| `durationSeconds` | Video length in seconds. |
| `thumbnailUrl` | Thumbnail image URL. |
| `isShort` | Whether a result is a Rumble Short. |
| `downloadable` | Whether Rumble marks the video as downloadable. |
| `embedUrl` | Rumble embed URL. |
| `videoUrl` | Optional direct file URL when enabled. |

### How much does it cost to scrape Rumble metadata?

This actor uses pay-per-event pricing.

You pay a small start fee plus a per-record charge for each output item.

Keep `maxItems` low for test runs, then increase it when the output shape matches your workflow.

### How to scrape Rumble search results

1. Open the actor on Apify.
2. Add one or more values to `searchQueries`.
3. Set `maxItems` to the number of records you need.
4. Keep `includeVideoFiles` disabled for metadata-only runs.
5. Start the run.
6. Export JSON, CSV, Excel, or connect the dataset to your pipeline.

### How to scrape a Rumble channel URL

Add a channel URL such as `https://rumble.com/c/IveGotQuestion` to `startUrls`.

The actor converts the channel slug into a public Rumble search query and returns matching channel and video intelligence records.

### How to scrape a Rumble video or Short

Add a URL such as `https://rumble.com/shorts/v7bgd6g` or a raw ID such as `7bgd6g` to `startUrls`.

The actor queries Rumble's public embed metadata endpoint for explicit video IDs.

### Input options

#### `searchQueries`

List of Rumble search terms.

Example:

```json
["news", "podcast", "markets"]
````

#### `startUrls`

Accepts Rumble search URLs, channel URLs, video URLs, Shorts URLs, embed URLs, or raw IDs.

#### `maxItems`

Maximum number of records across all inputs.

#### `includeVideoFiles`

When enabled, the actor includes direct CDN video file URLs if Rumble exposes them.

Leave this disabled for copyright-safe monitoring and metadata workflows.

### Example input

```json
{
  "searchQueries": ["news", "podcast"],
  "startUrls": [
    { "url": "https://rumble.com/search/video?q=news" },
    { "url": "https://rumble.com/shorts/v7bgd6g" }
  ],
  "maxItems": 25,
  "includeVideoFiles": false
}
```

### Example output

```json
{
  "recordType": "search_video",
  "query": "news",
  "title": "News Break",
  "channelName": "Question Everything",
  "canonicalUrl": "https://rumble.com/shorts/v7bgd6g",
  "views": 1341,
  "commentsCount": 1,
  "likesCount": 24,
  "durationSeconds": 44,
  "isShort": true,
  "downloadable": true,
  "extractedAt": "2026-06-20T20:20:13.776Z"
}
```

### Tips for best results

- Use specific search terms instead of very broad words.
- Run several small searches rather than one huge run during setup.
- Disable direct video URLs unless you need archive metadata.
- Use the channel URL input to discover related channel records.
- Export CSV for quick editorial review.

### Integrations

Use this actor with:

- Google Sheets for monitoring dashboards.
- Airtable for creator databases.
- Slack alerts for new topic snapshots.
- BI tools for cross-platform content analysis.
- Apify webhooks for scheduled media monitoring.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/rumble-channel-video-intelligence-scraper').call({
  searchQueries: ['news'],
  maxItems: 25,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/rumble-channel-video-intelligence-scraper').call({
    'searchQueries': ['news'],
    'maxItems': 25,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~rumble-channel-video-intelligence-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchQueries":["news"],"maxItems":25}'
```

### MCP usage

Connect this actor to Claude through Apify MCP:

`https://mcp.apify.com/?tools=automation-lab/rumble-channel-video-intelligence-scraper`

Claude Code setup:

```bash
claude mcp add apify-rumble "https://mcp.apify.com/?tools=automation-lab/rumble-channel-video-intelligence-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-rumble": {
      "url": "https://mcp.apify.com/?tools=automation-lab/rumble-channel-video-intelligence-scraper"
    }
  }
}
```

Example prompts:

- "Scrape Rumble search metadata for renewable energy and summarize the top channels."
- "Find public Rumble videos for this topic and return titles, views, and channel URLs."
- "Build a CSV of Rumble Shorts metadata for this search term."

### Scheduling

Schedule the actor daily or weekly to monitor topic visibility over time.

Use stable search queries and export each run to a time-series table.

### Limitations

Rumble HTML pages may return Cloudflare challenges to direct browsers.

The default implementation avoids that by using public JSON endpoints.

Some channel, playlist, or livestream-specific details may not be present in the public JSON response for every query.

### Legality and responsible use

This actor extracts publicly available metadata.

Do not use it to access private accounts, bypass paywalls, or infringe copyright.

If you enable direct file URLs, make sure your use complies with Rumble terms, creator rights, and applicable law.

### FAQ and troubleshooting

#### Why did I get fewer results than `maxItems`?

Rumble may return a limited number of records for a public query. Try more specific or additional search terms.

#### Why is `videoUrl` empty?

Direct file URLs are disabled by default. Enable `includeVideoFiles` only if your workflow needs them.

#### Why are some channel stats missing?

Rumble exposes different metadata depending on the result type and public endpoint response.

### Related scrapers

Try other automation-lab social and video intelligence actors on Apify:

- https://apify.com/automation-lab/youtube-scraper
- https://apify.com/automation-lab/tiktok-scraper
- https://apify.com/automation-lab/social-media-scraper

### Changelog

Initial version extracts public Rumble search, channel, and video/embed metadata.

### Support

If a public Rumble URL or query does not return expected metadata, open an Apify issue with the input JSON and run URL.

### Output field notes

`recordType` lets you filter mixed records in one dataset.

`source` stores the original query or input value.

`canonicalUrl` points to the public Rumble entity when available.

`extractedAt` is an ISO timestamp for the extraction time.

### Performance notes

The actor is HTTP-first and normally runs with 256 MB memory.

It does not launch a browser for the default workflow.

### Data quality notes

Public counts such as views, likes, and comments can change over time.

Run the actor on a schedule if you need trend tracking.

### Privacy notes

The actor does not require a Rumble login and does not scrape private user data.

# Actor input Schema

## `searchQueries` (type: `array`):

Rumble search phrases to scrape. Each query returns public video and channel records from Rumble's public service endpoint.

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

Rumble search URLs, channel URLs, video URLs, Shorts URLs, embed URLs, or raw Rumble video IDs. Channel URLs are converted to a channel-name search.

## `maxItems` (type: `integer`):

Maximum dataset records to emit across all search, channel, and video inputs.

## `includeVideoFiles` (type: `boolean`):

When enabled, include public CDN video file URLs exposed by Rumble. Keep disabled for metadata-only, copyright-safe monitoring workflows.

## Actor input object example

```json
{
  "searchQueries": [
    "news",
    "podcast"
  ],
  "startUrls": [
    {
      "url": "https://rumble.com/search/video?q=news"
    },
    {
      "url": "https://rumble.com/c/IveGotQuestion"
    }
  ],
  "maxItems": 20,
  "includeVideoFiles": 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 = {
    "searchQueries": [
        "news",
        "podcast"
    ],
    "startUrls": [
        {
            "url": "https://rumble.com/search/video?q=news"
        },
        {
            "url": "https://rumble.com/c/IveGotQuestion"
        }
    ],
    "maxItems": 20,
    "includeVideoFiles": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/rumble-channel-video-intelligence-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 = {
    "searchQueries": [
        "news",
        "podcast",
    ],
    "startUrls": [
        { "url": "https://rumble.com/search/video?q=news" },
        { "url": "https://rumble.com/c/IveGotQuestion" },
    ],
    "maxItems": 20,
    "includeVideoFiles": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/rumble-channel-video-intelligence-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 '{
  "searchQueries": [
    "news",
    "podcast"
  ],
  "startUrls": [
    {
      "url": "https://rumble.com/search/video?q=news"
    },
    {
      "url": "https://rumble.com/c/IveGotQuestion"
    }
  ],
  "maxItems": 20,
  "includeVideoFiles": false
}' |
apify call automation-lab/rumble-channel-video-intelligence-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/rumble-channel-video-intelligence-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Rumble Channel & Video Intelligence Scraper",
        "description": "Extract public Rumble search, channel, video, Shorts, and embed metadata for media monitoring, creator research, and content intelligence.",
        "version": "0.1",
        "x-build-id": "p72q7aAz9be0duYZu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~rumble-channel-video-intelligence-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-rumble-channel-video-intelligence-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/automation-lab~rumble-channel-video-intelligence-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-rumble-channel-video-intelligence-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/automation-lab~rumble-channel-video-intelligence-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-rumble-channel-video-intelligence-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": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Rumble search phrases to scrape. Each query returns public video and channel records from Rumble's public service endpoint.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Rumble URLs or video IDs",
                        "type": "array",
                        "description": "Rumble search URLs, channel URLs, video URLs, Shorts URLs, embed URLs, or raw Rumble video IDs. Channel URLs are converted to a channel-name search.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum dataset records to emit across all search, channel, and video inputs.",
                        "default": 50
                    },
                    "includeVideoFiles": {
                        "title": "Include direct video file URLs",
                        "type": "boolean",
                        "description": "When enabled, include public CDN video file URLs exposed by Rumble. Keep disabled for metadata-only, copyright-safe monitoring workflows.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
