# Rutube Video Downloader (`truefetch/rutube-video-downloader`) Actor

Process one publicly accessible Rutube video page for structured metadata and an optional stored video file. Choose metadata-only mode or a download quality preference.

- **URL**: https://apify.com/truefetch/rutube-video-downloader.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Videos, News, Integrations
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

Rutube Video Downloader converts one accessible Rutube video page into normalized metadata and can optionally store an available video file in Apify.

- The effective input surface has two fields and requires one Rutube video page URL.
- Four quality values distinguish metadata-only processing from three download preferences.
- The Dataset contract contains 39 fields covering identity, author, counters, media properties, run context, and delivery.
- Comment retrieval is not exposed; the reserved `comments` array is normally empty.

**[Run a one-result test](https://apify.com/truefetch/rutube-video-downloader)**

**[View API](https://apify.com/truefetch/rutube-video-downloader/api)**

Publish the Actor, replace the illustrative URL with an authorized public video, and verify metadata before downloading.

### What does Rutube Video Downloader do?

Rutube Video Downloader accepts the page for one Rutube video and maps the extractor response to an Apify Dataset item. The normalized record can include video identity, title, description, thumbnail, duration, publication time, author details, available engagement counters, dimensions, frame rate, audio labels, and processing context.

With metadata mode, the Actor does not transfer the media file. A low, medium, or high preference asks for an available video rendition and returns a storage URL when the file is produced. The source determines available resolutions and formats; the Actor cannot improve a rendition that Rutube does not serve.

The public scope excludes channels, playlists, categories, search pages, live streams, comments, user accounts, and private libraries. Removed, private, age-restricted, region-limited, or login-dependent media may not produce a result.

### How do I run Rutube Video Downloader?

Open the draft in Apify Console and confirm that the title, description, and input refer to Rutube. Copy one URL in the standard `/video/<identifier>/` shape. Do not submit a channel home, search result, category, playlist, studio page, or live broadcast.

This README uses one clearly illustrative identifier in every interface:

```json
{
  "video_url": "https://rutube.ru/video/557f03af71e5c6a7e931afd191e388f7/",
  "video_quality": "metadata"
}
```

Replace the placeholder identifier with a current public page that you may process. Start with metadata, then verify the returned ID, platform, title, and thumbnail against the browser page. Request a file only after identity is confirmed.

The input schema rejects extra properties. A cookie, login, proxy country, channel filter, or comment limit cannot be supplied through this public contract.

### What data does Rutube Video Downloader return?

The cross-platform output schema has these 39 fields:

| Group | Dataset fields |
|---|---|
| Provenance | `processor`, `processed_at` |
| Video | `id`, `thumbnail`, `platform`, `title`, `description`, `duration`, `published_at` |
| Author | `author`, `author_id`, `author_url` |
| Labels | `categories`, `tags` |
| Available statistics | `view_count`, `like_count`, `shares_count`, `dislike_count`, `comment_count` |
| Media details | `width`, `height`, `fps`, `audio_title`, `audio_artist` |
| Reserved and delivery | `comments`, `video` |

| Source and availability | `source_url`, `media_type`, `live_status`, `availability`, `age_limit`, `language` |
| Creator reach | `followers`, `is_verified` |
| File and captions | `file_ext`, `file_size`, `saves_count`, `subtitles`, `chapters` |
An abbreviated shape for the same illustrative page is:

```json
{
  "id": "0123456789abcdef0123456789abcdef",
  "platform": "Rutube",
  "title": "Example Rutube video",
  "author": "Example author",
  "thumbnail": "https://example.com/rutube-thumbnail.jpg",
  "duration": null,
  "comments": [],
  "video": ""
}
```

This is not a live Rutube response. It demonstrates types and nullability without claiming values for a nonexistent identifier. Some source fields may be absent. `comment_count` can hold a public numeric count when available, but the separate `comments` collection is not populated through public input. Metadata mode leaves `video` empty.

### What inputs can I configure?

The input contract is deliberately narrow:

| Input | Required | Meaning |
|---|---:|---|
| `video_url` | Yes | One publicly accessible Rutube video page. |
| `video_quality` | No | `metadata`, `low`, `medium`, or `high`; metadata avoids storing a file. |

The required field provides a URL-shaped placeholder. The optional selector has no prefill or example, preserving the distinction between an explicit value and omission; the runtime defaults an omitted quality to metadata.

There is no video ID array, channel, playlist, query, date, language, country, credential, batch, or comments option. A caller handling several videos must coordinate individual runs.

### What platforms and markets does Rutube Video Downloader cover?

Coverage is limited to individual Rutube video pages recognized by the installed yt-dlp extractor. The current local extractor list includes Rutube entries, but that observation is dated and platform changes can affect support.

The Actor does not select a country or language. Rutube pages can be published in different languages, and access can depend on the source asset, viewer location, maturity controls, deletion, or account requirements. The README therefore makes no universal availability claim.

Before release, prepare at least four cases: a public on-demand video, a malformed or nonexistent identifier, a channel or playlist URL that is out of scope, and an access-restricted video. When location is important, repeat the public case from representative run regions. Confirm ID, thumbnail, title, dimensions, and file outcome rather than treating a succeeded status as sufficient.

The illustrative all-zero-style identifier is suitable for documentation shape only and should fail a live content test. Keeping that expectation explicit prevents placeholder data from being mistaken for production proof.

For a successful public case, preserve a redacted evidence bundle containing the submitted URL shape, run region, start time, terminal status, detected extractor key, returned media ID, thumbnail host, requested quality, and whether a file appeared. Repeat the same case after dependency updates. Compare the identity fields before comparing counters, because view and reaction values can legitimately change between runs. A regression passes only when the Actor selects the intended video and the output remains contract-compatible.

Also test characters outside ASCII in a real title and description when an authorized page is available. Export the Dataset item as JSON and CSV, then confirm that text remains readable and fields do not shift columns. This validates delivery without making assumptions about the language used by every Rutube publisher.

### Why use Rutube Video Downloader?

A normalized item can connect an authorized Rutube video to systems that expect consistent field names. Media monitoring teams can capture title, author, publish time, thumbnail, duration, and available counters for a specific cited page. Developers can trigger a downstream webhook. An archive workflow can store a permitted file with processing provenance.

Metadata-first operation helps identify invalid, restricted, or unsupported pages before media transfer. The Dataset overview begins with the thumbnail so reviewers can spot mismatches. Nulls remain visible when Rutube does not expose a cross-platform field, which is safer than fabricated zeros.

Public adoption, ratings, reviews, incident history, Actor ID, and production success rates cannot yet be supported by evidence.

### Who is Rutube Video Downloader for?

Developers can add a single-Rutube-video step to an ingestion pipeline. Researchers and media teams can document public pages they are authorized to process. Archivists can retain approved media under their own policy. AI teams can pass a stored video to a separate transcription or classification service.

A Console user can test one URL without code.

The Actor is not intended for account export, channel mirroring, discovery search, live recording, audience collection, comment retrieval, access-control bypass, or legal rights determination. The caller remains responsible for permissions and retention.

### How can I use Rutube Video Downloader through the API or MCP?

The illustrative request has this API form:

```bash
curl -X POST "https://api.apify.com/v2/acts/truefetch~rutube-video-downloader/runs?token=$APIFY_TOKEN" \
 -H "Content-Type: application/json" \
 -d '{"video_url":"https://rutube.ru/video/557f03af71e5c6a7e931afd191e388f7/","video_quality":"metadata"}'
```

The same scenario in hosted MCP configuration is:

```json
{
  "mcpServers": {
    "apify-rutube": {
      "url": "https://mcp.apify.com?tools=truefetch/rutube-video-downloader",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  },
  "exampleToolArguments": {
    "video_url": "https://rutube.ru/video/557f03af71e5c6a7e931afd191e388f7/",
    "video_quality": "metadata"
  }
}
```

Publication is required before tool discovery. Protect the token and follow the [official Apify MCP instructions](https://docs.apify.com/integrations/mcp).

### How much does Rutube Video Downloader cost?

| Declared event | Unit | Local price |
|---|---|---:|
| `apify-actor-start` | Actor start | $0.01 |
| `actor_usage` | Metered usage event | $0.00001 |
| `metadata` | One video processed without download | $0.11 |
| `download` | One video processed with file storage | $0.26 |

The smallest metadata attempt declares $0.12 in fixed start and result events before metered usage and platform costs. A download declares the $0.26 result event instead of metadata.

Verify live pricing and completed-run charges.

### How does Rutube Video Downloader compare with alternatives?

| Option | Appropriate when | Limitation |
|---|---|---|
| Rutube Video Downloader | One public Rutube video needs normalized metadata or a stored file | Publication and representative access validation remain pending. |
| Manual page workflow | A person reviews one video once | Lacks repeatable Dataset, API, and MCP delivery. |
| Rutube owner tools | The account owner manages media through first-party controls | Requires the relevant account and follows current platform features. |
| Best Video Downloader | A pipeline receives URLs from multiple supported hosts | Broader contract with less Rutube-specific boundary guidance. |

Use first-party tools for account-wide management. This Actor is designed for a narrow, URL-driven processing step.

### What are the limits and troubleshooting steps?

Only one on-demand video URL is supported per run. There are no channel, playlist, live, search, country, language, credential, batch, or comments inputs. Output fields may be null, and download quality cannot exceed available renditions.

If no record appears, first replace the placeholder with a real page. Open it in a private browser window and verify that media plays without login. Confirm the `/video/<identifier>/` shape and retry metadata mode. Do not use a channel or studio URL.

If a download request returns no `video`, inspect the run log and key-value store. The asset may be restricted, deleted, unavailable from the run location, or missing a compatible rendition. Never translate a missing counter into zero. No public Issues page was available to establish incident history.

Schedules reprocess one configured URL; they do not discover uploads. Expect availability to change and define your own deduplication and retention rules.

### Frequently asked questions

#### Which Rutube address format works best?

Use the canonical `rutube.ru/video/<hash>/` address with the trailing slash. Embed and player addresses can resolve to a shell page that omits the uploader and engagement fields, which leaves `author`, `author_id`, and the counters null.

#### Can it download a channel or playlist?

No. The documented unit is one on-demand video page.

#### Does it retrieve comments?

No comment input exists; the reserved array is normally empty.

#### Can it bypass a regional or login restriction?

No credentials or location selector is exposed.

#### Does high guarantee a specific resolution?

No. The source renditions determine the result.

#### Why are fields null?

Rutube or the extractor did not supply them. Null is not zero.

#### Can it process a live stream?

Live recording is outside this contract.

#### Why can a Rutube run take longer than other sources?

Rutube serves manifests from regional edges, and the first request may negotiate several redirects before the media description is available. Metadata mode still completes well inside the run timeout; allow more headroom when you request a download of a long recording.

#### What should I check when a Rutube field arrives empty?

First confirm which field group is affected. An empty `author` or `author_id` usually means the address resolved to a player shell rather than the canonical video page, so re-submit the `rutube.ru/video/<hash>/` form. Empty engagement counters more often mean the source simply did not publish them for that title, which is expected and is why the contract uses null instead of zero. If `video` is empty after a download run, check the run logs and key-value storage before assuming the media was unavailable.

### Related TrueFetch Actors

- [Best Video Downloader](https://apify.com/truefetch/best-video-downloader) handles supported media across several hosts.
- [Video To Text](https://apify.com/truefetch/video-to-text) transcribes authorized video or audio.
- [Video Subtitles Downloader](https://apify.com/truefetch/video-subtitles-downloader) retrieves available subtitle tracks.

### Support

- [Apify Actor dashboard](https://apify.com/truefetch/rutube-video-downloader)
- [Apify Actor API reference](https://apify.com/truefetch/rutube-video-downloader/api)
- [Apify MCP documentation](https://docs.apify.com/integrations/mcp)
- [yt-dlp supported-sites reference](https://github.com/yt-dlp/yt-dlp/blob/master/supportedsites.md)
- [TrueFetch community](https://t.me/TrueFetch)
- [Direct support](https://t.me/AiAgentApi)

Include the Actor link, stable ID, redacted real URL, access condition, and run ID in support requests.

**[Run a one-result test](https://apify.com/truefetch/rutube-video-downloader)**

**[View API](https://apify.com/truefetch/rutube-video-downloader/api)**

# Actor input Schema

## `video_url` (type: `string`):

Publicly accessible Rutube video page URL to process.

## `video_quality` (type: `string`):

Preferred download quality, or metadata-only mode without a video file.

## Actor input object example

```json
{
  "video_url": "https://rutube.ru/video/557f03af71e5c6a7e931afd191e388f7/"
}
```

# Actor output Schema

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

All video details and optional download links with full engagement stats and comments

# 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 = {
    "video_url": "https://rutube.ru/video/557f03af71e5c6a7e931afd191e388f7/"
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/rutube-video-downloader").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 = { "video_url": "https://rutube.ru/video/557f03af71e5c6a7e931afd191e388f7/" }

# Run the Actor and wait for it to finish
run = client.actor("truefetch/rutube-video-downloader").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 '{
  "video_url": "https://rutube.ru/video/557f03af71e5c6a7e931afd191e388f7/"
}' |
apify call truefetch/rutube-video-downloader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=truefetch/rutube-video-downloader",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

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