# 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Rumble Creator & Video Signal Monitor

Rumble Creator & Video Signal Monitor turns public Rumble channels and search queries into structured creator, video, and momentum rows. It is built for influencer discovery, brand monitoring, media research, emerging-platform coverage, and weekly reporting workflows that already track YouTube, TikTok, Instagram, podcasts, newsletters, or mainstream media but also need Rumble coverage.

Give the actor Rumble channel URLs, Rumble search queries, or both. It returns rows with `entityType`, `channelName`, `videoTitle`, `videoUrl`, visible view and follower signals, search result ranks, recency labels, `momentumScore`, `influencerRelevanceScore`, warnings, and timestamps.

### Why use this actor

- Monitor Rumble creators and topic searches without manual page checks.
- Convert public channel and video pages into exportable Apify dataset rows.
- Rank videos and search results with lightweight momentum and influencer relevance scores.
- Keep warning fields and `RUN_SUMMARY` diagnostics so missing public values are explicit.
- Schedule repeat runs for the same channels or keywords and append results with `datasetId`.
- Use `runId` to connect Rumble monitoring with wider creator, media, or brand-safety workflows.

### What it collects

| Output | Meaning |
| --- | --- |
| `entityType` | `channel`, `video`, `search_result`, or `error`. |
| `query` / `rank` | Search query and rank for search-result rows. |
| `channelName` / `channelUrl` | Public channel identity when visible. |
| `videoTitle` / `videoUrl` | Public video metadata and URL. |
| `views`, `publishedText`, `durationText` | Visible video signals when available. |
| `momentumScore` | 0-100 prioritization score based on recency, views, and comments. |
| `influencerRelevanceScore` | 0-100 signal based on channel size, verification, rank, and query match. |
| `sourcePageUrl` | Public page used for the row. |
| `warnings` | Missing, blocked, or approximate data notes. |
| `scrapedAt` | Timestamp when the row was created. |

### Use cases

- **Influencer discovery:** track creators who publish on Rumble and compare repeat-run momentum.
- **Brand monitoring:** watch brand, product, executive, or campaign keywords on an emerging video platform.
- **Media research:** follow topics that may move outside mainstream social platforms.
- **Agency reporting:** produce weekly rows for creator intelligence, niche coverage, and content trend reports.
- **Brand safety review:** identify videos or channels that deserve manual inspection before sponsorship or placement decisions.

### How to use it

1. Add one or more Rumble channel URLs in `channelUrls`, search `queries`, or both.
2. Set `lookbackDays` to shape the recency component of `momentumScore`.
3. Keep `maxResults` focused for the workflow you actually need.
4. Enable Apify Proxy if Rumble blocks plain datacenter traffic.
5. Review rows together with `warnings` and the run-level `RUN_SUMMARY`.

### Input examples

#### Channel monitoring

```json
{
  "channelUrls": [
    { "url": "https://rumble.com/c/Reuters", "label": "Reuters on Rumble" }
  ],
  "lookbackDays": 14,
  "maxResults": 10,
  "runId": "weekly-rumble-channel-watch"
}
```

#### Search monitoring

```json
{
  "queries": ["technology news", "electric vehicles"],
  "lookbackDays": 14,
  "maxResults": 20
}
```

#### Input reference

| Field | Required | Description |
| --- | --- | --- |
| `channelUrls` | No | Public Rumble channel URLs to inspect. |
| `queries` | No | Creator names, brand terms, topics, campaign keywords, or niche categories to search. |
| `lookbackDays` | No | Recency window used for momentum scoring. |
| `maxResults` | No | Maximum enriched rows per input. |
| `proxyConfiguration` | No | Apify Proxy settings for blocked or rate-limited public pages. |
| `datasetId` | No | Existing dataset to append rows into. |
| `runId` | No | Workflow identifier copied into run metadata. |

### Output example

```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"
}
```

### API usage

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

### How scoring works

`momentumScore` is a lightweight 0-100 prioritization score based on recency, visible views, and comments. `influencerRelevanceScore` combines visible channel size, verification, result rank, and query-term matches. These fields help sort review queues; they are not endorsements, audience-quality guarantees, or brand-safety certifications.

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

### Limitations

- The actor uses public Rumble pages only. It does not log in or bypass access controls.
- Search completeness depends on Rumble's public search behavior at run time.
- Some channel, video, follower, comment, or view metrics may be hidden, delayed, localized, or absent.
- When a value is not visible or reliable enough to parse, the actor returns `null` and warnings instead of inventing data.
- Video and search-result rows are normally returned after successful detail-page enrichment so the default dataset avoids half-empty rows.
- Residential Apify Proxy is recommended for cloud runs because Rumble may return HTTP 403 to plain datacenter traffic.

### Troubleshooting

| Problem | What to try |
| --- | --- |
| HTTP 403 or many blocked rows | Enable Apify Proxy, preferably residential, and keep `maxResults` focused. |
| Search returns fewer rows than expected | Try broader or alternate query wording and check Rumble search manually. |
| Video rows are missing | Detail-page enrichment may have failed; check `RUN_SUMMARY.suppressedEnrichment`. |
| Scores look low | Increase `lookbackDays` or use more specific creator/topic queries. |
| Repeated monitoring is hard to compare | Schedule the same input and append rows with `datasetId` or a stable `runId`. |

### FAQ

**Does this actor scrape private Rumble data?**\
No. It uses public pages only.

**Can I monitor both channels and searches?**\
Yes. Provide `channelUrls`, `queries`, or both in the same run.

**Why are some metrics null?**\
The metric was not visible or parseable with enough confidence on the public page.

**Are the momentum scores authoritative?**\
No. They are sorting signals for review, not proof of influence or brand safety.

**Can I schedule weekly reports?**\
Yes. Use Apify schedules and keep input stable across runs.

**Should I use a proxy?**\
For cloud runs, yes if you see blocked pages or HTTP 403 responses.

**Can I export rows to BI or Sheets?**\
Yes. Use Apify dataset exports, API, integrations, or webhooks.

### Related actors

- Influencer Pricing Calculator for rate benchmarking after creator discovery.
- Mobile Apps Reviews, Downloads and Data for app-market signal monitoring.
- Competitor Ad Angle Analyzer for paid creative intelligence workflows.

### Changelog

- 0.1: Initial TroveVault release with Rumble channel/search inputs, video enrichment, momentum scoring, proxy support, `datasetId`, and `runId`.

### Feedback and support

Open an issue on the actor page with the input JSON, run ID, blocked URL or query, and the row you expected to see.

# 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(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,trovevault/rumble-creator-video-signal-monitor"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/xWXBAhSOivMGiRgpP/builds/sjemgGZ0j7rigYxdz/openapi.json