# Threads Video Downloader (`alpha-scraper/threads-video-downloader`) Actor Threads Video Downloader extracts direct video URLs and thumbnail URLs from Threads video posts. Process one or more Threads URLs and receive structured results with source URLs, video links, thumbnails, and error details for efficient media collection and automation. - **URL**: https://apify.com/alpha-scraper/threads-video-downloader.md - **Developed by:** [Alpha Scraper](https://apify.com/alpha-scraper) (community) - **Categories:** Videos, Social media, Other - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $1.50 / 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. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ### Threads Video Downloader Threads Video Downloader is an Apify Actor designed to extract direct video URLs from publicly accessible Threads video pages. It accepts one or more Threads post or share URLs and returns structured results containing the original source URL, available video URL, thumbnail URL, and user-facing error information when a URL cannot be processed. The actor is useful for developers, researchers, content workflows, media collection tasks, and automation processes that need structured Threads video links rather than manually opening each post and locating the media. The workflow is simple: provide Threads URLs as the input, start the Actor, and review the resulting dataset. Each processed URL produces a result object that identifies the source and provides the extracted media information when available. ### What Is a Threads Video Downloader? A Threads Video Downloader automates the process of retrieving a video URL associated with a Threads post. Instead of manually inspecting Threads pages one by one, users can submit multiple supported URLs in a single Actor run. The Actor focuses specifically on video URL extraction. For a successfully processed page, the result can contain a direct video URL along with the source page and an available thumbnail URL. It is intended for workflows where the important output is structured media metadata rather than a full copy of the Threads page. ### Key Features | **Feature** | **Description** | **User Benefit** | | ---------------------------- | ------------------------------------------------------------------ | ------------------------------------------------- | | Threads video URL extraction | Extracts a video URL from supported Threads video pages. | Reduces manual media-link discovery. | | Multiple URL processing | The `startUrls` input accepts one or more URLs. | Process several Threads posts in one run. | | Source URL preservation | Each result includes the original submitted Threads URL. | Makes results easy to trace back to their source. | | Thumbnail extraction | Attempts to return an available video thumbnail URL. | Helps identify the associated media visually. | | Structured dataset results | Results are returned as structured objects in the default dataset. | Simplifies downstream analysis and automation. | | Error reporting | Failed requests can include an `error` field. | Makes unsuccessful URLs easier to identify. | ### What Data Can You Extract? The Threads Video Downloader returns a small, focused dataset centered on video access information. The primary data categories are: - **Source information** — the Threads URL that was submitted for processing. - **Video information** — the extracted `video_download_link` when a video URL is available. - **Thumbnail information** — the `thumbnail_url` associated with the media when available. - **Processing status information** — an `error` field may appear when the source cannot be successfully processed. This structure makes the Actor suitable for creating a clean Threads media dataset without adding unrelated profile or post fields. The Actor does not document broader profile information, comments, engagement statistics, author details, captions, or other post metadata as part of its output, so those fields should not be expected. ### Why Use the Threads Video Downloader? Manually finding a video URL inside individual Threads pages can become repetitive when working with multiple posts. This Actor provides a repeatable input-and-output workflow for collecting the relevant video links. The main practical advantages are automation, structured results, multiple-URL processing, and source traceability. For research and data workflows, keeping the original Threads URL alongside the extracted video link is especially useful because it preserves the relationship between the source page and the resulting media record. The focused output can also make later filtering easier. For example, users can identify successful results by checking whether `video_download_link` contains a value and inspect the `error` field for unsuccessful records. ### Benefits #### Automated Media Link Collection The Actor removes the need to manually inspect each submitted Threads page for its video URL. #### Batch Processing Multiple supported Threads URLs can be provided through the `startUrls` array, making the workflow more convenient for small or larger collections of source links. #### Structured Data Instead of manually copying links into a spreadsheet or document, the Actor produces structured records containing consistent field names. #### Source Traceability Every successful or failed result retains the `source_url`, allowing users to connect the output with the original Threads page. #### Research-Friendly Output The returned structure is compact and easy to review when building a Threads video dataset for further research or analysis. ### How to Use the Threads Video Downloader Using the Actor requires only a supported `startUrls` input. 1. Open the Actor's **Input** tab. 2. Add one or more Threads video, post, or share URLs to `startUrls`. 3. Start the Actor. 4. Wait for the URLs to be processed. 5. Open the default dataset and review the returned results. 6. Use the extracted video URLs and thumbnail URLs in your permitted downstream workflow. For a first run, start with one or a few URLs so you can confirm that the returned structure matches your workflow before processing a larger collection. ### Input The Actor has one required input property: `startUrls`. It is an array designed for one or more Threads URLs. The Apify input editor uses a request-list style interface, so each entry can be supplied as a URL record. The code also accepts an individual string URL inside the array when provided programmatically. ### Input Fields | **Field** | **Type** | **Required** | **Default** | **Description** | | ----------- | -------- | ------------ | ----------- | ---------------------------------------------------------- | | `startUrls` | Array | Yes | None | One or more Threads video, post, or share URLs to process. | Supported URLs can resemble Threads post URLs such as: - `https://www.threads.com/@bmw/post/DT0n5H5iIEf` - `https://www.threads.com/@bmw/post/DV-fETEETCC/media` - `https://www.threads.com/@nfloncbs/post/DWCXQoxkeJX/media?hl=en` - `https://www.threads.com/@rioferdinandpresents/post/DV_r4RJDNND?...` Use valid Threads URLs that point to content containing a video. The Actor is specifically intended for video URL extraction, so non-video pages may not produce a `video_download_link`. ### Input Example ```json { "startUrls": [ { "url": "https://www.threads.com/@bmw/post/DT0n5H5iIEf" }, { "url": "https://www.threads.com/@nfloncbs/post/DWCXQoxkeJX/media?hl=en" } ] } ``` ### Output The Actor writes the finalized results to the default dataset. A run can contain multiple processed URL results. The output records use consistent field names so users can identify the source, extracted video URL, thumbnail URL, and any applicable error message. For successful processing, `video_download_link` contains the extracted video URL when one is available. When a URL returns a not-found response, the result can contain an `error` value of `HTTP 404 Not Found`. Other failed attempts can return a general processing error indicating that valid data could not be obtained after retries. ### Output Fields | **Field** | **Description** | | --------------------- | ------------------------------------------------------------------------------------------------------------------------------- | | `source_url` | The original Threads URL submitted to the Actor. | | `thumbnail_url` | The available thumbnail image URL associated with the Threads media, when extracted. | | `video_download_link` | The extracted video URL when available. | | `error` | A user-facing error message for URLs that could not be successfully processed. This field is not present on successful results. | A successful result therefore centers on three values: source page, thumbnail, and video URL. ### Output Example ```json [ { "source_url": "https://www.threads.com/@bmw/post/DT0n5H5iIEf", "thumbnail_url": "https://example.com/thumbnail.jpg", "video_download_link": "https://example.com/video.mp4" }, { "source_url": "https://www.threads.com/@example/post/ABC123", "error": "HTTP 404 Not Found", "thumbnail_url": "", "video_download_link": "" } ] ``` The URLs above are illustrative examples of the output structure. Actual media URLs depend on the source page being processed. ### Input to Output Workflow The Actor follows a straightforward user-facing workflow: **Threads URL → page processing → media URL extraction → structured dataset result** The user provides one or more Threads URLs. The Actor processes each valid URL and attempts to identify the associated video and thumbnail information. The final results are collected into the default dataset. This approach keeps the workflow focused on extracting the information users actually need for a Threads video data collection task. ### Use Cases The Threads Video Downloader can support several practical workflows where extracting video URLs from Threads posts is relevant. #### Content Research Researchers can collect video links associated with selected Threads posts for permitted analysis or reference. #### Media Dataset Creation Users can build a structured collection containing source URLs, video links, and thumbnails. #### Content Discovery Workflows The extracted links can serve as inputs to downstream workflows that organize or analyze video resources where permitted. #### Research and Analysis Structured source and media URLs can be useful for organizing datasets before manual review or further analysis. #### Automation The Actor can be incorporated into repeatable workflows where Threads URLs need to be processed without manually inspecting each page. #### Archival and Reference Workflows Where permitted by applicable rights and platform rules, users can retain the relationship between an original Threads source URL and its extracted media URL for internal reference. ### Competitive Advantages The Actor's practical strengths are centered on simplicity and focused output. It has a small input schema, accepts multiple URLs, and returns only the principal fields associated with Threads video extraction. This makes it easier to understand than a workflow that produces a large amount of unrelated page information. Another useful characteristic is source preservation. The `source_url` remains part of every result, allowing users to match an extracted media URL back to the submitted Threads page. The thumbnail field can also make result review easier when thumbnail information is available. ### Pros and Cons | **Pros** | **Cons** | | --------------------------------------------- | ------------------------------------------------------------------------------------ | | Simple one-field input schema. | Output is focused specifically on video-related information. | | Supports multiple Threads URLs in one run. | Non-video or inaccessible pages may not return a video URL. | | Preserves the original source URL. | Some results may include an error instead of media information. | | Returns thumbnail information when available. | The Actor does not document broader post analytics or profile data. | | Structured dataset output. | Availability of extracted media information can depend on the submitted source page. | ### Comparison With Alternative Approaches | **Capability** | **This Actor** | **Manual / Typical Alternative** | | ------------------------ | -------------------------------------------- | -------------------------------------------------- | | Multiple URL processing | Supported through `startUrls`. | Often requires repeated manual handling. | | Video URL extraction | Automated by the Actor. | Usually requires opening and inspecting each page. | | Source URL preservation | Included in every result. | Must be recorded manually. | | Structured result fields | Provided in the dataset. | May require manual copying and formatting. | | Error visibility | Failed records can include an `error` field. | Failures may need to be tracked manually. | This comparison describes workflow differences rather than making claims about other scraping products or services. ### Limitations The Actor is specifically designed for extracting video URLs from Threads pages and should be treated as a focused media-link extraction tool. A submitted URL may not produce a video result when the page is unavailable, returns an HTTP 404 response, does not contain the expected video information, or cannot provide usable media data during processing. Thumbnail information may also be unavailable for some sources. In those cases, `thumbnail_url` can remain empty. The actor code does not define a documented maximum number of URLs in `startUrls`, so users should choose a practical batch size appropriate for their workflow rather than assuming an unlimited batch. ### Best Practices For reliable user-facing workflows: - Start with a small number of known Threads video URLs. - Use the exact `startUrls` structure shown in the input example. - Confirm that each submitted URL points to a Threads page containing video content. - Review both `video_download_link` and `error` when processing results. - Keep the `source_url` when storing extracted media information so records remain traceable. - Validate extracted URLs before using them in downstream applications. - For larger collections, review an initial sample of results before expanding the input set. ### Troubleshooting #### Invalid Input Check that `startUrls` is an array and that each entry contains a valid Threads URL in the expected request-list format. #### Empty Results Make sure the submitted page is a Threads URL associated with video content. A page without extractable video information may not produce a usable video link. #### Missing Video URL Review the returned object for an `error` field. A failed request or unavailable source can result in an empty `video_download_link`. #### Missing Thumbnail A missing `thumbnail_url` does not necessarily mean that the source contains no video. Thumbnail information may simply be unavailable from the processed page. #### 404 Error A result containing `HTTP 404 Not Found` indicates that the submitted source could not be found at processing time. Verify the URL and try again with a valid Threads page. #### Processing Failure For other unsuccessful requests, review the `error` message and verify that the URL is valid and accessible before retrying. ### Frequently Asked Questions #### What does the Threads Video Downloader do? It processes Threads video URLs and attempts to extract the associated video URL and thumbnail URL while preserving the original source URL. #### What input does the Threads Video Downloader require? The only required input is `startUrls`, an array containing one or more Threads URLs. #### Can I process multiple Threads URLs? Yes. `startUrls` is an array, so multiple Threads URLs can be submitted in the same run. #### What does the Threads Video Downloader return? A result can contain `source_url`, `thumbnail_url`, and `video_download_link`. Failed processing can also produce an `error` field. #### Does every result contain a video URL? No. A video URL is returned when the Actor successfully extracts one. Unavailable, invalid, or unsuccessful sources can produce an empty video field and an error message. #### Does the Actor return the original Threads URL? Yes. The submitted URL is preserved as `source_url` in the result. #### Does it return thumbnail information? The Actor attempts to return a thumbnail URL when available. The field can be empty when thumbnail information cannot be extracted. #### Can I use the Actor for general Threads post data? The documented output is focused on source URL, thumbnail URL, video URL, and errors. General profile, engagement, comment, and analytics fields are not part of the documented output. #### What should I do if a URL returns 404? Check that the Threads URL is correct and still accessible, then retry with a valid source URL. #### Is the Threads Video Downloader suitable for automated workflows? Yes. Its structured input and dataset output make it suitable for repeatable workflows that need to process Threads video URLs. ### NLP Keywords - Threads video extraction - Threads media URL - Threads video URL - Threads post video - Threads media downloader - Threads video data - Threads video link - Threads video metadata - Threads thumbnail URL - Threads media extraction - Threads content extraction - Threads post URL - Threads share URL - video link extraction - social media video extraction - structured Threads data - Threads dataset - video metadata extraction - media link collection - automated Threads processing ### Related Keywords - Threads video downloader - download Threads videos - extract Threads video URL - Threads video link extractor - Threads post video downloader - Threads media downloader tool - Threads video URL extractor - Threads video data scraper - Threads media link extractor - Threads video extraction tool - extract video from Threads - Threads video source URL - Threads video thumbnail extractor - Threads media data extraction - Threads video dataset - Threads content downloader - Threads URL video extractor - Threads post media extraction - automated Threads video extraction - Threads video link collection ### Final Overview Threads Video Downloader provides a focused workflow for extracting video URLs from Threads video pages. Users submit one or more Threads URLs through `startUrls`, and the Actor returns structured results containing the original source URL, available thumbnail URL, extracted video URL, and relevant error information. Its simple schema makes it suitable for media-link collection, research workflows, dataset creation, and automation where Threads video URLs need to be gathered in a consistent format. For the most predictable workflow, begin with a small test set of valid Threads video URLs, review the dataset results, and then expand the collection as appropriate for your use case. **Contact me:** # Actor input Schema ## `startUrls` (type: `array`): List of one or more Instagram video URLs ## Actor input object example ```json { "startUrls": [ { "url": "https://www.threads.com/@bmw/post/DT0n5H5iIEf" }, { "url": "https://www.threads.com/@bmw/post/DV-fETEETCC/media" }, { "url": "https://www.threads.com/@nfloncbs/post/DWCXQoxkeJX/media?hl=en" }, { "url": "https://www.threads.com/@rioferdinandpresents/post/DV_r4RJDNND?xmt=AQF0AXU1Vtdf9DCIB0sUcyB6aSq-yWm23dhB36E5_3hZzw" } ] } ``` # Actor output Schema ## `dataset` (type: `string`): No description # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "startUrls": [ { "url": "https://www.threads.com/@bmw/post/DT0n5H5iIEf" }, { "url": "https://www.threads.com/@bmw/post/DV-fETEETCC/media" }, { "url": "https://www.threads.com/@nfloncbs/post/DWCXQoxkeJX/media?hl=en" }, { "url": "https://www.threads.com/@rioferdinandpresents/post/DV_r4RJDNND?xmt=AQF0AXU1Vtdf9DCIB0sUcyB6aSq-yWm23dhB36E5_3hZzw" } ] }; // Run the Actor and wait for it to finish const run = await client.actor("alpha-scraper/threads-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "startUrls": [ { "url": "https://www.threads.com/@bmw/post/DT0n5H5iIEf" }, { "url": "https://www.threads.com/@bmw/post/DV-fETEETCC/media" }, { "url": "https://www.threads.com/@nfloncbs/post/DWCXQoxkeJX/media?hl=en" }, { "url": "https://www.threads.com/@rioferdinandpresents/post/DV_r4RJDNND?xmt=AQF0AXU1Vtdf9DCIB0sUcyB6aSq-yWm23dhB36E5_3hZzw" }, ] } # Run the Actor and wait for it to finish run = client.actor("alpha-scraper/threads-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": [ { "url": "https://www.threads.com/@bmw/post/DT0n5H5iIEf" }, { "url": "https://www.threads.com/@bmw/post/DV-fETEETCC/media" }, { "url": "https://www.threads.com/@nfloncbs/post/DWCXQoxkeJX/media?hl=en" }, { "url": "https://www.threads.com/@rioferdinandpresents/post/DV_r4RJDNND?xmt=AQF0AXU1Vtdf9DCIB0sUcyB6aSq-yWm23dhB36E5_3hZzw" } ] }' | apify call alpha-scraper/threads-video-downloader --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,alpha-scraper/threads-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 ` 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/WsyeKnaRPBdqDoIhR/builds/YkPZwoo8Vm4VF03mk/openapi.json