# Twitter X Image Downloader (`scraperoka/twitter-x-image-downloader`) Actor

📥 Twitter X Image Downloader lets you save images fast from X posts with a simple, user-friendly flow. ⚡ Download high-quality visuals in seconds—perfect for creators, marketers, and social media teams. 🔍 No hassle, just results!

- **URL**: https://apify.com/scraperoka/twitter-x-image-downloader.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Social media, Automation, Other
- **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 (X.com) Image Downloader ⚡

Manually clicking through Twitter (X.com) posts to find the right visuals wastes time—especially when you need them at scale. **Twitter (X.com) Image Downloader** extracts image metadata and high-quality thumbnails from Twitter/X links in one run—ideal for marketers, recruiters, and growth teams who want thousands of results quickly.

***

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "success": true,
  "tweet_url": "https://x.com/iamsrk/status/1994361290421383203",
  "metadata": {
    "title": "Shah Rukh Khan",
    "twitter_id": "1994361290421383203",
    "thumbnail": "https://example.com/thumbnail.jpg",
    "image_count": 1
  },
  "images": [
    {
      "format": "jpg",
      "width": 1200,
      "height": 675,
      "resolution": "1200x675",
      "url": "https://example.com/image.jpg"
    }
  ]
}
```

If something goes wrong, the actor outputs an error record like this:

```json
{
  "success": false,
  "tweet_url": "https://x.com/iamsrk/status/1994361290421383203",
  "error": "Some error message here"
}
```

| Field | Type | What It Tells You |
|---|---|---|
| `success` | boolean | Whether this URL was processed successfully |
| `tweet_url` | string | The exact Twitter/X post URL you provided |
| `metadata.title` | string | A cleaned-up title derived from the post metadata |
| `metadata.twitter_id` | string | The post ID extracted from the URL (or from extracted info) |
| `metadata.thumbnail` | string | A best-effort thumbnail URL (parameter-stripped if needed) |
| `metadata.image_count` | number | How many image entries were captured for the post |
| `images` | array | A list of extracted image entries for the post |
| `images[].format` | string | Image format used in the output (currently `"jpg"`) |
| `images[].width` | number | Target image width (currently `1200`) |
| `images[].height` | number | Target image height (currently `675`) |
| `images[].resolution` | string | Resolution label formatted as `"{width}x{height}"` |
| `images[].url` | string | Present when `key_value` is `false`; the extracted thumbnail image URL |
| `images[].kv_store_url` | string | Present when `key_value` is `true`; a generated Key-Value store record URL (simulated) |
| `error` | string | Populated only for failed URLs |

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

***

### Why Twitter (X.com) Image Downloader?

There are a lot of ways to pull data from Twitter/X—here’s what sets Twitter (X.com) Image Downloader apart.

#### Built for bulk input (post URLs)

You pass a list of Twitter/X status links via `post_urls`, and the actor processes each one and writes results per URL. This makes it a practical fit for bulk download workflows and content audits using a Twitter X image downloader flow.

#### Clear, integration-ready JSON output

Each result includes `success`, the original `tweet_url`, a `metadata` object, and an `images` array. That structured output makes it easy to automate downstream steps like saving images, enriching records, or reporting.

#### Resilient processing with retries

The actor processes each URL with multiple attempts, so you’re less likely to lose work due to temporary failures. In practice, this improves reliability when downloading images from X.com in batches.

#### Optional Key-Value store URL generation

If you set `key_value` to `true`, each image entry includes a `kv_store_url` instead of a direct `url`. This is useful if your workflow expects image references in a key-value record style—while still staying within a consistent Twitter media downloader output schema.

***

### Configuring Your Run

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

```json
{
  "post_urls": [
    "https://x.com/iamsrk/status/1994361290421383203"
  ],
  "key_value": false
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `post_urls` | ✅ | A list of Twitter/X status URLs to scrape and extract image metadata from |
| `key_value` | ⬜ | If `true`, generates URLs pointing to records in the key-value store (simulated). If `false`, returns a direct image `url` for each extracted image |

***

### Core Capabilities

#### Twitter (X.com) link-to-image extraction

Twitter (X.com) Image Downloader extracts image metadata and high-quality thumbnails from Twitter/X links you provide. The output is organized per post, so your team can quickly map images to the exact `tweet_url`.

#### Targeted thumbnail selection & clean URLs

The actor chooses a thumbnail from the extracted `thumbnails` when available and normalizes the thumbnail URL by removing query parameters. This helps when you want “save X.com images” style workflows without messy link variants.

#### Resilience through retry attempts

For each URL, the actor uses retry logic to improve the chance of successful extraction. If a final attempt still fails, you get a structured failed result with `success: false`.

#### Complete per-URL result records

Each processed URL yields a single output record containing `metadata` and `images`. Even when `key_value` is enabled, the `images` array keeps a consistent structure so your pipelines can adapt cleanly.

#### Run-scale friendly for bulk workflows

Because the actor accepts a list of post URLs, it’s well-suited for bulk download X images tasks—like building media libraries, compiling creative references, or archiving public visuals.

***

### Who Gets the Most Out of This

Here’s how different teams put Twitter (X.com) Image Downloader to work:

**Outreach marketers** — paste a list of target post URLs and use the returned `metadata.thumbnail` plus the `images` entries to quickly collect creative assets for campaigns, moodboards, or lead research. The structured output helps you build a repeatable “download Twitter images without watermark”-style media library workflow (based on publicly available data).

**Recruiters & employer brand teams** — use the actor to capture visual proof from relevant public posts and keep it organized per `tweet_url` for internal review. The `metadata.title`, `metadata.twitter_id`, and `images` array make it easy to audit sources at scale.

**Social media analysts** — run the same Twitter X photo downloader process across many posts to compare media availability and thumbnail consistency. The `image_count` field helps you quantify how often posts include usable imagery.

**Automation specialists (technical)** — integrate the actor into an existing pipeline by consuming the per-run JSON records. You can store results, trigger downstream tasks, and keep your workflow consistent whether you return direct `images[].url` or `images[].kv_store_url`.

**Content curators & archive teams** — build bulk archives of Twitter media downloader outputs for reference and preservation. The normalized thumbnail URL and consistent image entry structure make the dataset easier to reuse later.

***

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

No coding needed. Here's how to run Twitter (X.com) Image Downloader from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and open the Twitter (X.com) Image Downloader actor page.
2. **Enter your inputs** — add one or more Twitter/X post links in `post_urls`, and choose whether to set `key_value` to `true` or keep it `false`.
3. **Configure proxy settings** — if you need it for your environment, enable proxy support in the Apify run configuration (the actor is compatible with proxy configuration).
4. **Hit Run and watch the live log** — monitor processing per URL and see warnings if attempts fail.
5. **View results in the dataset tab** — each URL generates a record with `success`, `tweet_url`, `metadata`, and `images` (or an `error` for failures).
6. **Export as JSON, CSV, or Excel** — download your dataset in the format that best fits your workflow.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Twitter (X.com) Image Downloader plugs directly into your existing workflow.

Export formats are available directly from the Apify dataset tab, including JSON, CSV, or Excel—so you can save X.com images data wherever your team works.

You can also integrate via API: trigger runs programmatically and pull results using the Apify API. If you want automation, set up scheduled runs and connect with tools like Zapier/Make for no-code actions when results are ready. For deeper details, see the Apify docs for API and automations: https://apify.com/docs/api

***

### Pricing & Free Trial

Twitter (X.com) Image Downloader runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You can use the free trial to test downloading images from X.com on a small set of `post_urls`, then scale up as needed.

For exact credit usage and costs, refer to the pricing details on the Apify website, since compute and plan-based limits can vary.

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

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Per-URL failures | Outputs structured records with `success: false` and an `error` field for the failed `tweet_url` |
| Temporary issues | Uses retry attempts per URL to improve success rate |
| Proxy support | Compatible with proxy configuration to help maintain scraping reliability |
| Output consistency | Always returns a `metadata` object and an `images` array when successful |
| Thumbnail normalization | Removes query parameters from the selected thumbnail URL when present |

**Limitations:** The actor works with publicly available Twitter/X media metadata returned by the extraction step. If a post doesn’t include usable thumbnails, the `images` array may be empty and `metadata.thumbnail` may be blank.

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 so you can run Twitter (X.com) Image Downloader before committing to paid usage.

#### Do I need to log in to Twitter (X.com) to use this?

No. This actor is designed to work from publicly available Twitter/X data using the links you provide in `post_urls`.

#### How accurate is the data?

Generally, it’s as accurate as what’s publicly available for each post. The actor extracts `metadata` (including `title`, `twitter_id`, and `thumbnail`) and builds the `images` entries from the extracted thumbnail data.

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

Your results scale with how many Twitter/X links you include in `post_urls`. There’s no specific per-run limit described in the actor’s input schema beyond what Apify limits apply for your run settings and plan.

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

Data freshness depends on when you run the actor. Since each run scrapes from the provided Twitter/X post URLs at execution time, you’ll get the latest publicly available state during that run.

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

Yes, as long as you use it responsibly with **publicly available data** and follow applicable laws and platform terms. You’re responsible for ensuring your use complies with GDPR, CCPA, and Twitter/X requirements for data handling.

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

Yes. You can export from the Apify dataset tab as JSON, CSV, or Excel, and then move it into Google Sheets as needed.

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

Yes. You can schedule actor runs on Apify so Twitter (X.com) Image Downloader runs automatically at the cadence you choose.

#### Can I access this via API?

Yes. You can access results programmatically by running the actor via the Apify API and retrieving dataset outputs.

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

For individual URLs, the actor outputs a record with `success: false`, the `tweet_url`, and an `error` string. Successful URLs still produce their own structured results in the same dataset.

***

### Need Help or Have a Request?

Got a question about Twitter (X.com) Image Downloader or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re actively maintaining this actor and welcome ideas like batch CSV upload of `post_urls` and webhook notifications when a run completes.

***

### Disclaimer & Responsible Use

*Twitter (X.com) Image Downloader is the fastest, most reliable way to extract Twitter/X image metadata and thumbnails — start your free run today.*

This actor collects **publicly available data** from Twitter/X links. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, and platform Terms of Service when collecting, storing, or processing the data. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `post_urls` (type: `array`):

List of Twitter/X status URLs to scrape.

## `key_value` (type: `boolean`):

If true, generates URLs pointing to records in the key-value store (simulated).

## Actor input object example

```json
{
  "post_urls": [
    "https://x.com/iamsrk/status/1994361290421383203"
  ],
  "key_value": false
}
```

# 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 = {
    "post_urls": [
        "https://x.com/iamsrk/status/1994361290421383203"
    ]
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ctPsMQUo0FJrUgWGX/builds/4THcSEm99Kw3HNxS3/openapi.json