# X (Twitter) Media Downloader — Fastest, No Rate Limit, $0.5/1K (`api402/x-twitter-media-downloader`) Actor

The fastest X/Twitter media scraper with standby mode. Download images, videos, GIFs & thumbnails from any public tweet. No rate limit. Only $0.5 per 1,000 requests. No login, no API key needed. Bulk URL support with direct CDN links.

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

## Pricing

from $0.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## X (Twitter) Media Downloader — Fastest Scraper, No Rate Limit, $0.5 per 1K Requests

**The fastest X/Twitter media scraper on Apify — no rate limit, only $0.5 per 1,000 requests, no login required.**

Extract high-quality images, videos, GIFs, and tweet metadata from any public X (Twitter) tweet URL or ID. Get direct CDN download links instantly, including **video thumbnails**, author info, engagement stats, and scrape timestamps.

Built with speed and reliability in mind — powered by [Apify](https://apify.com), the leading platform for web scraping and automation.

---

### What Does X (Twitter) Media Downloader Do?

**X (Twitter) Media Downloader** is an Apify Actor that lets you extract media files and metadata from public X (Twitter) tweets — just paste in a URL or tweet ID and get back a structured JSON dataset with:

- 🎬 **Direct video URLs** (highest available resolution, MP4)
- 🖼️ **Video thumbnail URLs** (`thumbnail_url` per video)
- 📸 **Image URLs** (original resolution from pbs.twimg.com)
- 📊 **Tweet engagement stats** (likes, retweets, replies) — toggleable
- 👤 **Author metadata** (username, display name)
- 📝 **Tweet text and post date**
- 🕐 **Scrape timestamp** for freshness tracking

No account, no cookies, no API keys needed. 100% public content only.

---

### Why Use X (Twitter) Media Downloader?

| Feature | This Actor |
|---|---|
| 💰 **Price** | **$0.50 per 1,000 requests** — cheapest on Apify |
| 🚀 **Speed** | No rate limits on our end |
| 🎥 **Video thumbnails** | ✅ Included |
| 📸 **Full-res images** | ✅ Original CDN URLs |
| 🔑 **Login required** | ❌ None |
| 🔒 **Twitter API key** | ❌ None |
| 📦 **Output format** | Clean JSON dataset |

#### Use Cases

- **Content archiving** — Save original media from viral tweets permanently
- **AI & ML datasets** — Collect labeled image/video datasets from Twitter
- **Social media analytics** — Track media from specific tweets or campaigns
- **Competitive research** — Monitor what media competitors are publishing
- **Media production** — Curate visual content for editorial or creative projects
- **Brand monitoring** — Track all media published about your brand

---

### How to Use X (Twitter) Media Downloader

1. Go to the **Input** tab in Apify Console
2. Paste one or more X/Twitter tweet URLs or tweet IDs into **Tweet URLs or IDs**
3. (Optional) Toggle **Include tweet stats** on/off
4. (Optional) Configure proxy settings — residential proxies recommended for large batches
5. Click **Start** and your media dataset will be ready in seconds
6. Download results as **JSON, CSV, Excel, or XML** from the **Dataset** tab

---

### Input Parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `tweetUrls` | array of strings | — | Tweet URLs or IDs to extract media from |
| `includeStats` | boolean | `true` | Include engagement stats (likes, retweets, replies) |
| `proxyConfiguration` | object | Auto | Proxy settings — residential proxies recommended |

#### Supported URL Formats

````

https://x.com/username/status/1234567890
https://twitter.com/username/status/1234567890
1234567890   ← just the tweet ID also works

````

#### Minimal Input Example

```json
{
  "tweetUrls": [
    "https://x.com/teslaownersSV/status/2004891561180758165"
  ]
}
````

#### Full Input Example

```json
{
  "tweetUrls": [
    "https://x.com/teslaownersSV/status/2004891561180758165",
    "https://x.com/sciencegirl/status/2048046638254489836",
    "1804891561180758165"
  ],
  "includeStats": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

***

### Output Format

Each tweet is output as a separate dataset record. You can download the dataset in **JSON, CSV, Excel, or XML** format.

#### Dataset Fields

| Field | Type | Description |
|---|---|---|
| `item_type` | string | Always `"tweet_media"` |
| `tweet_url` | string | Original URL of the tweet |
| `tweet_id` | string | Unique numeric ID of the tweet |
| `username` | string | Twitter/X handle of the author |
| `fullname` | string | Display name of the author |
| `text` | string | Text content of the tweet |
| `date` | string | Date the tweet was posted |
| `media` | array | List of media items (see below) |
| `stats` | object | Engagement data (if `includeStats` is `true`) |
| `scrape_date` | string | ISO timestamp when the data was scraped |

#### Media Item Structure

Each item in the `media` array contains:

| Field | Type | Description |
|---|---|---|
| `type` | string | `"video"` or `"image"` |
| `url` | string | Direct CDN URL to download the media |
| `thumbnail_url` | string | Thumbnail image URL (videos only) |

#### Output Example — Video Tweet

```json
{
  "item_type": "tweet_media",
  "tweet_url": "https://x.com/teslaownersSV/status/2004891561180758165",
  "tweet_id": "2004891561180758165",
  "username": "teslaownersSV",
  "fullname": "Tesla Owners Silicon Valley",
  "text": "Check out this incredible footage! 🚀",
  "date": "2025-06-12T18:43:00.000Z",
  "media": [
    {
      "type": "video",
      "url": "https://video.twimg.com/ext_tw_video/2004891.../720x1280/vid/avc1/video.mp4",
      "thumbnail_url": "https://pbs.twimg.com/ext_tw_video_thumb/2004891.../img/thumbnail.jpg"
    }
  ],
  "stats": {
    "likes": 14200,
    "retweets": 3100,
    "replies": 480
  },
  "scrape_date": "2026-07-21T03:00:00.000Z"
}
```

#### Output Example — Photo Tweet

```json
{
  "item_type": "tweet_media",
  "tweet_url": "https://x.com/sciencegirl/status/2048046638254489836",
  "tweet_id": "2048046638254489836",
  "username": "sciencegirl",
  "fullname": "Science Girl",
  "text": "The most mind-blowing photo from last night's observation 🔭",
  "date": "2026-01-05T21:15:00.000Z",
  "media": [
    {
      "type": "image",
      "url": "https://pbs.twimg.com/media/ExampleABC.jpg"
    },
    {
      "type": "image",
      "url": "https://pbs.twimg.com/media/ExampleDEF.jpg"
    }
  ],
  "stats": {
    "likes": 89000,
    "retweets": 21000,
    "replies": 3400
  },
  "scrape_date": "2026-07-21T03:00:00.000Z"
}
```

***

### Pricing — The Most Affordable X Media Scraper

> **$0.50 per 1,000 requests** — no hidden fees, no rate limits.

| Volume | Cost |
|---|---|
| 100 tweets | ~$0.05 |
| 1,000 tweets | ~$0.50 |
| 10,000 tweets | ~$5.00 |
| 100,000 tweets | ~$50.00 |

Apify gives you **$5 free credit** every month on the free tier — that's **10,000 free tweet media extractions** per month.

***

### Features

- ✅ **Highest resolution video** — always grabs the best available MP4 quality
- ✅ **Video thumbnails** — `thumbnail_url` included per video item
- ✅ **Original photo URLs** — direct links to pbs.twimg.com full-resolution images
- ✅ **Tweet stats toggle** — enable or disable stats per run to save compute
- ✅ **Dual API fallback** — fxtwitter primary, vxtwitter automatic fallback
- ✅ **Proxy support** — configure residential proxies for large-scale batches
- ✅ **No login / no Twitter API key** — works on public content immediately
- ✅ **Structured JSON dataset** — ready for downstream pipelines, ETL, or export
- ✅ **Multiple URL formats** — supports x.com, twitter.com, and bare tweet IDs

***

### Tips & Best Practices

- **For large batches**: Enable residential proxies in the proxy configuration
- **For AI datasets**: Set `includeStats: false` to reduce payload size
- **For video archiving**: The `thumbnail_url` field gives you a preview image for each video
- **For automation**: Use the [Apify API](https://docs.apify.com/api/v2) or [JavaScript/Python SDK](https://docs.apify.com/sdk) to trigger runs programmatically

#### Run via Apify API

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "tweetUrls": ["https://x.com/example/status/123456789"],
    "includeStats": true
  }'
```

#### Run via JavaScript SDK

```javascript
const { ApifyClient } = require('apify-client');
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const { items } = await client.actor('YOUR_ACTOR_ID').call({
  tweetUrls: ['https://x.com/example/status/123456789'],
  includeStats: true,
});

console.log(items);
```

***

### FAQ

**Does it work for private accounts?**
No. This Actor only accesses publicly viewable content.

**Does it require a Twitter/X account or API key?**
No. It works without any credentials or Twitter developer access.

**Does it support multiple tweets per run?**
Yes. You can pass as many tweet URLs or IDs as you need in the `tweetUrls` array.

**Can I use it without a proxy?**
Yes for small-scale use. For 100+ tweets, residential proxies are recommended to ensure reliability.

**What video quality is returned?**
The highest available resolution MP4 — typically 720p or 1080p depending on what was uploaded.

**Does it extract GIFs?**
Yes. Twitter GIFs are stored as MP4 video files and will be returned with `type: "video"`.

***

### Legal Notice

This Actor accesses only **publicly available** content on X (Twitter). Users are responsible for ensuring their use complies with:

- [X/Twitter Terms of Service](https://twitter.com/en/tos)
- Applicable copyright laws in their jurisdiction
- GDPR or other data protection regulations where applicable

Apify is not responsible for how extracted data is used.

***

### ⭐ Rate It · 🐛 Report an Issue

> **Enjoying the Actor?** Drop us a quick star rating — it helps others find the tool and keeps us motivated to improve it.
>
> 👉 **[Leave a ⭐ Review on Apify](https://console.apify.com/actors/Kl8XqqLsqY5PQV0K9/reviews)**

> **Having a problem?** No data returned, unexpected output, or something broke?
>
> 👉 **[Open an Issue on Apify](https://console.apify.com/actors/Kl8XqqLsqY5PQV0K9/issues)**

When raising an issue, please include:

- The tweet URL(s) that failed
- The error message from the Actor log
- Your proxy configuration (if any)

**Self-check before reporting:**

1. ✅ URL is correct and accessible in incognito mode
2. ✅ Tweet contains media (photo, video, or GIF)
3. ✅ Account is not private or suspended
4. ✅ Using a valid format: `https://x.com/username/status/ID` or bare tweet ID

Thank you for your support — it means a lot! 🙏

# Actor input Schema

## `tweetUrls` (type: `array`):

Enter X/Twitter URLs or tweet IDs. Supports: https://x.com/username/status/123, https://twitter.com/username/status/123, or just the tweet ID.

## `includeStats` (type: `boolean`):

When enabled, engagement statistics (likes, retweets, comments) will be included in the dataset.

## `useStandbyMode` (type: `boolean`):

When enabled, the Actor stays running as a standby server after extraction is complete — useful for integrations that send repeated requests. When disabled, the Actor exits immediately after processing all URLs (recommended for one-off runs).

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

Select proxies to be used. Residential proxies are highly recommended.

## Actor input object example

```json
{
  "tweetUrls": [
    "https://x.com/teslaownersSV/status/2004891561180758165",
    "https://x.com/sciencegirl/status/2048046638254489836"
  ],
  "includeStats": true,
  "useStandbyMode": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `media_gallery` (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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "tweetUrls": [
        "https://x.com/teslaownersSV/status/2004891561180758165",
        "https://x.com/sciencegirl/status/2048046638254489836"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("api402/x-twitter-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 = {
    "tweetUrls": [
        "https://x.com/teslaownersSV/status/2004891561180758165",
        "https://x.com/sciencegirl/status/2048046638254489836",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("api402/x-twitter-media-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 '{
  "tweetUrls": [
    "https://x.com/teslaownersSV/status/2004891561180758165",
    "https://x.com/sciencegirl/status/2048046638254489836"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call api402/x-twitter-media-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "X (Twitter) Media Downloader — Fastest, No Rate Limit, $0.5/1K",
        "description": "The fastest X/Twitter media scraper with standby mode. Download images, videos, GIFs & thumbnails from any public tweet. No rate limit. Only $0.5 per 1,000 requests. No login, no API key needed. Bulk URL support with direct CDN links.",
        "version": "0.0",
        "x-build-id": "XT00OhMZCQjnufAEE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api402~x-twitter-media-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api402-x-twitter-media-downloader",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/api402~x-twitter-media-downloader/runs": {
            "post": {
                "operationId": "runs-sync-api402-x-twitter-media-downloader",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/api402~x-twitter-media-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-api402-x-twitter-media-downloader",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "tweetUrls": {
                        "title": "Tweet URLs or IDs",
                        "type": "array",
                        "description": "Enter X/Twitter URLs or tweet IDs. Supports: https://x.com/username/status/123, https://twitter.com/username/status/123, or just the tweet ID.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeStats": {
                        "title": "Include tweet stats",
                        "type": "boolean",
                        "description": "When enabled, engagement statistics (likes, retweets, comments) will be included in the dataset.",
                        "default": true
                    },
                    "useStandbyMode": {
                        "title": "Keep Actor alive (Standby mode)",
                        "type": "boolean",
                        "description": "When enabled, the Actor stays running as a standby server after extraction is complete — useful for integrations that send repeated requests. When disabled, the Actor exits immediately after processing all URLs (recommended for one-off runs).",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used. Residential proxies are highly recommended."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
