# Reddit Media Downloader (`khadinakbar/reddit-media-downloader`) Actor

Download Reddit-hosted images, galleries, GIFs, and video/audio streams from public post URLs. Saves media files to KV and returns clean MCP-ready rows.

- **URL**: https://apify.com/khadinakbar/reddit-media-downloader.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, Videos, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 media extracteds

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Reddit Media Downloader

Download Reddit-hosted images, galleries, GIFs, and video streams from public Reddit post URLs. This actor resolves the Reddit post metadata, extracts every supported media asset, optionally saves the files to the run key-value store, and returns one clean dataset row per media item.

It is built for content archives, research collections, moderation workflows, social listening, AI-agent pipelines, and no-code automations that need files, not just Reddit post text.

### What It Extracts

| Field | Description |
| --- | --- |
| `mediaUrl` | Direct Reddit or Reddit CDN media URL. |
| `fileKey` and `fileApiUrl` | Key-value store location when file saving is enabled. |
| `audioUrl` and `audioFileApiUrl` | Separate v.redd.it audio stream when Reddit exposes one. |
| `mediaType` | `image`, `gif`, `video`, `audio`, or `manifest`. |
| `title`, `subreddit`, `author`, `score` | Useful Reddit post metadata for sorting and attribution. |
| `dashUrl`, `hlsUrl` | Video manifest URLs for advanced processing. |
| `downloadStatus` | Tells you whether the file was saved, skipped, too large, or unavailable. |

### When To Use

Use this actor when you have one or more public Reddit post URLs and need the media assets behind those posts. It is especially useful for Reddit video archiving because Reddit often separates the video stream and audio stream. The actor records both so downstream tools can merge, transcode, or store them.

Use a broader Reddit scraper when you need search results, subreddit feeds, comments, or user profile data. This actor starts from known post URLs and focuses on media extraction and download storage.

### Input

```json
{
  "urls": [
    "https://www.reddit.com/r/ChatGPT/comments/1iic23b/who_said_ai_videos_cant_do_physics/"
  ],
  "maxMediaItems": 25,
  "downloadMedia": true,
  "downloadAudio": true,
  "maxFileSizeMb": 250,
  "includeVideoVariants": true,
  "includeNsfw": false
}
````

`urls` accepts full Reddit post URLs. The actor soft-skips invalid, private, deleted, or unsupported URLs and records the reason in `OUTPUT`.

`downloadMedia` controls whether binary files are saved to the default key-value store. Turn it off when you only need direct source URLs and metadata.

`maxFileSizeMb` protects storage and runtime cost. Oversized files still produce metadata rows with `downloadStatus` set to `skipped_too_large`.

### Output Example

```json
{
  "recordType": "media",
  "sourceUrl": "https://www.reddit.com/r/example/comments/abc123/example/",
  "canonicalPostUrl": "https://www.reddit.com/r/example/comments/abc123/example/",
  "postId": "abc123",
  "subreddit": "r/example",
  "title": "Example Reddit video",
  "mediaType": "video",
  "mediaUrl": "https://v.redd.it/example/DASH_720.mp4",
  "audioUrl": "https://v.redd.it/example/DASH_audio.mp4",
  "downloadStatus": "saved",
  "fileKey": "MEDIA_abc123_000_media.mp4",
  "fileApiUrl": "https://api.apify.com/v2/key-value-stores/.../records/MEDIA_abc123_000_media.mp4",
  "audioDownloadStatus": "saved",
  "audioFileKey": "MEDIA_abc123_000_audio.mp4",
  "assetIndex": 0,
  "assetCount": 1,
  "provider": "reddit-oauth",
  "scrapedAt": "2026-07-08T00:00:00.000Z"
}
```

### Metadata Sources

The actor tries metadata resolvers in this order:

1. Reddit OAuth using `REDDIT_CLIENT_ID` and `REDDIT_CLIENT_SECRET`.
2. ScrapeCreators using `SCRAPECREATORS_API_KEY`.
3. SociaVault using `SOCIAVAULT_API_KEY`.

The media files themselves are downloaded directly from Reddit-hosted media URLs such as `i.redd.it`, `preview.redd.it`, and `v.redd.it`. If no resolver is configured, the actor exits successfully with a warning and a machine-readable summary instead of marking the run as failed.

### Pricing

This actor uses pay per event pricing.

| Event | Price |
| --- | ---: |
| Actor start | $0.00005 |
| Media extracted | $0.005 per media row |

The run status message shows the maximum possible cost before extraction starts. `maxMediaItems` is a hard billing cap.

### Limits

Reddit-hosted media is supported. External hosts such as Imgur, YouTube, TikTok, or news sites are not downloaded by this actor. Posts that are private, deleted, removed, login-gated, or blocked by Reddit may not resolve.

Reddit video and audio are usually separate files. This actor saves both when available, but it does not merge or transcode them. Use ffmpeg or a media pipeline downstream if you need a single combined MP4.

### API Example

```bash
apify call khadinakbar/reddit-media-downloader --input='{
  "urls": ["https://www.reddit.com/r/ChatGPT/comments/1iic23b/who_said_ai_videos_cant_do_physics/"],
  "maxMediaItems": 10,
  "downloadMedia": true
}'
```

### Legal And Responsible Use

Download only content you are allowed to use. Respect Reddit users, subreddit rules, copyright, privacy rights, platform terms, and applicable laws. This actor provides technical extraction of public media URLs and files; you are responsible for how the downloaded media is stored, shared, edited, or reused.

# Actor input Schema

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

Use this when you have public Reddit post URLs and need downloadable media files or direct media links. Accepts full URLs such as https://www.reddit.com/r/ChatGPT/comments/1iic23b/who\_said\_ai\_videos\_cant\_do\_physics/. Defaults to one sample video post. Not for private, deleted, login-only, or non-Reddit URLs.

## `maxMediaItems` (type: `integer`):

Use this as the hard cap on billable media rows returned across all URLs. Default is 100, range is 1 to 10000, and the actor stops as soon as the cap is reached. At $0.005 per media item, maxMediaItems=100 means about $0.50 maximum PPE spend. Not a per-post limit.

## `downloadMedia` (type: `boolean`):

Use this when you want the actor to download media bytes into the default key-value store. True saves images, GIFs, primary video streams, and optionally audio streams, then returns file keys and API URLs. False returns direct source URLs only. Not a video-audio merge option.

## `downloadAudio` (type: `boolean`):

Use this when downloadMedia is true and you want the separate v.redd.it audio stream saved when Reddit exposes one. Reddit often stores video and audio separately, so this creates audioFileKey fields on video records. Defaults to true. Not used for image or gallery posts.

## `maxFileSizeMb` (type: `integer`):

Use this to stop very large files from being saved to key-value store. Default is 250 MB per media or audio file, range is 1 to 2048. Oversized files still produce metadata rows with downloadStatus=skipped\_too\_large. Not a total run storage cap.

## `includeVideoVariants` (type: `boolean`):

Use this when you need DASH and HLS manifest URLs for advanced video processing. Defaults to true and adds dashUrl, hlsUrl, scrubberMediaUrl, and audioUrl when Reddit exposes them. The actor still saves only the primary MP4 and audio stream by default. Not a transcoding feature.

## `includeNsfw` (type: `boolean`):

Use this only when you intentionally want media from posts marked NSFW by Reddit. Defaults to false for business, research, and AI-agent workflows. NSFW posts are skipped with a clear summary reason when disabled. Not a content moderation classifier.

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

Use this to route Reddit metadata and media downloads through Apify Proxy. The default uses residential proxies because Reddit web endpoints can block datacenter networks. Keep the default unless your account has a specific proxy policy. Not required for provider-only fallback metadata.

## `redditClientId` (type: `string`):

Optional Reddit app client ID for the official OAuth metadata path. Leave blank to use the owner-managed REDDIT\_CLIENT\_ID secret when configured. Example format is the app client ID from reddit.com/prefs/apps. Not your Reddit username.

## `redditClientSecret` (type: `string`):

Optional Reddit app client secret paired with redditClientId. Leave blank to use the owner-managed REDDIT\_CLIENT\_SECRET secret when configured. This lets the actor resolve public post metadata without scraping Reddit HTML. Not your Reddit password.

## Actor input object example

```json
{
  "urls": [
    "https://www.reddit.com/r/ChatGPT/comments/1iic23b/who_said_ai_videos_cant_do_physics/",
    "https://www.reddit.com/r/pics/comments/example/example_title/"
  ],
  "maxMediaItems": 25,
  "downloadMedia": true,
  "downloadAudio": true,
  "maxFileSizeMb": 250,
  "includeVideoVariants": true,
  "includeNsfw": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `media` (type: `string`):

Dataset items containing Reddit media source URLs, saved file keys, post metadata, and provider details.

## `summary` (type: `string`):

Aggregate counts, provider breakdown, skipped URLs, download totals, and estimated PPE billing.

# 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.reddit.com/r/ChatGPT/comments/1iic23b/who_said_ai_videos_cant_do_physics/"
    ],
    "maxMediaItems": 25,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/reddit-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.reddit.com/r/ChatGPT/comments/1iic23b/who_said_ai_videos_cant_do_physics/"],
    "maxMediaItems": 25,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/reddit-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 '{
  "urls": [
    "https://www.reddit.com/r/ChatGPT/comments/1iic23b/who_said_ai_videos_cant_do_physics/"
  ],
  "maxMediaItems": 25,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/reddit-media-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Media Downloader",
        "description": "Download Reddit-hosted images, galleries, GIFs, and video/audio streams from public post URLs. Saves media files to KV and returns clean MCP-ready rows.",
        "version": "0.1",
        "x-build-id": "IRE3azqZgayhjITpj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~reddit-media-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-reddit-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/khadinakbar~reddit-media-downloader/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-reddit-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/khadinakbar~reddit-media-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-reddit-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",
                "required": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "Reddit post URLs",
                        "type": "array",
                        "description": "Use this when you have public Reddit post URLs and need downloadable media files or direct media links. Accepts full URLs such as https://www.reddit.com/r/ChatGPT/comments/1iic23b/who_said_ai_videos_cant_do_physics/. Defaults to one sample video post. Not for private, deleted, login-only, or non-Reddit URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxMediaItems": {
                        "title": "Max media items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Use this as the hard cap on billable media rows returned across all URLs. Default is 100, range is 1 to 10000, and the actor stops as soon as the cap is reached. At $0.005 per media item, maxMediaItems=100 means about $0.50 maximum PPE spend. Not a per-post limit.",
                        "default": 100
                    },
                    "downloadMedia": {
                        "title": "Save media files",
                        "type": "boolean",
                        "description": "Use this when you want the actor to download media bytes into the default key-value store. True saves images, GIFs, primary video streams, and optionally audio streams, then returns file keys and API URLs. False returns direct source URLs only. Not a video-audio merge option.",
                        "default": true
                    },
                    "downloadAudio": {
                        "title": "Save Reddit video audio",
                        "type": "boolean",
                        "description": "Use this when downloadMedia is true and you want the separate v.redd.it audio stream saved when Reddit exposes one. Reddit often stores video and audio separately, so this creates audioFileKey fields on video records. Defaults to true. Not used for image or gallery posts.",
                        "default": true
                    },
                    "maxFileSizeMb": {
                        "title": "Max file size MB",
                        "minimum": 1,
                        "maximum": 2048,
                        "type": "integer",
                        "description": "Use this to stop very large files from being saved to key-value store. Default is 250 MB per media or audio file, range is 1 to 2048. Oversized files still produce metadata rows with downloadStatus=skipped_too_large. Not a total run storage cap.",
                        "default": 250
                    },
                    "includeVideoVariants": {
                        "title": "Include video manifest links",
                        "type": "boolean",
                        "description": "Use this when you need DASH and HLS manifest URLs for advanced video processing. Defaults to true and adds dashUrl, hlsUrl, scrubberMediaUrl, and audioUrl when Reddit exposes them. The actor still saves only the primary MP4 and audio stream by default. Not a transcoding feature.",
                        "default": true
                    },
                    "includeNsfw": {
                        "title": "Include NSFW posts",
                        "type": "boolean",
                        "description": "Use this only when you intentionally want media from posts marked NSFW by Reddit. Defaults to false for business, research, and AI-agent workflows. NSFW posts are skipped with a clear summary reason when disabled. Not a content moderation classifier.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Use this to route Reddit metadata and media downloads through Apify Proxy. The default uses residential proxies because Reddit web endpoints can block datacenter networks. Keep the default unless your account has a specific proxy policy. Not required for provider-only fallback metadata.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "redditClientId": {
                        "title": "Reddit client ID",
                        "type": "string",
                        "description": "Optional Reddit app client ID for the official OAuth metadata path. Leave blank to use the owner-managed REDDIT_CLIENT_ID secret when configured. Example format is the app client ID from reddit.com/prefs/apps. Not your Reddit username."
                    },
                    "redditClientSecret": {
                        "title": "Reddit client secret",
                        "type": "string",
                        "description": "Optional Reddit app client secret paired with redditClientId. Leave blank to use the owner-managed REDDIT_CLIENT_SECRET secret when configured. This lets the actor resolve public post metadata without scraping Reddit HTML. Not your Reddit password."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
