# Twitter Video Downloader (`scraperoka/twitter-video-downloader`) Actor

🚀 Download Twitter videos fast with Twitter Video Downloader! 📥 Save HD clips, reels & GIFs in seconds. 🔥 Simple, secure, and easy to use—just paste the link and go! ✅ Perfect for creators, marketers & everyday sharing. 📱

- **URL**: https://apify.com/scraperoka/twitter-video-downloader.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Videos, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### Twitter Video Downloader ⚡ — Extract High-Quality Media Links from Twitter/X Status URLs

Manually visiting Twitter/X links to find the actual downloadable video URL wastes time, especially when you need media links in bulk. **Twitter Video Downloader** extracts the direct `downloadUrl` (and the best available `sourceUrl`) from your provided Twitter/X status URLs—ideal for marketers, researchers, and growth teams that need faster media sourcing. This **Twitter Video Downloader** supports a “twitter video downloader” workflow for teams using a “twitter video download” process at scale, potentially processing thousands of links in minutes.

***

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "sourceUrl": "https://t.co/AbCdEfGhIj",
  "downloadUrl": "https://video.twimg.com/ext_tw_video/1234567890123456789/pu/vid/720x1280/abcdefg12345678.mp4?tag=14"
}
```

| Field | Type | What It Tells You |
|---|---|---|
| `sourceUrl` | string | The resolved link the actor uses as the “source” (it prefers a `t.co` link from the status description when present) |
| `downloadUrl` | string | The direct media URL you can use to download the video (or fall back to the original link when needed) |
| `charged_event_name` | string | Indicates the record was pushed to your run results (shown as `"result"` when the actor streams output) |
| `success` | string | There is no explicit `success` field in the pushed record; treat absence of failures as success for each pushed item |
| `error` | string | When an error occurs, the actor logs the issue for that specific input URL (there is no `error_message` field in the pushed output record) |
| `status` | string | There is no explicit `status` field in the pushed output record |
| `originalUrl` | string | Not provided as a separate field; the actor uses `info.get('original_url', url)` internally to resolve `sourceUrl` |
| `description` | string | Not provided as a separate field; the actor reads `info.get('description', '')` internally to detect `t.co` links |
| `url` | string | Not provided as a separate field; the actor reads `info.get('url')` internally to set `downloadUrl` |
| `timestamp` | string | Not provided in the pushed record |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Twitter Video Downloader?

There are a lot of ways to pull data from Twitter/X links — here’s what sets **Twitter Video Downloader** apart.

#### Direct `downloadUrl` Extraction for Media Reuse

This actor focuses on returning the usable media link you need: `downloadUrl`. If a direct media URL is available from the input, you get it right away—great for “download twitter videos” and “twitter to mp4 downloader” style workflows.

#### Smart `sourceUrl` Resolution from Public Status Content

When the status description contains shortened `t.co` links, the actor resolves and uses the first matching `t.co` link as `sourceUrl`. That makes it easier to trace each `downloadUrl` back to the associated status context for review.

#### Built for Bulk Runs with Real-Time Dataset Writing

Results are pushed immediately as each URL is processed. That means you can start exporting while a long list is still running, which is ideal when you’re building a “twitter video saver” pipeline.

#### Resilient Execution with Error Logging per Input URL

If one URL fails, the actor logs the error for that specific input and continues processing the rest of your `startUrls`. This reduces the “all-or-nothing” problem when running large batches.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "startUrls": [
    "https://x.com/TinaDebove/status/1967637722476212406"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `startUrls` | ✅ | List of Twitter/X status URLs to scrape and extract media links from |
| `proxyConfiguration` | ⬜ | Choose proxy settings for the run to help with reliable scraping |
| ↳ `proxy support` | ⬜ | When enabled, routes traffic through Apify Proxy |
| ↳ `proxy support` | ⬜ | Selects which proxy group(s) to use (for example, `"RESIDENTIAL"`) |

***

### Core Capabilities

#### Media Links from Twitter/X Status URLs

You provide `startUrls` as Twitter/X status links, and the actor returns `downloadUrl` for direct media access. This makes it straightforward to power “download twitter video mp4” style workflows without manual link hunting.

#### Input Flexibility for Bulk Processing

Send a list of many status URLs at once. Each entry produces an output record with `sourceUrl` and `downloadUrl`, letting you quickly build a bulk “x video downloader” dataset for downstream use.

#### Resilience for Large Lists

The actor handles failures per URL: errors are logged, and processing continues for the remaining inputs. That behavior is especially helpful when you’re running a “twitter video downloader online” job across diverse links.

#### Structured, Integration-Ready Output

Every pushed record follows a consistent JSON structure with `sourceUrl` and `downloadUrl`. That consistency makes it easy to plug results into your internal tools or data workflows (including quick exports and filtering).

#### Dataset Streaming for Faster Visibility

Records are pushed immediately during processing, so you don’t have to wait until the entire run finishes to start reviewing or exporting. This accelerates testing and iteration on your “twitter video download” pipeline.

***

### Who Gets the Most Out of This

Here's how different teams put **Twitter Video Downloader** to work:

**Media Ops Teams** — collect `downloadUrl` links from a curated set of Twitter/X posts so editors can quickly retrieve videos without manually resolving each link. The outcome is a ready-to-use media link list for fast publishing workflows.

**Marketing and Growth Teams** — when a campaign relies on customer or creator clips, they can batch process status URLs and save direct media links for reuse. The outcome is time saved during content production and repurposing.

**Researchers and Data Analysts** — convert a list of public Twitter/X posts into a structured dataset containing `sourceUrl` and `downloadUrl`. The outcome is clean, exportable JSON you can analyze, deduplicate, or join with other sources.

**Automation Specialists (Developers / Data Engineers)** — wire **Twitter Video Downloader** into an end-to-end pipeline that ingests lists of Twitter/X status URLs and writes results to an Apify dataset for programmatic consumption. The outcome is repeatable media link extraction at scale.

**Community and Creator Managers** — maintain a “save twitter video” workflow for outreach reviews, content archiving, or shortlisting clips for collabs. The outcome is a centralized set of direct media links tied to each original status.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Twitter Video Downloader from start to finish:

1. **Open the actor on Apify** — visit [console.apify.com](https://console.apify.com) and open the Twitter Video Downloader actor page.
2. **Enter your inputs** — add your list of Twitter/X status links to `startUrls` and optionally configure `proxyConfiguration`.
3. **Configure proxy settings** — if you want improved reliability, enable and select proxy settings in `proxyConfiguration`.
4. **Hit Run and watch the live log** — track progress as each `startUrls` entry is processed.
5. **View results in the dataset tab** — each processed item is stored as a record with `sourceUrl` and `downloadUrl`.
6. **Export as JSON, CSV, or Excel** — download your dataset directly from the Apify dashboard for your “download x videos” workflow.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, **Twitter Video Downloader** plugs directly into your existing workflow. You can export from the Apify dataset tab in JSON, CSV, or Excel formats for quick handoff to spreadsheets, analysts, or downstream systems.

Use the Apify platform integrations (and the Apify API) to move results into your stack. If you want automation, you can connect it with Zapier/Make-style no-code flows, and schedule it to run automatically on a recurring schedule.

For more details, see Apify documentation for API access and automations: https://apify.com/docs/api

***

### Pricing & Free Trial

**Twitter Video Downloader** runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You can use free credits for several test runs and validate outputs before scaling.

For production usage, billing is based on Apify’s platform compute model. Exact pricing details depend on the plan and current Apify pricing—check the pricing page for up-to-date numbers.

Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate limiting | Built for reliable scraping with proxy support to maintain steady runs |
| Proxy reliability | Uses your selected proxy configuration for better consistency |
| Partial failures | Errors are logged per input URL so one failure doesn’t stop the whole batch |
| Data freshness | Extracts media metadata/links directly from the provided Twitter/X status URLs |
| Output availability | Pushes results immediately during processing so you can monitor progress in real time |
| Scale limits | Designed to handle batch lists provided via `startUrls` |

Limitations: This actor works with publicly accessible data related to the Twitter/X links you provide. If a status doesn’t expose a direct downloadable media link, `downloadUrl` may fall back to the resolved source link behavior described in the output fields. For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial for Twitter Video Downloader?

Yes. Apify provides a free tier with credits so you can run Twitter Video Downloader and verify `downloadUrl` extraction before scaling.

#### Do I need to log in to Twitter/X to use this?

No. You only need to provide public Twitter/X status URLs in `startUrls`. The actor extracts media-related links from publicly available content.

#### How accurate is the data?

It’s as accurate as what the provided status URLs expose. The actor extracts `downloadUrl` when available and resolves `sourceUrl` using the provided link and any `t.co` link found in the status description.

#### How many results can I get per run?

Your results correspond to how many items you include in `startUrls`. Each input URL processed pushes one record containing `sourceUrl` and `downloadUrl`.

#### How often is the data updated / how fresh is it?

The actor extracts fresh media metadata/links at run time. If you re-run the same `startUrls` later, you’ll get a new extraction of what’s available then.

#### Is this legal? Does it comply with GDPR / CCPA?

You should use Twitter Video Downloader for content you’re authorized to process and store. The actor operates on **publicly available data**, but it’s your responsibility to comply with GDPR, CCPA, and any applicable platform rules.

#### Can I export results to Google Sheets or Excel?

Yes. You can export your dataset from the Apify dashboard as JSON, CSV, or Excel. From there, you can import into tools like Google Sheets.

#### Can I run this on a schedule automatically?

Yes. You can use Apify’s scheduling capabilities to run Twitter Video Downloader automatically on a recurring basis, using the same `startUrls` structure.

#### Can I access this via API?

Yes. You can run the actor via the Apify API and retrieve results programmatically. Check the Apify API docs for how to trigger runs and read datasets.

#### What happens if the actor hits an error?

If an input URL fails, the actor logs the error for that specific URL and continues processing the remaining `startUrls`. Output records that were already pushed to the dataset remain available for export.

***

### Need Help or Have a Request?

Got a question about Twitter Video Downloader or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re actively maintaining this actor and welcome requests that improve bulk “twitter video downloader” workflows, like better handling of more input variations or adding richer output fields. Tell us what you’re trying to build and we’ll respond.

***

### Disclaimer & Responsible Use

*Twitter Video Downloader is the fastest, most reliable way to extract direct Twitter/X media links — start your free run today.*

The actor accesses **publicly available data** from the Twitter/X links you provide. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, and any applicable platform terms. For data-removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

List of Twitter/X status URLs to scrape.

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

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "startUrls": [
    "https://x.com/TinaDebove/status/1967637722476212406"
  ],
  "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 = {
    "startUrls": [
        "https://x.com/TinaDebove/status/1967637722476212406"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/twitter-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 = { "startUrls": ["https://x.com/TinaDebove/status/1967637722476212406"] }

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/twitter-video-downloader").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://x.com/TinaDebove/status/1967637722476212406"
  ]
}' |
apify call scraperoka/twitter-video-downloader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scraperoka/twitter-video-downloader"
        }
    }
}

```

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/O014tbtTXA5o60tWL/builds/kaveLeK9YCgZd6yn1/openapi.json