Twitter Video Downloader: Up to 500 Free Results a Month (2026)

Each downloaded file produces one dataset record carrying 18 fields, including direct, signed download links for MP4 videos, high-resolution photos, and GIFs. This media downloader extracts the highest quality available, automatically converting fragmented MP4 streams into unified, playable files. It is designed for researchers, archivists, and content creators who need programmatic access to Twitter/X assets. This tool is not for teams trying to scrape user interaction networks or extract video text, as it does not generate subtitles; those who require text-based transcripts should use the dedicated transcript extraction tools instead.

Try it before you read further. Apify's free plan includes $5.00 of usage every month with no credit card, enough for up to 500 results at $0.01 each before platform usage. Open Twitter Video Downloader on Apify and run the prefilled example.

How reliable is Twitter Video Downloader in production?

Across the last 30 days of public runs on the Apify platform, Twitter Video Downloader recorded 65 runs with the following outcomes.

With a 98.5% success rate over the last 30 days, you can reliably run this Actor on an unattended schedule. Only about 2 in a hundred runs failed or timed out, indicating a highly stable integration with the platform. To maintain this level of consistency, ensure your browser cookies are refreshed regularly to prevent session expirations from halting your scheduled workflows.

What does it cost to run Twitter Video Downloader?

Each result costs $0.01 on Apify's free plan, which is $10.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

Worked example: collecting 10,000 results costs $100.00 in result charges before run-start fees and platform usage. With 1.5% of runs failing or timing out in the last 30 days, budget for re-running a portion of those batches rather than assuming every run completes.

The list of target items in postUrls and usernames has the largest effect on your bill, as each successfully scraped post writes directly to your dataset and incurs a charge. The cheapest way to test your setup is to run a single post URL or limit maxPostsPerUser to 3, which caps your first-run result charge at just $0.03. Utilizing the free trial provides $5.00 of monthly credit, allowing you to safely download up to 500 media files before spending any money.

How do you run Twitter Video Downloader from the API?

The schema marks 1 of its 4 controls as required: browserCookies. Every value in the payload below comes from the published schema's own prefills, which means you can paste it, swap the token, and get a real result.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~twitter-video-downloader/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"postUrls":["https://x.com/CoinMarketCap/status/2030012592282796096"],"usernames":["cristiano"],"maxPostsPerUser":3,"browserCookies":""}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "postUrls": [
    "https://x.com/CoinMarketCap/status/2030012592282796096"
  ],
  "usernames": [
    "cristiano"
  ],
  "maxPostsPerUser": 3,
  "browserCookies": ""
}

run = client.actor("crawlerbros~twitter-video-downloader").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "postUrls": [
    "https://x.com/CoinMarketCap/status/2030012592282796096"
  ],
  "usernames": [
    "cristiano"
  ],
  "maxPostsPerUser": 3,
  "browserCookies": ""
}

const run = await client.actor('crawlerbros~twitter-video-downloader').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

That endpoint blocks until the run completes. Fine while you are testing a handful of records, risky once a run takes minutes: a dropped connection loses the response even though the run itself finished. Switch to an asynchronous start with polling or a webhook before you schedule anything.

Which Twitter Video Downloader inputs matter, and which can you skip?

The actor is configured using postUrls for targeting direct links, usernames for profile timelines, and maxPostsPerUser to cap the volume. The most critical control is browserCookies, which is required to authenticate your sessions and bypass aggressive platform restrictions. Most users running single, direct video URLs should focus on populating postUrls while leaving the timeline settings at their default values.

• postUrls (array): List of Twitter/X post URLs to download videos from (e.g., https://x.com/username/status/123456)
• usernames (array): List of Twitter/X usernames to scrape videos from (without @)
• maxPostsPerUser (integer): Maximum number of posts to scrape per username (only for username mode) Default: 10.
• browserCookies (string): Required. Twitter/X session cookies in JSON format for authenticated scraping. Twitter heavily restricts unauthenticated browsing - a valid session is mandatory. Format: [{"name":"auth_token","value":"...","domain":".x.com"}, ...]. Without cookies the run returns a single placeholder record indicating cookies are needed.

What does Twitter Video Downloader return?

The output records are optimized for media curation, delivering high-resolution file downloads alongside detailed structural metadata like codec, resolution, and bitrate. They do not contain tweet engagement statistics, profile history, or post replies, making it a poor fit for social listening projects.

What you get

• tweet_url: Original tweet URL
• tweet_id: Tweet ID
• scraped_from: Username whose profile this post was found on (null for direct URLs)
• uploader: Twitter handle of whoever posted the media
• is_retweet: true if the post is a retweet
• is_quote_tweet: true if the post quotes another tweet
• media_origin: "self" = media from the tweet itself, "quoted" = media from a quoted tweet
• media_type: "video", "photo", or "gif"
• media_url: Original Twitter CDN URL of the media
• thumbnail_url: Preview thumbnail URL (when present)
• filename: Saved file name
• filesize_bytes: File size in bytes
• storage_key: Key used to store the file in the Apify Key-Value Store
• download_url: Signed direct download URL - works in any browser or curl
• download_status: "finished" or "failed"
• error: Error message (only when download_status="failed")
• downloaded_at: ISO 8601 UTC timestamp
• media_stats: Resolution, duration, codec, bitrate, aspect ratio (where applicable)

media_stats` fields

• width / height: All media - 1920 / 1080
• fps: Videos / GIFs - 30.0
• duration: Videos / GIFs - 45.23 (seconds)
• video_codec: Videos / GIFs - "h264"
• ext: All media - "mp4", "png", "jpg"
• filesize_bytes: All media - 28640256
• total_bitrate_kbps: Videos - 5064.12
• aspect_ratio: All media - 1.78

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open Twitter Video Downloader and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Assemble your target list of Twitter/X assets, deciding whether to input explicit URLs in postUrls or target whole timelines using usernames.
2. Export your active Twitter session cookies in JSON format from your browser and paste them into the browserCookies field to ensure authenticated access.
3. Set maxPostsPerUser to a small value like 5 on your initial test run to keep your credit usage low and avoid rapid rate limits.
4. Run the Actor and review the dataset output to verify that the download_status field reads finished for all discovered media files.
5. Copy a signed URL from the download_url field and paste it into a browser to confirm that the Key-Value Store file serves correctly.
6. Inspect the nested media_stats object in your output dataset to check that variables like width, height, and duration are fully populated.
7. Save the output JSON schema and scale up your run by expanding the usernames array to your full production list.

How do you apply it? Three worked playbooks

These are Twitter Video Downloader's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Content archival

Outcome: Backup tweets from accounts you care about (your own, journalists, NASA, etc.).

Configure: Set usernames to ["NASA", "SpaceX"], maxPostsPerUser to 50, and paste your active session JSON into browserCookies.

Working method: Execute the run with your target usernames and check the output dataset. Ensure that the scraped_from field correctly documents the target handle while uploader identifies the original poster, then download the files from the signed download_url keys.

Deliverable: A collection of MP4 and PNG files saved in your Apify Key-Value Store alongside a JSON mapping of tweet metadata.

Stop condition: The actor returns a single placeholder record indicating cookies are needed, meaning your browserCookies have expired.

Use case 2: Media research

Outcome: Build labelled datasets of viral video/image content.

Configure: Set postUrls to a list of specific viral tweet URLs, leaving usernames empty, and provide your session JSON in browserCookies.

Working method: Run the Actor to fetch the target posts. Filter the output dataset by media_type to isolate videos, then read the nested media_stats properties such as total_bitrate_kbps and aspect_ratio to group and label your media dataset.

Deliverable: A structured CSV or JSON dataset containing resolution, codec, duration, and direct download links for every viral file.

Stop condition: The download_status field is marked as failed with an error message indicating the tweet has been deleted or suspended.

Use case 3: Repurposing

Outcome: Pull video/image assets for blog posts, presentations, or social repurposing.

Configure: Input the specific post URLs in postUrls and paste your valid Twitter session cookies into the browserCookies field.

Working method: Initiate the run to extract the media files. Download the high-resolution media directly using the signed download_url strings, and verify that the media is saved with clean file names matching the filename schema.

Deliverable: A local folder of downloaded MP4 and PNG assets ready for production editing and immediate inclusion in presentation decks.

Stop condition: The downloaded media files return corrupted streams or zero-byte payloads due to network blocks or altered CDN endpoints.

What breaks, and how do you design around it?

• Private / protected accounts require cookies from a follower.
• Tweets that were deleted before the run started cannot be retrieved.
• Twitter rate-limits aggressive crawling; very large username scrapes (50+ users × 100 posts each) may slow down or pause for cool-off.
• Download URLs are valid as long as your Apify storage retention allows.

To navigate the platform's rate limits on large username crawls, segment your targets into smaller batches of a few profiles per run. If you hit a block, rotate your browser session cookies using a fresh login file in browserCookies. Keep in mind that signed download URLs expire based on your Apify storage terms, so you should back up critical media files to your own bucket shortly after each run.

When should you not use Twitter Video Downloader?

Do not use this Actor if you need to gather textual data, search queries, or user engagements. If you are conducting a text-based campaign, search for keyword metrics using Twitter Keywords Scraper or Twitter Keywords Scraper Pro instead. If you need complete user account metadata, including follower counts and profile details, use Twitter Profile Scraper. If you require visual evidence of tweets rather than the raw media files themselves, Twitter Screenshot Generator is the proper choice. Finally, if you need video subtitles and timestamped audio narration, use Twitter / X Video Transcript Scraper instead.

What should you check before trusting the output?

• Verify that download_status is not set to failed; if it is, inspect the error field to identify expired URLs or deleted posts.
• Monitor the media_url field for null values, which occur if a post does not contain any video, photo, or GIF media.
• Check that the uploader string is populated and matches the expected Twitter handle to prevent scraping the wrong author's content during retweets.
• Assess the size of downloaded files via filesize_bytes; an unusually small size or zero-byte value indicates a corrupted download stream.
• Set up an automated platform alert to trigger if a scheduled run ends with a timeout, indicating a need to refresh your browserCookies JSON.

None of this proves a record is correct. It gives a scheduled Twitter Video Downloader run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

How much does it cost to download 10,000 video files?

At the free-plan price of $10.00 per 1,000 results, downloading 10,000 files will cost $100.00 in result charges. There is also a small Apify platform usage fee charged for the computing memory used during the run. If you upgrade to a paid Apify plan, the result fee drops, reducing your total media extraction costs.

What happens if a run times out or fails?

The platform telemetry shows that about 2 in a hundred runs failed or timed out over the last 30 days. If a timeout occurs, your run-start fee is still charged, but per-result charges apply only to items successfully written to the dataset before the timeout. Most failures are caused by expired session cookies.

Are private or protected Twitter profiles supported?

Yes, but only if you provide session cookies in browserCookies from an account that already follows the target private profile. The Actor cannot bypass Twitter's native privacy controls, so unauthenticated runs or standard cookie pools will fail to access protected timelines.

Do I need to manage video segment files for streaming videos?

No. The Actor automatically detects fragmented MP4 streams (HLS/m3u8), selects the highest quality variant, downloads all segments, and merges them into a single playable MP4. You get a single, standard video file link in your dataset.

How long do the generated download links remain active?

The download links rely on Apify Key-Value Store storage. On the free plan, these files are typically retained for 7 days. For permanent archival, you must copy the files from the signed URLs to your own external storage before the retention period expires.

Where to go next

When you are ready to run it, open Twitter Video Downloader on Apify; the free plan covers up to 500 results a month.

Start with the Twitter Video Downloader Actor page for the current input schema, pricing tier, and run history.

It is part of the Twitter/X Scraping Suite, which puts every related Actor on one page with its price and run history.

If you are comparing approaches rather than committing to one Actor, these category pages list every option we publish:

• Video and transcript scrapers covers 48 Actors in this family.

Other Actors we maintain for related data:

• Twitter / X Video Transcript Scraper: Extract transcripts from Twitter/X video posts.
• Twitter Keywords Scraper: Extract tweets from Twitter/X based on keywords.
• Twitter Screenshot Generator: Take clean, high-quality screenshots of any public Twitter/X post.
• Twitter Profile Scraper: Extract comprehensive Twitter/X profile data and tweets including all engagement metrics (likes, retweets, replies, quotes, bookmarks, views), profile details, media URLs, hashtags, and mentions with anti-detection features and authenticated scraping support.
• Twitter Keywords Scraper Pro: Scrape tweets from Twitter/X by keywords with advanced filters: date range, language, engagement thresholds, media type, verified-only, and more.

Related guides:

• Twitter Keywords Scraper: 17 Data Fields per Record (2026)
• Twitter Profile Scraper: Practical Use Cases and Workflows
• Twitter Keywords Scraper Pro: 3 Practical Use Cases
• Ultimate Website Screenshot / PDF / Video: $2.00 per 1,000 Results
• Social Media Finder: Operating Guide and Cross-Platform Playbooks

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-26.

• Actor last updated by its maintainers on 2026-05-05.

• Run outcome figures cover the 30 day public window ending 2026-09-26.

• Twitter Video Downloader on Apify