# Rumble Creator & Video Signal Monitor (`trovevault/rumble-creator-video-signal-monitor`) Actor

Monitors Rumble creators, videos, views, followers, rankings, and momentum signals. Export data, run via API, schedule runs, or integrate with other tools.

- **URL**: https://apify.com/trovevault/rumble-creator-video-signal-monitor.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** Social media, Videos, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.50 / 1,000 channel or videos

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 Creator & Video Signal Monitor

Track public Rumble creators, videos, search results, and current momentum signals for influencer discovery, brand monitoring, media research, and emerging-platform coverage.

This Actor is built for teams that already monitor YouTube, TikTok, Instagram, podcasts, newsletters, or mainstream media, but also need coverage for Rumble. It turns public Rumble pages into structured rows with creator names, channel URLs, video URLs, visible view counts, result ranks, recency signals, and simple momentum scoring.

### What It Does

The Actor accepts Rumble channel URLs, Rumble search queries, or both. It then:

- inspects public Rumble channel pages
- searches Rumble for creator names, brand terms, topics, or campaign keywords
- opens each discovered video page to enrich search results with structured video metadata
- extracts visible video cards and channel-level signals
- parses public view, follower, publication-age, duration, thumbnail, description, and comment labels when available
- suppresses video rows when detail-page enrichment fails, so the default dataset avoids half-empty results
- scores each result for momentum and influencer relevance
- writes structured rows that can be scheduled, exported, or joined with other monitoring pipelines

### Good Use Cases

- Influencer teams tracking creators who publish on Rumble
- Brand safety teams monitoring niche or emerging-platform mentions
- Media researchers following topics that move outside mainstream platforms
- Agencies building weekly creator intelligence reports
- Growth teams comparing creator momentum across repeat runs

### Input

You can use either channels, queries, or both.

#### Rumble Channel URLs

Use known public Rumble channels:

```json
[
  { "url": "https://rumble.com/c/Reuters", "label": "Reuters on Rumble" }
]
````

#### Search Queries

Use creator names, brand terms, topics, campaign keywords, or niche categories:

```json
["technology news", "electric vehicles", "creator name"]
```

#### Lookback Days

Controls how strongly recent videos are scored. Older videos may still appear, but the recency component of `momentumScore` drops as videos fall outside the configured window.

#### Max Results per Input

Limits the number of enriched video or search-result rows returned per channel or query. The Actor may inspect extra candidates and suppress blocked detail pages so the final dataset stays clean.

### Output

The Actor writes rows with `entityType`:

- `channel`: one row per channel page inspected
- `video`: videos detected from a channel page
- `search_result`: videos detected from Rumble search
- `error`: structured row explaining an input, network, blocked, not-found, or parse issue

Example row:

```json
{
  "entityType": "search_result",
  "query": "technology news",
  "rank": 1,
  "channelName": "Example Creator",
  "videoTitle": "New technology policy update",
  "videoUrl": "https://rumble.com/v...",
  "views": 18400,
  "publishedText": "2 days ago",
  "momentumScore": 74,
  "influencerRelevanceScore": 61,
  "sourcePageUrl": "https://rumble.com/search/video?q=technology%20news",
  "warnings": null,
  "scrapedAt": "2026-05-18T12:00:00.000Z"
}
```

### Field Notes

`momentumScore` is a lightweight 0-100 score based on recency, visible views, and comments.

`influencerRelevanceScore` combines visible channel size, verification, rank, and query-term matches. It is a prioritization signal, not an endorsement or audience-quality guarantee.

`publishedAtApprox` is approximate when Rumble shows relative labels such as "2 days ago". The original label is preserved in `publishedText`.

`warnings` explain remaining public data limitations. By default, video and search-result rows are only returned after successful detail-page enrichment. Rows skipped because detail enrichment failed are summarized in `RUN_SUMMARY.suppressedEnrichment`.

### API Example

```bash
curl "https://api.apify.com/v2/acts/trovevault~rumble-creator-video-signal-monitor/runs?waitForFinish=120" \
  -X POST \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "queries": ["technology news"],
    "lookbackDays": 14,
    "maxResults": 1
  }'
```

### Scheduling

Run the Actor daily or weekly with the same channels and queries. Save each run into a long-lived dataset using `datasetId` if you want one combined export table across scheduled runs.

### Limitations

This Actor uses public Rumble pages. It does not log in, bypass access controls, or claim complete platform coverage. Search result completeness depends on Rumble's public search behavior. Some channel or video metrics may be hidden, delayed, localized, or absent from listing pages. When a value is not visible or not reliable enough to parse, the Actor returns `null` and adds a warning instead of inventing data.

For cloud runs, Residential Apify Proxy is recommended because Rumble may return HTTP 403 to plain datacenter traffic. Keep `maxResults` focused enough for the workflow you actually need.

# Actor input Schema

## `channelUrls` (type: `array`):

Rumble channel URLs to inspect. Use this when you already know the creators or publishers you want to monitor. Some channel pages may require stronger proxy settings than search pages.

## `queries` (type: `array`):

Keywords, creator names, brand terms, or topics to search on Rumble. Use this for influencer discovery, brand monitoring, or emerging-topic tracking.

## `lookbackDays` (type: `integer`):

Number of recent days to treat as current activity when scoring video momentum. Older public videos may still be returned, but they receive lower recency scores.

## `maxResults` (type: `integer`):

Maximum enriched video or search-result rows to return per channel or query. The actor may inspect extra candidates and suppress blocked detail pages so the final dataset stays clean.

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

Proxy settings for Rumble page requests. Residential Apify Proxy is recommended for cloud runs because Rumble may return HTTP 403 to datacenter traffic.

## `datasetId` (type: `string`):

ID of an existing Apify dataset to append results to, in addition to the default run dataset. Use this for long-lived creator monitoring tables.

## `runId` (type: `string`):

External run, campaign, or workflow ID to copy into each dataset row for downstream pipeline matching.

## Actor input object example

```json
{
  "queries": [
    "technology news"
  ],
  "lookbackDays": 14,
  "maxResults": 1,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "queries": [
        "technology news"
    ],
    "lookbackDays": 14,
    "maxResults": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/rumble-creator-video-signal-monitor").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 = {
    "queries": ["technology news"],
    "lookbackDays": 14,
    "maxResults": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("trovevault/rumble-creator-video-signal-monitor").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 '{
  "queries": [
    "technology news"
  ],
  "lookbackDays": 14,
  "maxResults": 1
}' |
apify call trovevault/rumble-creator-video-signal-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=trovevault/rumble-creator-video-signal-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Rumble Creator & Video Signal Monitor",
        "description": "Monitors Rumble creators, videos, views, followers, rankings, and momentum signals. Export data, run via API, schedule runs, or integrate with other tools.",
        "version": "0.1",
        "x-build-id": "ms3L29grb8egcOn2s"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~rumble-creator-video-signal-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-rumble-creator-video-signal-monitor",
                "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/trovevault~rumble-creator-video-signal-monitor/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-rumble-creator-video-signal-monitor",
                "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/trovevault~rumble-creator-video-signal-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-rumble-creator-video-signal-monitor",
                "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": {
                    "channelUrls": {
                        "title": "Rumble Channel URLs",
                        "type": "array",
                        "description": "Rumble channel URLs to inspect. Use this when you already know the creators or publishers you want to monitor. Some channel pages may require stronger proxy settings than search pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "queries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Keywords, creator names, brand terms, or topics to search on Rumble. Use this for influencer discovery, brand monitoring, or emerging-topic tracking.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "lookbackDays": {
                        "title": "Lookback Days",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Number of recent days to treat as current activity when scoring video momentum. Older public videos may still be returned, but they receive lower recency scores.",
                        "default": 14
                    },
                    "maxResults": {
                        "title": "Max Results per Input",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum enriched video or search-result rows to return per channel or query. The actor may inspect extra candidates and suppress blocked detail pages so the final dataset stays clean.",
                        "default": 1
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for Rumble page requests. Residential Apify Proxy is recommended for cloud runs because Rumble may return HTTP 403 to datacenter traffic.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "datasetId": {
                        "title": "Dataset ID (optional)",
                        "type": "string",
                        "description": "ID of an existing Apify dataset to append results to, in addition to the default run dataset. Use this for long-lived creator monitoring tables."
                    },
                    "runId": {
                        "title": "Run ID (optional)",
                        "type": "string",
                        "description": "External run, campaign, or workflow ID to copy into each dataset row for downstream pipeline matching."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```