# Twitter Video Downloader — X Video & Tweet Metadata (`scrapepilot/twitter-video-downloader----x-video-tweet-metadata`) Actor

Download Twitter and X videos in bulk. Get all quality MP4 URLs plus full tweet metadata — likes, retweets, views, replies, author profile, duration, and thumbnail. Supports x.com & twitter.com links. No login. $9.99/month. 2-hour free trial.

- **URL**: https://apify.com/scrapepilot/twitter-video-downloader----x-video-tweet-metadata.md
- **Developed by:** [Scrape Pilot](https://apify.com/scrapepilot) (community)
- **Categories:** Videos, Social media, Automation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$9.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

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

## 🐦 Twitter Video Downloader — X Video Download & Tweet Metadata

> **The most reliable Twitter Video Downloader on Apify.** Extract direct MP4 download URLs at every available bitrate, complete tweet metadata, engagement metrics, and author details from any public Twitter/X video tweet — in bulk. No login. No API key. Residential proxy ready. Instant structured output.

---

### 📌 Table of Contents

- [What Is This Actor?](#what-is-this-actor)
- [Why Use This Twitter Video Downloader?](#why-use-this-twitter-video-downloader)
- [Use Cases](#use-cases)
- [Input Parameters](#input-parameters)
- [Output Fields](#output-fields)
- [Example Input & Output](#example-input--output)
- [Pricing & Free Trial](#pricing--free-trial)
- [Performance & Limits](#performance--limits)
- [FAQ](#faq)
- [Changelog](#changelog)
- [Legal & Terms of Use](#legal--terms-of-use)

---

### 🔍 What Is This Actor?

**Twitter Video Downloader & X Video Metadata Extractor** is a production-ready Apify actor that delivers direct MP4 download URLs at every available quality level — plus complete **Twitter video metadata** — from any public Twitter/X video tweet.

Provide one or many tweet URLs or tweet IDs and receive back a clean, consistently structured record for each video: tweet text, author profile, engagement metrics (likes, retweets, replies, views), thumbnail, duration, aspect ratio, and all available video quality URLs sorted by bitrate from highest to lowest.

This **X video downloader** works entirely without login, without Twitter API credentials, and without any manual steps. Paste your tweet URLs and get results instantly — whether you need one video or a thousand.

---

### 🚀 Why Use This Twitter Video Downloader?

| Feature | This Actor | Manual Download | Browser Extensions | Twitter API |
|---|---|---|---|---|
| **Twitter video downloader — bulk** | ✅ | ❌ One-by-one | ❌ One-by-one | ❌ Paid tier |
| **All quality levels returned** | ✅ Every bitrate | ⚠️ One quality | ⚠️ | ❌ |
| **Twitter video metadata — full set** | ✅ 15+ fields | ❌ | ❌ | ⚠️ Limited |
| **Likes, retweets, replies & views** | ✅ | ❌ | ❌ | ⚠️ Paid |
| **Author profile & username** | ✅ | ❌ | ❌ | ⚠️ |
| **Tweet text & display text** | ✅ Both | ❌ | ❌ | ✅ |
| **Duration & aspect ratio** | ✅ | ❌ | ❌ | ❌ |
| **No login or API key** | ✅ | ✅ | ✅ | ❌ Required |
| **Structured JSON — export-ready** | ✅ | ❌ | ❌ | ⚠️ |
| **CSV / Excel export** | ✅ Via Apify | ❌ | ❌ | ❌ |

> **Bottom line:** This **X video downloader** is the only actor that returns every available video quality alongside a complete **Twitter video metadata** record — engagement metrics, author details, and tweet content — in a single run with no credentials needed.

---

### 🎯 Use Cases

#### 📥 Twitter Video Download & Archiving
- Download Twitter and X videos in bulk for backup before tweets are deleted or accounts suspended
- Archive brand videos, product announcements, and viral tweet content with full metadata
- Preserve public interest X videos as timestamped evidence or documentation records

#### 📊 Twitter Video Metadata Research & Analytics
- Collect Twitter video metadata — likes, retweets, replies, views — for engagement benchmarking
- Analyze which video types and topics drive the highest engagement on Twitter/X
- Monitor competitor X video performance by tracking view and like counts over time

#### 🤖 AI & Machine Learning Datasets
- Extract X video download URLs in bulk to build training datasets for video AI models
- Collect tweet text and descriptions for NLP, sentiment analysis, or content classification
- Scrape Twitter video metadata at scale for recommendation system or content moderation training

#### 🔬 Social Media Research & Journalism
- Download Twitter videos and X content as verified evidence for investigative reporting
- Study virality patterns by correlating video engagement metrics with content type
- Build structured datasets of tweet videos for academic media research or platform studies

#### 🛠️ Developer & Content Pipeline Integrations
- Build a **Twitter video downloader** pipeline that resolves MP4 URLs on demand for your application
- Automate X video ingestion into your media library, CMS, or content management platform
- Integrate Twitter video metadata into dashboards, monitoring tools, or analytics systems

#### 🎓 Brand Monitoring & Marketing Intelligence
- Track how brand-related X video content performs across engagement dimensions
- Collect video metadata from key accounts in your industry for competitive analysis
- Monitor viral video trends on Twitter/X to inform content strategy decisions

---

### ⚙️ Input Parameters

```json
{
  "tweetUrls": [
    "https://x.com/username/status/1234567890123456789",
    "https://twitter.com/username/status/9876543210987654321"
  ],
  "videoOnly":          false,
  "includeAllQualities": true,
  "includeMetadata":    true
}
````

| Parameter | Type | Default | Description |
|---|---|---|---|
| `tweetUrls` | array or string | `[]` | Twitter/X tweet URLs or tweet IDs — supports both `x.com` and `twitter.com` links |
| `videoOnly` | boolean | `false` | When `true`, skips tweets that contain no video and only returns video records |
| `includeAllQualities` | boolean | `true` | When `true`, returns all available video quality URLs. When `false`, returns only the highest quality URL |
| `includeMetadata` | boolean | `true` | When `true`, includes full engagement metrics (likes, retweets, replies, views) in every record |

> **Tip:** Both `x.com` and `twitter.com` URLs are accepted interchangeably. Tweet IDs (numeric strings) are also accepted directly in the `tweetUrls` array.

***

### 📋 Output Fields

Every record from this **Twitter Video Downloader** includes complete **Twitter video metadata** in a fixed, consistent structure:

#### 🐦 Tweet Fields

| Field | Type | Description | Example |
|---|---|---|---|
| `tweetId` | string | Unique tweet ID | `"1234567890123456789"` |
| `tweetUrl` | string | Canonical X.com URL | `"https://x.com/i/status/1234..."` |
| `status` | string | Extraction status | `"success"` |
| `mediaType` | string | Content type detected | `"video"`, `"image"` |
| `text` | string | Full tweet text / caption | `"This is absolutely incredible 🔥"` |
| `displayText` | string | Display title from tweet | `"Watch this..."` |
| `createdAt` | string | Tweet upload date (YYYYMMDD) | `"20240315"` |
| `language` | string | Detected tweet language | `"en"` |
| `duration` | string | Video duration (M:SS) | `"1:24"` |
| `durationMs` | integer | Duration in milliseconds | `84000` |
| `aspectRatio` | string | Video aspect ratio | `"16:9"` |
| `thumbnail` | string | Video thumbnail URL | `"https://pbs.twimg.com/..."` |
| `quality` | string | Best available quality label | `"2176kbps"` |
| `downloadUrl` | string | Best quality direct MP4 URL | `"https://video.twimg.com/..."` |
| `timestamp` | string | Extraction time (ISO 8601 UTC) | `"2024-03-15T10:30:00Z"` |

#### 👤 Author Object

| Field | Type | Description | Example |
|---|---|---|---|
| `author.name` | string | Display name | `"NASA"` |
| `author.username` | string | Twitter/X handle | `"NASA"` |
| `author.profileImage` | string | Profile image URL | `"https://pbs.twimg.com/..."` |

#### 📈 Engagement Object *(when `includeMetadata: true`)*

| Field | Type | Description | Example |
|---|---|---|---|
| `engagement.likes` | string | Formatted like count | `"85.0K"` |
| `engagement.retweets` | string | Formatted retweet count | `"12.3K"` |
| `engagement.replies` | string | Formatted reply count | `"3.2K"` |
| `engagement.views` | string | Formatted view count | `"2.4M"` |

#### 🎬 Video Qualities Array *(when `includeAllQualities: true`)*

Each entry in `videoQualities` contains a direct MP4 URL at a specific bitrate — sorted from highest to lowest quality:

```json
[
  { "url": "https://video.twimg.com/.../720x1280.mp4", "bitrate": 2176000, "quality": "2176kbps", "contentType": "video/mp4" },
  { "url": "https://video.twimg.com/.../360x640.mp4",  "bitrate": 832000,  "quality": "832kbps",  "contentType": "video/mp4" },
  { "url": "https://video.twimg.com/.../240x426.mp4",  "bitrate": 256000,  "quality": "256kbps",  "contentType": "video/mp4" }
]
```

***

### 📦 Example Input & Output

**Input:**

```json
{
  "tweetUrls": ["https://x.com/NASA/status/1234567890123456789"],
  "includeAllQualities": true,
  "includeMetadata": true
}
```

**Output:**

```json
{
  "tweetId":     "1234567890123456789",
  "tweetUrl":    "https://x.com/i/status/1234567890123456789",
  "status":      "success",
  "mediaType":   "video",
  "text":        "Watch our latest launch highlights from Kennedy Space Center 🚀",
  "displayText": "NASA Launch Highlights",
  "createdAt":   "20240315",
  "language":    "en",
  "author": {
    "name":         "NASA",
    "username":     "NASA",
    "profileImage": "https://pbs.twimg.com/profile_images/..."
  },
  "engagement": {
    "likes":    "124.5K",
    "retweets": "38.2K",
    "replies":  "4.1K",
    "views":    "8.7M"
  },
  "thumbnail":   "https://pbs.twimg.com/ext_tw_video_thumb/.../img/thumb.jpg",
  "duration":    "1:24",
  "durationMs":  84000,
  "aspectRatio": "16:9",
  "quality":     "2176kbps",
  "downloadUrl": "https://video.twimg.com/ext_tw_video/.../720x1280.mp4",
  "videoQualities": [
    { "url": "https://video.twimg.com/.../720x1280.mp4", "bitrate": 2176000, "quality": "2176kbps", "contentType": "video/mp4" },
    { "url": "https://video.twimg.com/.../360x640.mp4",  "bitrate": 832000,  "quality": "832kbps",  "contentType": "video/mp4" }
  ],
  "timestamp": "2024-03-15T10:30:00Z"
}
```

***

### 💰 Pricing & Free Trial

| Plan | Price | Includes |
|---|---|---|
| **Free Trial** | $0 | 2 hours full access — no credit card required |
| **Monthly** | $8.99 / month | Unlimited runs, bulk URLs, all quality levels |

#### Everything included in every plan:

- ✅ All available video quality URLs — every bitrate in one record
- ✅ Complete Twitter video metadata — 15+ fields per tweet
- ✅ Engagement metrics: likes, retweets, replies, views
- ✅ Author profile: name, username, profile image
- ✅ `videoOnly` filter — skip non-video tweets automatically
- ✅ Supports both `x.com` and `twitter.com` URLs
- ✅ Bulk processing — any volume per run
- ✅ JSON + CSV + Excel export from Apify dataset
- ✅ Scheduled runs for automated X video monitoring

> **Start your 2-hour free trial now** — no credit card needed. Click **Try for free** at the top of this page.

***

### ⚡ Performance & Limits

| Mode | Count | Estimated Time |
|---|---|---|
| Single tweet video | 1 | ~8–15 seconds |
| Small batch | 10 | ~2–3 minutes |
| Medium batch | 50 | ~8–15 minutes |
| Large batch | 100 | ~18–30 minutes |

- Results are pushed to the Apify dataset in real time as each tweet is processed
- Per-tweet error isolation — one failed tweet never stops the rest of the batch
- Non-video tweets are logged and skipped cleanly when `videoOnly: true`
- Duplicate tweet IDs in your input are removed automatically before processing

***

### ❓ FAQ

**Q: Does this actor work with both `twitter.com` and `x.com` URLs?**
A: Yes. Both URL formats are accepted and processed identically. You can mix them freely in the same `tweetUrls` array.

**Q: What is the difference between `downloadUrl` and `videoQualities`?**
A: `downloadUrl` always points to the highest available quality MP4 for quick use. `videoQualities` is the full array of all available bitrate options — useful when you need a specific file size or want to offer quality selection in your own application.

**Q: Does this actor download video files to Apify's servers?**
A: No. The actor extracts and returns **direct signed CDN URLs** from Twitter's video hosting infrastructure. No files are stored on Apify. You use `downloadUrl` to download the video to your own system.

**Q: How long are the video download URLs valid?**
A: Twitter/X CDN URLs are signed and expire within a few hours. Use them immediately after the run, or re-run the actor to refresh them.

**Q: Can I use this X video downloader on private or protected accounts?**
A: No. Only publicly accessible tweets from public accounts are supported. Protected accounts and login-gated content are not supported.

**Q: What does `videoOnly: true` do?**
A: When enabled, tweets that contain no video are automatically skipped and not included in the output. This is useful when your input list contains a mix of video and non-video tweet URLs.

**Q: Can I get engagement metrics for every tweet?**
A: Yes. Set `includeMetadata: true` (the default) and every record will include the full `engagement` object with likes, retweets, replies, quotes, bookmarks, and views — all formatted for readability (e.g. `"8.7M"`, `"124.5K"`).

**Q: Can I export results to Excel or CSV?**
A: Yes. All results are pushed to the Apify dataset, which can be exported to JSON, CSV, Excel, and more directly from the Apify Console after the run completes.

***

### 📜 Changelog

#### v2.0.0 (Current)

- ✅ All available video qualities returned — sorted by bitrate, highest first
- ✅ Complete Twitter video metadata: tweet text, display text, language, date, duration, aspect ratio
- ✅ Full engagement object: likes, retweets, replies, quotes, bookmarks, views
- ✅ Author profile object: name, username, profile image
- ✅ `videoOnly` filter — skip non-video tweets automatically
- ✅ `includeAllQualities` flag — control output size vs. completeness
- ✅ `includeMetadata` flag — toggle engagement data on/off
- ✅ Supports both `x.com` and `twitter.com` URL formats
- ✅ Tweet ID input accepted directly (no full URL required)
- ✅ Automatic duplicate tweet ID removal
- ✅ Per-tweet error isolation — batch never stops on a single failure
- ✅ Real-time dataset push as each tweet is processed

#### v1.0.0

- Initial release with basic Twitter video URL and tweet text extraction

***

### 🏷️ Tags

`twitter video downloader` `x video downloader` `twitter video metadata` `tweet video download` `x.com video scraper` `twitter mp4 downloader` `tweet metadata scraper` `twitter engagement data` `x video extractor` `social media video downloader` `download video from twitter` `twitter data extraction`

***

### ⚖️ Legal & Terms of Use

This actor extracts publicly accessible Twitter/X video metadata and CDN stream URLs in the same way a regular user views tweet content through a browser.

**Please note:**

- Use this tool only for **personal backup, research, archiving, journalism, and education**
- Only download content that you have the right to access and store
- Redistributing copyrighted Twitter/X video content without authorization may violate copyright law and X's Terms of Service
- Do not use this tool to scrape personal data, target private individuals, or facilitate harassment
- The actor developer is not responsible for how users choose to use the extracted content or metadata

***

### 🤝 Support & Feedback

- **Bug report?** Contact us via the Apify actor page
- **Feature request?** Post in the Apify Community forum
- **Loving it?** Please leave a ⭐ review — it helps other users find this actor!

***

<p align="center">
  <strong>Built with ❤️ on Apify</strong><br/>
  <em>The most reliable Twitter Video Downloader — all quality levels, full X video metadata, no login required</em><br/><br/>
  <strong>💰 $9.99/month · 🆓 2-hour free trial · No credit card required</strong>
</p>

# Actor input Schema

## `tweetUrls` (type: `array`):

List of Tweet URLs or Tweet IDs. Supports x.com and twitter.com.

## `videoOnly` (type: `boolean`):

Enable to download only tweets with videos. Tweets with only photos will be skipped.

## `includeAllQualities` (type: `boolean`):

Include all available quality versions of videos (from 256kbps to 25Mbps).

## `includeMetadata` (type: `boolean`):

Extract comprehensive metadata including tweet text, author details, and engagement metrics.

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

Select proxies to be used by the actor. Residential proxies are highly recommended for X.com.

## Actor input object example

```json
{
  "videoOnly": false,
  "includeAllQualities": true,
  "includeMetadata": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapepilot/twitter-video-downloader----x-video-tweet-metadata").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scrapepilot/twitter-video-downloader----x-video-tweet-metadata").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 '{}' |
apify call scrapepilot/twitter-video-downloader----x-video-tweet-metadata --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitter Video Downloader — X Video & Tweet Metadata",
        "description": "Download Twitter and X videos in bulk. Get all quality MP4 URLs plus full tweet metadata — likes, retweets, views, replies, author profile, duration, and thumbnail. Supports x.com & twitter.com links. No login. $9.99/month. 2-hour free trial.",
        "version": "0.0",
        "x-build-id": "FGjHZfoNrOnTGNeSv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilot~twitter-video-downloader----x-video-tweet-metadata/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilot-twitter-video-downloader----x-video-tweet-metadata",
                "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/scrapepilot~twitter-video-downloader----x-video-tweet-metadata/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilot-twitter-video-downloader----x-video-tweet-metadata",
                "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/scrapepilot~twitter-video-downloader----x-video-tweet-metadata/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilot-twitter-video-downloader----x-video-tweet-metadata",
                "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",
                "required": [
                    "tweetUrls"
                ],
                "properties": {
                    "tweetUrls": {
                        "title": "Tweet URLs",
                        "type": "array",
                        "description": "List of Tweet URLs or Tweet IDs. Supports x.com and twitter.com.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "videoOnly": {
                        "title": "Video Only",
                        "type": "boolean",
                        "description": "Enable to download only tweets with videos. Tweets with only photos will be skipped.",
                        "default": false
                    },
                    "includeAllQualities": {
                        "title": "Include All Qualities",
                        "type": "boolean",
                        "description": "Include all available quality versions of videos (from 256kbps to 25Mbps).",
                        "default": true
                    },
                    "includeMetadata": {
                        "title": "Include Metadata",
                        "type": "boolean",
                        "description": "Extract comprehensive metadata including tweet text, author details, and engagement metrics.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used by the actor. Residential proxies are highly recommended for X.com.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
