# Threads Post Media Downloader (`scraperoka/threads-post-media-downloader`) Actor

🚀 Threads Post Media Downloader lets you save photos & videos from Threads with ease. 📥 Fast, simple, and reliable—perfect for creators and marketers to reuse content responsibly. ✨ Download in seconds and boost your workflow today!

- **URL**: https://apify.com/scraperoka/threads-post-media-downloader.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Social media, Automation, Developer tools
- **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

### Threads Post Media Downloader 🧵

Manually visiting Threads posts to collect video and image assets wastes hours you could spend on analysis or outreach. **Threads Post Media Downloader** extracts high-quality video metadata, images, and carousel data from Threads posts in bulk, so you can download Threads media fast. This Threads post media downloader (and Threads media download tool) is ideal for marketers, recruiters, and growth teams who want to export media from Threads at scale—often thousands of records in minutes.

***

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "url": "https://www.threads.net/@example_creator/post/ABC123",
  "result": {
    "url": "https://www.threads.net/@example_creator/post/ABC123",
    "source": "threads",
    "pk": "987654321",
    "id": "ABC123",
    "author": "",
    "title": "New product update 🚀",
    "like_count": "1542",
    "thumbnail": "https://example-cdn.com/media/thumb_1080x1080.jpg",
    "medias": [
      {
        "url": "https://example-cdn.com/media/video_1080p.mp4?token=xyz",
        "thumbnail": "https://example-cdn.com/media/thumb_1080x1080.jpg",
        "pk": "987654321",
        "id": "ABC123",
        "caption": "New product update 🚀",
        "quality": "Video 1080x1920p",
        "accessibility_caption": "A short accessibility description for the media",
        "height": 1920,
        "width": 1080,
        "resolution": "1080x1920",
        "extension": "mp4",
        "type": "video"
      }
    ],
    "type": "single",
    "error": false,
    "time_end": 420
  }
}
```

| Field | Type | What It Tells You |
|---|---|---|
| `url` | string | The original post URL you provided—useful for traceability |
| `result.url` | string | A normalized copy of the post URL stored with the scraped media |
| `result.source` | string | Confirms the data source as `threads` for consistent pipelines |
| `result.pk` | string | Internal media identifier (as exposed by the post payload) for joins/deduping |
| `result.id` | string | Post media identifier for easy referencing across systems |
| `result.author` | string | Author field included in the output (empty string in the current extraction flow) |
| `result.title` | string or null | Caption text from the post to label your exports (null if missing) |
| `result.like_count` | string | Like count as a string for sorting and scoring |
| `result.thumbnail` | string | Best available thumbnail URL to quickly preview the media set |
| `result.medias` | array | A list of extracted media items (images and/or videos), including thumbnails and URLs |
| `result.type` | string | Whether the post is treated as `single` or `carousel` |
| `result.error` | boolean | True/False to indicate success for each post record |
| `result.time_end` | number | Video-end timing (derived from media metadata when available) |
| `result` → `medias[].type` | string | Each media item is labeled as `video` or `image` for downstream filtering |
| `result` → `medias[].quality` | string | Human-readable resolution info like `Video 1080x1920p` or `Image 720x1280p` |
| `result` → `medias[].extension` | string | File extension hint (`mp4` for videos, `jpg` for images) |

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

***

### Why Threads Post Media Downloader 🧵?

There are a lot of ways to pull data from Threads — here’s what sets Threads Post Media Downloader apart.

#### Extracts complete media sets (images + video metadata)

Threads Post Media Downloader pulls media details from Threads.net posts and returns URLs, thumbnails, caption text, and media-specific fields so your “download Threads videos / download Threads images” workflows don’t need extra stitching.

#### Handles single posts and carousels

It detects whether a post is treated as `single` or `carousel`, then outputs a `medias` array accordingly—so you can save Threads reels-like video assets and carousel images with one consistent flow.

#### Resilient output with error handling

When media data can’t be found or a request fails, the actor still returns a structured record with `result.error: true` and a message in the error response—helpful for monitoring and retry logic on your side.

#### Proxy-ready for more reliable scraping runs

The actor supports proxy configuration, helping you run Threads media download tool jobs more reliably across larger batches.

***

### Configuring Your Run

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

```json
{
  "urls": [
    "https://www.threads.net/@shams/post/DFntiSvSsNq"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `urls` | ⬜ | List of Threads post URLs to scrape |
| `proxyConfiguration` | ⬜ | Select proxies to be used by your crawler |
| ↳ `proxy support` | ⬜ | Set `true` to route requests through Apify Proxy for better reliability |

***

### Core Capabilities

#### Media extraction for Threads posts

Threads Post Media Downloader extracts video metadata and image/carousel information from Threads.net posts and outputs direct media URLs plus captions (when present). This makes it practical to export media from Threads into your own media library or analysis dataset.

#### Structured `medias` array for easy filtering

Each post result includes a `medias` array where items are labeled with `type` (`video` or `image`), file `extension`, and a readable `quality` string. That’s ideal for splitting “download Threads videos” vs “download Threads images” runs without manual cleanup.

#### Carousel-aware output

For posts with `carousel_media`, the actor returns multiple media items in the same `medias` list. This supports Threads post image download workflows where one URL can contain many assets.

#### Captions, thumbnails, and resolution for better context

The output includes `title` (from post caption text), `thumbnail`, and resolution details (`resolution`, `height`, `width`) per media item. As a result, you can preview and validate results quickly before exporting.

#### Error-ready results for dependable batch runs

Every input URL produces a record: success returns `result.error: false`, while failures return `result.error: true` along with a message. This helps you keep pipelines stable and track which Threads post downloader online targets need attention.

Overall, Threads Post Media Downloader turns Threads content download into clean, integration-ready JSON you can process immediately.

***

### Who Gets the Most Out of This

Here's how different teams put Threads Post Media Downloader to work:

**Social media analysts**—feed a list of Threads post URLs and build datasets that include like counts, caption titles, and per-media resolutions. You get consistent “Threads media extractor” output that’s easy to filter for video vs image trends.

**Influencer and creator marketers**—collect the exact media assets tied to posts you’re evaluating, including thumbnails and video-end timing when available. This speeds up content sourcing and helps you compare messaging across creators using the same export media from Threads format every time.

**Growth and community teams**—turn public Threads posts into a reusable media library for reporting, campaign inspiration, or asset auditing. When you need to save Threads reels and carousel posts side-by-side, the single structured output keeps the workflow straightforward.

**Freelance researchers and media curators**—use the extracted caption text and media resolutions to tag and organize findings without opening each post manually. The “Threads media download tool” output is particularly useful when you’re compiling evidence collections from multiple URLs.

**Developers and automation specialists**—integrate the actor into an API-driven pipeline that ingests URLs and produces a predictable JSON structure with `result` and `medias`. This makes it easier to automate “Threads post video downloader” workflows end-to-end.

***

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

No coding needed. Here's how to run Threads Post Media Downloader from start to finish:

1. **Open** the actor on Apify at https://console.apify.com
2. **Enter** your inputs using the `urls` field (one or more Threads post URLs) and optionally `proxyConfiguration`
3. **Configure** proxy settings (use the built-in proxy option if you want added scraping reliability)
4. **Hit Run** and watch the live log as each Threads URL is processed
5. **View** results in the dataset tab (each input URL produces a structured record)
6. **Export** your dataset as JSON, CSV, or Excel from the Apify dashboard

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Threads Post Media Downloader plugs directly into your existing workflow.

You can download results from the Apify dataset tab as **JSON**, **CSV**, or **Excel**, which is great for both quick reviews and analyst-ready deliverables. For deeper automation, you can also access results programmatically via the **Apify API**: https://apify.com/docs/api.

To connect Threads media download tool outputs with your systems, you can use Apify-native options such as **webhooks** (to trigger downstream actions when a run completes) and automation platforms like **Zapier** or **Make**. If you’re running recurring “Threads post downloader online” jobs, you can schedule the actor to run automatically on a recurring schedule.

***

### Pricing & Free Trial

Threads Post Media Downloader runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You’ll typically use **platform credits** for compute, and scaling depends on how large your `urls` list is and how heavy your runs are. For exact details on pricing, free credits, and plan tiers, check the Apify pricing page and choose the plan that matches your expected volume.

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

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limit pressure in batch workflows | Keeps runs stable with built-in request handling |
| Proxy usage | Supports `proxyConfiguration` so you can choose a proxy strategy for your run |
| Missing or unexpected media payloads | Returns structured error records with `result.error` and a message |
| Batch processing | Processes each URL and writes results as it goes |

**Limitations:** The actor works with **publicly accessible media metadata** available from Threads posts. If a post’s media payload can’t be extracted, you’ll receive an error record for that specific URL.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes. Apify provides a free tier with platform credits, which is enough to test Threads Post Media Downloader on a small batch before scaling up.

#### Do I need to log in to Threads to use this?

No. This actor is designed to extract data from publicly accessible Threads post pages without requiring login.

#### How accurate is the data?

In general, accuracy depends on what the post itself exposes publicly. The actor extracts media metadata, thumbnails, caption text (if present), and media-specific fields such as resolution and type.

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

You can submit multiple post URLs in the `urls` array. The practical limit is determined by your run size and Apify platform settings—use smaller batches first if you’re testing.

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

The data is fetched when you run the actor. If you need fresher results, re-run the actor with the same or updated URLs.

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

This actor only accesses **publicly available data** from Threads posts. You are responsible for ensuring your use, storage, and processing comply with GDPR, CCPA, platform Terms of Service, and applicable local laws.

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

Yes. You can export from the Apify dashboard as JSON, CSV, or Excel, and then load it into Google Sheets or other spreadsheet tools. You can also connect workflows using automation tools via Apify integrations.

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

Yes. You can schedule actor runs on Apify using the platform’s scheduling features, so your Threads media download tool jobs run automatically.

#### Can I access this via API?

Yes. Results can be retrieved programmatically via the Apify API, which makes Threads Post Media Downloader suitable for automated pipelines.

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

When there’s a problem fetching or extracting media data, the actor returns a structured record for that URL with `result.error: true` and a message. This lets you keep going through a batch and identify which URLs need attention.

***

### Need Help or Have a Request?

Got a question about Threads Post Media Downloader or want a new feature added? Reach out at <dataforleads@gmail.com>. We review feedback regularly and can help with ideas like batch CSV upload and webhook notifications on completion.

***

### Disclaimer & Responsible Use

*Threads Post Media Downloader is the fastest, most reliable way to export media from Threads — start your free run today.*\
This actor accesses **publicly available data** from Threads posts and does not access private accounts, login-gated content, or password-protected pages. You are responsible for using the output in compliance with GDPR, CCPA, platform Terms of Service, and applicable laws. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `urls` (type: `array`):

List of Threads post URLs to scrape.

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

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "urls": [
    "https://www.threads.net/@shams/post/DFntiSvSsNq"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "urls": [
        "https://www.threads.net/@shams/post/DFntiSvSsNq"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/threads-post-media-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 = { "urls": ["https://www.threads.net/@shams/post/DFntiSvSsNq"] }

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/threads-post-media-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 '{
  "urls": [
    "https://www.threads.net/@shams/post/DFntiSvSsNq"
  ]
}' |
apify call scraperoka/threads-post-media-downloader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scraperoka/threads-post-media-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/p3bx2nzhPvkajf9zm/builds/8eiwaRfFuozAfjGde/openapi.json