# Rumble Scraper - Videos, Channels, Playlists & Transcripts (`topapi/rumble-scraper`) Actor

Scrape Rumble: every video of a channel, user, playlist, category or trending list with exact views, rumbles, comments, duration, tags and MP4 links; channel rows with followers, socials and e-mail; transcripts; keywords; monitor mode. $0.90 per 1,000 videos.

- **URL**: https://apify.com/topapi/rumble-scraper.md
- **Developed by:** [Top Api](https://apify.com/topapi) (community)
- **Categories:** Videos, Social media, News
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 videos

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/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 Scraper - Videos, Channels, Playlists & Transcripts

Scrape public Rumble data from any channel, user, playlist, category, trending list or video link: one row per video with exact views, rumbles (up-votes), down-votes, comments, reposts, duration, upload date, tags, live and Shorts flags, the uploader with exact followers and the MP4 links; one row per channel with followers, total views, video count, join date, description, social links and public e-mail; one row per playlist. Add video details (full description, categories, every file with its size, the audio track, captions) and transcripts when you need them. No login, no browser.

### What you can scrape

| What you enter | Example | What you get |
|---|---|---|
| Channel or user link | `https://rumble.com/c/bongino`, `https://rumble.com/user/RealAmericasVoice` | One channel row + the channel's videos (newest first) |
| Channel name | `bongino` in **Channel or user names** | The same, the channel page is tried first, then the user page |
| Channel tab link | `https://rumble.com/c/NewsmaxTV/shorts`, `/livestreams`, `/videos`, `/playlists`, `/about` | That tab only (`/playlists`: one row per playlist, `/about`: the channel row) |
| Playlist link | `https://rumble.com/playlists/bIiAjWZmvAg` | One playlist row + every video in it |
| Video, Shorts or embed link, video id | `https://rumble.com/v7ht1li-...html`, `https://rumble.com/shorts/vshp03`, `https://rumble.com/embed/v7fmoo0/`, `v7ht1li` | That video |
| Category link | `https://rumble.com/category/news` | The category's videos |
| Trending, editor picks, live | `https://rumble.com/videos?sort=views&date=today`, `https://rumble.com/editor-picks`, `https://rumble.com/browse/live` | The videos those pages list |
| Keywords | `bitcoin` in **Search keywords** | Videos about the keyword (see "Keyword search" below) |
| Channel keywords | `news` in **Search channels by keyword** | One row per matching channel |

Mix them freely in one run.

### Quick input

```json
{
  "startUrls": ["https://rumble.com/c/bongino", "https://rumble.com/c/TimcastIRL"],
  "maxItemsPerInput": 10
}
```

This is the prefilled input: 10 newest videos of each channel plus 2 channel rows (22 rows, $0.02).

More examples:

```json
{ "startUrls": ["https://rumble.com/c/NewsmaxTV"], "channelSort": "views", "uploadDate": "this-month", "maxItemsPerInput": 200 }
```

```json
{ "startUrls": ["https://rumble.com/c/bongino"], "maxItemsPerInput": 50, "fetchDetails": true, "includeTranscripts": true }
```

```json
{ "startUrls": ["https://rumble.com/playlists/bIiAjWZmvAg"], "maxItems": 0 }
```

### Input

| Field | Default | What it does |
|---|---|---|
| `startUrls` | - | Any Rumble link from the table above |
| `channels` | - | Channel or user names |
| `searchQueries` | - | Keywords (videos) |
| `channelSearchQueries` | - | Keywords (channels) |
| `videoIds` | - | Video ids (`v7ht1li`) or embed ids |
| `contentTypes` | `all` | Channel tabs to read: `all` (the main page: uploads, livestreams and Shorts), `videos`, `shorts`, `livestreams`, `playlists` |
| `includeChannelInfo` | `true` | One channel row per channel link |
| `includeChannelVideos` | `true` | The channel's videos (off: channel rows only) |
| `includeChannelPlaylists` | `false` | One row per playlist of each channel link |
| `includePlaylistInfo` / `includePlaylistVideos` | `true` / `true` | For playlist links: the playlist row / its videos |
| `channelSort` | `date` | `date` (newest first) or `views` (Rumble's most-viewed order) |
| `sort` | `relevance` | Keyword results: `relevance`, `date`, `views`, `rumbles` |
| `uploadDate` | `any` | `today`, `this-week`, `this-month`, `this-year` (sent in Rumble's own channel and trending query) |
| `duration` | `any` | `short` (4 min or less) or `long` (over 20 min), Rumble's own presets (sent in Rumble's own channel query) |
| `fetchDetails` | `false` | Video details add-on (below) |
| `includeTranscripts` | `false` | Transcript add-on (below) |
| `transcriptLanguages` | English, else the first track | Preferred caption languages |
| `includeTranscriptSegments` | `true` | Timed segments `{start, end, text}` next to the text |
| `maxItems` | `50` | Rows at most in the run (videos, channels, playlists together); `0` = no limit |
| `maxItemsPerInput` | no limit | Videos at most per channel tab, playlist, list or keyword |
| `dateFrom`, `dateTo`, `publishedWithinDays` | - | Upload date window (a newest-first channel stops reading once it is past the window) |
| `minViews`, `maxViews`, `minLikes`, `minComments`, `minDurationSeconds`, `maxDurationSeconds` | - | Number filters. With `minViews`, channel links are read most viewed first (Rumble's own order) and reading stops at the first page under it; a date window, `maxDurationSeconds` up to 240 and `minDurationSeconds` from 1,242 also go into Rumble's own list query |
| `shorts`, `livestreams` | `include` | `include`, `exclude` or `only` |
| `titleContains`, `excludeKeywords` | - | Words in the title (or description) |
| `verifiedOnly`, `minFollowers`, `maxFollowers` | - | Channel filters |
| `monitorMode`, `monitorKey`, `emitViewChanges`, `viewChangePercent`, `resetMonitor` | off | Only-new mode (below) |
| `maxPagesPerList`, `maxConcurrency`, `proxyConfiguration` | `400`, `8`, none | Advanced |

Input names used by other Rumble scrapers are accepted too (`channelLinks`, `channelUrls`, `playlistUrls`, `videoUrls`, `links`, `keywords`, `searchQuery`, `maxItemsPerChannel`, `maxVideosPerSource`, `maxResults`, `extractTranscript`, `includeVideoDetails`, `onlyNew`, `watchViews`, `monitoringKey`, `sortBy`, `dateFilter`, `lengthFilter` ...).

### Output

Every row has `type`: `video`, `channel` or `playlist`. Measured fill below is from real runs on 2026-11-06 (150 channel videos `3FFnxInFHSTnctX4J`) and 2026-11-13 (100 videos with both add-ons `Dka5d4FiLOcpGH3dj`).

**Video row** (from channel, category and Shorts lists; 100% filled unless noted): `id`, `videoId`, `encodedId`, `url`, `path`, `title`, `thumbnailUrl`, `durationSeconds`, `durationText`, `uploadedAt`, `views`, `rumblePlays`, `youtubeViews`, `revenue`, `likes`, `dislikes`, `rumbleScore`, `votesTotal`, `commentsCount`, `repostsCount`, `width`, `height`, `contentType` (`video` / `short` / `livestream`), `isShort`, `isLive`, `isUpcoming`, `isMonetized`, `isAgeRestricted`, `isDownloadable`, `visibility`, `mediaFiles` (every rendition: quality, type mp4 / webm / hls / tar, url, bitrate), `bestVideoUrl` (71%, live and stream recordings have HLS / archive files only), `tags` (33%: the uploader sets them), livestream fields (`liveStreamedAt`, `livestreamStatus`, `livestreamHasDvr`, `watchingNow`: livestreams only), uploader `channelId`, `channelName`, `channelSlug`, `channelUrl`, `channelType`, `channelAvatarUrl`, `channelFollowers` (exact), `channelSubscribers`, `channelVerified`, `channelBadge`, `channelEncodedId`, plus `sourceType`, `source`, `searchQuery`, `position`, `playlistId`, `dataSource`, `scrapedAt`.

```json
{
  "type": "video", "id": "449772930", "videoId": "v7hyjy0",
  "url": "https://rumble.com/v7hyjy0-fred-fleitz-trump-could-let-pete-hegseth-go-national-report.html",
  "title": "Fred Fleitz: Trump could let Pete Hegseth go | National Report",
  "durationSeconds": 243, "durationText": "4:03", "uploadedAt": "2026-11-06T17:11:44.000Z",
  "views": 2538, "rumblePlays": 50, "likes": 4, "dislikes": 1, "rumbleScore": 3, "commentsCount": 2, "repostsCount": 0,
  "width": 1920, "height": 1080, "contentType": "video", "isLive": false, "isMonetized": true, "visibility": "public",
  "tags": ["Fred Fleitz", "National Report", "NEWSMAX", "Pete Hegseth", "..."],
  "mediaFiles": [{ "quality": "auto", "type": "hls", "url": "https://rumble.com/hls-vod/-GmgpVapV_U/playlist.m3u8" }],
  "channelId": "316725", "channelName": "NEWSMAX", "channelUrl": "https://rumble.com/c/NewsmaxTV",
  "channelFollowers": 1307435, "channelVerified": true, "channelBadge": "premium",
  "dataSource": "list", "sourceType": "channel", "position": 1
}
```

**Video details add-on** (`fetchDetails`): every file with `sizeBytes` and bitrate (100%), `audioUrl` / `audioBitrateKbps` / `audioSizeBytes` (when Rumble keeps a separate audio track), `captions` (language, label, VTT link, auto-generated flag), `captionsAvailable`, `fps`, `embedId`, `embedUrl`, `shareUrl`, `thumbnails`, `momentsCount` (100%), and `description`, `categories`, `primaryCategory`, `secondaryCategory`, `videoQuality` from the video page (99 of 99 on 2026-11-13; 51% on a 2026-11-06 run whose video pages were checked: see "Limits"). `bestVideoUrl` stays empty for the few recent uploads Rumble packages as HLS only (2 of 99); their HLS and archive files are in `mediaFiles`.

**Transcript add-on** (`includeTranscripts`): `transcript` (plain text), `transcriptSegments` (`{start, end, text}` in seconds), `transcriptLanguage`, `transcriptWordCount`, for every video with a caption track (96 of 100 Dan Bongino Show videos).

```json
{ "transcriptLanguage": "en-auto", "transcriptWordCount": 14601,
  "transcriptSegments": [{ "start": 71.66, "end": 78.86, "text": "we are not sunk yet we will never surrender ..." }] }
```

**Channel row**: `id`, `slug`, `name`, `title`, `url`, `channelType`, `description`, `avatarUrl`, `bannerUrl`, `followers` (exact when the channel lists videos), `followersText`, `subscribers`, `verified`, `badge`, `encodedId`, `creatorId`, `premiumProgram`, `acceptsTips`, `joinedAt`, `totalViews`, `videosCount`, `socialLinks` with `twitter`, `facebook`, `instagram`, `truthsocial`, `youtube`, `tiktok`, `telegram`, `locals`, `website`, `email` (when the About page lists one), `tabs`, `aboutFetched`, and upload cadence from the first list page: `latestUploadAt`, `uploadsLast30Days`, `uploadsLast30DaysCapped`, `avgViewsLatest`, `latestVideosSampled`.

```json
{ "type": "channel", "id": "316725", "slug": "NewsmaxTV", "name": "NEWSMAX", "url": "https://rumble.com/c/NewsmaxTV",
  "followers": 1307435, "followersText": "1.3M Followers", "verified": true, "videosCount": 13647, "totalViews": 132255319,
  "joinedAt": "2020-11-13T00:00:00.000Z", "socialLinks": ["https://twitter.com/newsmax", "https://facebook.com/newsmax", "https://instagram.com/newsmax", "https://truthsocial.com/@NewsMax"],
  "latestUploadAt": "2026-11-06T18:46:31.000Z", "uploadsLast30Days": 24, "aboutFetched": true }
```

**Playlist row**: `id`, `playlistId`, `url`, `title`, `description`, `videosCount`, `thumbnailUrl`, `updatedAt`, `updatedText`, `channelName`, `channelUrl`, `channelSlug`, `channelAvatarUrl`, `visibility`.

`dataSource` says where a video row came from: `list` (channel, category, Shorts list: exact counts), `card` (trending, editor picks, live, playlists: Rumble rounds counts on these cards - `viewsRounded` / `votesRounded` say so), `videoPage` (a video link: exact views, rounded votes), `embed` (a video link whose page Rumble refused: no views or votes).

### Keyword search

Rumble's own search page answers automated visitors with a human check, so keywords are searched in DuckDuckGo's index of rumble.com and every video found is read from Rumble itself. Expect 5-40 videos per keyword (DuckDuckGo shows 10 results a page and paces the next pages), not Rumble's full result list; results that are not about the keyword are dropped and never charged. DuckDuckGo also answers some visitors with its own check: on 2026-11-13, 8 of 13 test runs met it on every exit for at least one keyword, and a keyword it checks returns nothing (nothing charged; a run with only such keywords ends FAILED). For full coverage of a creator, use the channel link.

### Monitor mode (only new videos)

Turn on `monitorMode` and schedule the run (Apify Schedules, a webhook or the API). The first run delivers what it finds and remembers it in a named dataset in your account (`monitorKey`); each later run with the same input returns only videos it has not delivered before, and with `emitViewChanges` also known videos whose views moved by `viewChangePercent` or more (`changeType: viewsChanged`, `previousViews`, `viewsChange`). Turn on `fetchDetails` or `includeTranscripts` on a later poll and the videos an earlier poll delivered without them come back once, with the add-on (`changeType: details`); after that they are not sent again. A poll that finds nothing writes nothing and charges nothing (measured $0.00014 per empty poll). A poll whose free exits Rumble answers with a human check, and whose expected new videos (the channel's own upload rate times the time since the last delivering poll) do not pay for a residential page, ends FAILED with nothing charged; the next poll reads again, and its expected count has grown.

```json
{ "startUrls": ["https://rumble.com/c/NewsmaxTV"], "maxItemsPerInput": 25, "monitorMode": true, "monitorKey": "newsmax" }
```

API: `POST https://api.apify.com/v2/acts/TopApi~rumble-scraper/runs?token=<token>` with the input as the body; the MCP server `https://mcp.apify.com` exposes the actor to AI agents.

### Pricing

Pay per row delivered, no start fee:

| Event | Price |
|---|---|
| Video | $0.0009 ($0.90 per 1,000) |
| Channel | $0.00099 |
| Playlist | $0.0013 |
| Video details (add-on, per enriched video) | $0.00089 |
| Transcript (add-on, per video with captions) | $0.001 |

Rows removed by a filter, rows a monitor already delivered, missing channels and videos without captions are never charged. A spending limit stops the run cleanly at the limit with every charged row delivered. Measured: 1,000 channel videos in 11-59 s.

### Limits

- **Human checks.** Rumble's Cloudflare scores each visitor IP. The actor starts on direct egress and moves one step up (Apify datacenter, then Apify residential) when a page answers with a human check; it never solves a check and never rotates IPs past one (every rumble.com page of a run shares one exit per step). Measured over 101 test runs on 2026-11-13: the Apify container's own egress was checked on 98, the datacenter exit on 62, and the residential exit on 3 (2 ended FAILED with 0 rows and nothing charged, for $0.0003; 1 delivered 125 of 153 rows with a warning); 12 runs spaced two minutes apart had 0 residential checks. A run whose exits are all checked ends FAILED and charges nothing; one that read some sources first ends with those rows and a warning. Residential pages are used only when the rows they bring pay for them, so a one-video run never uses them and comes back from the embed player data (no views or votes) when the video page is refused.
- **Descriptions and categories** come from the video page; with Video details on they were filled for 99 of 99 videos on 2026-11-13 and 51% of 100 on a 2026-11-06 run whose video pages were checked on the free exits.
- **Monitor polls on checked exits**: a poll whose free exits are checked reads residential pages only when the new videos it expects pay for them; otherwise it ends FAILED with nothing charged (see Monitor mode).
- **Comments are not delivered**: Rumble serves them only through its comment service, which answers every automated visitor with a human check on every exit.
- **Channel depth**: Rumble lists a channel's main page up to 58 pages (1,440 videos for The Dan Bongino Show, whose About page counts 2,174) and the Videos tab up to 30 pages.
- **Keyword search** depth: see above.

# Actor input Schema

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

Any Rumble link: channels (<code>https://rumble.com/c/bongino</code>), users (<code>https://rumble.com/user/RealAmericasVoice</code>), channel tabs (<code>/c/NewsmaxTV/shorts</code>, <code>/livestreams</code>, <code>/playlists</code>, <code>/about</code>), playlists (<code>https://rumble.com/playlists/bIiAjWZmvAg</code>), videos, Shorts and embed links, categories (<code>https://rumble.com/category/news</code>), trending (<code>https://rumble.com/videos?sort=views\&date=today</code>), <code>/editor-picks</code>, <code>/browse/live</code> and search links (read as keywords). Mix them freely.

## `channels` (type: `array`):

Channel or user names as they appear in the link (<code>bongino</code>, <code>TimcastIRL</code>, <code>RealAmericasVoice</code>); the channel page is tried first, then the user page.

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

Keywords such as <code>bitcoin</code> or <code>election night</code>. Rumble's own search page answers automated visitors with a human check, so keyword results come from DuckDuckGo's index of rumble.com (typically 10-40 videos per keyword) and every video is then read from Rumble itself.

## `channelSearchQueries` (type: `array`):

Keywords to find Rumble channels (one channel row each), through DuckDuckGo's index of rumble.com.

## `videoIds` (type: `array`):

Rumble video ids from the link (<code>v7ht1li</code>) or embed ids (<code>v7fmoo0</code>).

## `contentTypes` (type: `array`):

Which tabs of each channel or user link to read: <b>all</b> (the channel's main page: every upload, livestream and Short - the whole catalogue), <b>videos</b> (uploads only; Rumble lists at most 30 pages = 750 of them), <b>shorts</b>, <b>livestreams</b>, <b>playlists</b> (one row per playlist).

## `includeChannelInfo` (type: `boolean`):

One row per channel or user link: followers, total views, video count, join date, description, social links, public e-mail, avatar, banner, upload cadence (latest upload, uploads in the last 30 days, average views of the latest videos).

## `includeChannelVideos` (type: `boolean`):

The videos of each channel or user link (the tabs chosen above). Off: channel rows only.

## `includeChannelPlaylists` (type: `boolean`):

One row per public playlist of each channel link (title, video count, last update).

## `includePlaylistVideos` (type: `boolean`):

For playlist links: every video in the playlist.

## `includePlaylistInfo` (type: `boolean`):

For playlist links: one row with the playlist's title, description, video count, owner and last update.

## `channelSort` (type: `string`):

Order of a channel's videos: newest first (Rumble's default) or most viewed first (Rumble's own sort).

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

Order of keyword results (and of the trending list when no sort is in its link): relevance (the index's order), newest, most viewed or most up-voted.

## `uploadDate` (type: `string`):

Only videos uploaded today, this week, this month or this year. Applied in Rumble's own channel and trending queries and in the keyword search.

## `duration` (type: `string`):

Short (4 minutes or less) or long (over 20 minutes), Rumble's own presets. Applied in Rumble's own channel query; checked on every other video.

## `fetchDetails` (type: `boolean`):

Adds the full description, categories, every video file with its size and bitrate, the audio track, caption tracks, frame rate, share and embed links to each video (two more pages per video). Charged as one video-details event per enriched video.

## `includeTranscripts` (type: `boolean`):

Adds the transcript (plain text and timed segments) from the video's caption track. Charged as one transcript event per video that has captions; videos without captions are not charged.

## `transcriptLanguages` (type: `array`):

Preferred caption languages, e.g. <code>en</code>. Empty: English, else the first track.

## `includeTranscriptSegments` (type: `boolean`):

With transcripts: also return the segments with start and end times in seconds.

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

Rows delivered (and charged) at most in this run, videos, channels and playlists together. 0 = no limit.

## `maxItemsPerInput` (type: `integer`):

Videos at most from each channel tab, playlist, list or keyword. Empty = no limit.

## `dateFrom` (type: `string`):

Only videos uploaded on or after this date (YYYY-MM-DD).

## `dateTo` (type: `string`):

Only videos uploaded on or before this date (YYYY-MM-DD).

## `publishedWithinDays` (type: `integer`):

Only videos uploaded in the last N days (a rolling window for scheduled runs).

## `minViews` (type: `integer`):

Only videos with at least this many views. Channel links are then read most viewed first (Rumble's own order, so reading stops at the first page under it), except in monitor mode.

## `maxViews` (type: `integer`):

Only videos with at most this many views.

## `minLikes` (type: `integer`):

Only videos with at least this many up-votes.

## `minComments` (type: `integer`):

Only videos with at least this many comments.

## `minDurationSeconds` (type: `integer`):

Only videos at least this long.

## `maxDurationSeconds` (type: `integer`):

Only videos at most this long.

## `shorts` (type: `string`):

Keep, drop or keep only Shorts.

## `livestreams` (type: `string`):

Keep, drop (live now or upcoming) or keep only livestreams.

## `titleContains` (type: `array`):

Only videos whose title (or description, when read) contains one of these words.

## `excludeKeywords` (type: `array`):

Drop videos whose title (or description) contains one of these words.

## `verifiedOnly` (type: `boolean`):

Only videos from (and channels that are) verified on Rumble.

## `minFollowers` (type: `integer`):

Channel keyword results: only channels with at least this many followers.

## `maxFollowers` (type: `integer`):

Channel keyword results: only channels with at most this many followers.

## `monitorMode` (type: `boolean`):

Remember every delivered video, channel and playlist id in a named dataset in your account (one small row per poll that finds something); later runs with the same input return only rows that are new, plus (once) videos delivered earlier without an add-on the run now asks for (changeType details). A poll with nothing new writes nothing and charges nothing.

## `monitorKey` (type: `string`):

Name of the monitor's memory (letters, digits, dashes). Different inputs keep separate memories under the same name.

## `emitViewChanges` (type: `boolean`):

Monitor mode: also return known videos whose views moved by at least the percentage below since the last run (changeType viewsChanged, previousViews, viewsChange).

## `viewChangePercent` (type: `integer`):

With view-count changes: the smallest change in percent that is reported.

## `resetMonitor` (type: `boolean`):

Forget what this monitor has seen and start over.

## `maxPagesPerList` (type: `integer`):

Pages read at most from each channel tab, category, list or playlist (25 videos a page; 50 for playlists).

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

Detail and video pages read at the same time.

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

Leave empty: the actor starts on direct egress and moves one step up (Apify datacenter, then residential) only if Rumble refuses it.

## Actor input object example

```json
{
  "startUrls": [
    "https://rumble.com/c/bongino",
    "https://rumble.com/c/TimcastIRL"
  ],
  "contentTypes": [
    "all"
  ],
  "includeChannelInfo": true,
  "includeChannelVideos": true,
  "includeChannelPlaylists": false,
  "includePlaylistVideos": true,
  "includePlaylistInfo": true,
  "channelSort": "date",
  "sort": "relevance",
  "uploadDate": "any",
  "duration": "any",
  "fetchDetails": false,
  "includeTranscripts": false,
  "includeTranscriptSegments": true,
  "maxItems": 50,
  "maxItemsPerInput": 10,
  "shorts": "include",
  "livestreams": "include",
  "verifiedOnly": false,
  "monitorMode": false,
  "monitorKey": "rumble-monitor",
  "emitViewChanges": false,
  "viewChangePercent": 10,
  "resetMonitor": false,
  "maxPagesPerList": 400,
  "maxConcurrency": 8
}
```

# Actor output Schema

## `results` (type: `string`):

One item per video, channel or playlist.

## `summary` (type: `string`):

Per-source counts (read, delivered, pages), filters, details and egress statistics (written for Console runs, large runs and runs with a problem).

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        "https://rumble.com/c/bongino",
        "https://rumble.com/c/TimcastIRL"
    ],
    "maxItemsPerInput": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("topapi/rumble-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [
        "https://rumble.com/c/bongino",
        "https://rumble.com/c/TimcastIRL",
    ],
    "maxItemsPerInput": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("topapi/rumble-scraper").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 '{
  "startUrls": [
    "https://rumble.com/c/bongino",
    "https://rumble.com/c/TimcastIRL"
  ],
  "maxItemsPerInput": 10
}' |
apify call topapi/rumble-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,topapi/rumble-scraper"
        }
    }
}
```

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/b9QPdM9lCNuq6NXM2/builds/IbXq691uVTawV98Kw/openapi.json
