# Telegram Scraper - Channels, Messages, Media & Search (`scrapesage/telegram-scraper`) Actor

Scrape public Telegram channels: full message history, media, reactions, polls, forwards, replies, link previews, channel stats, and in-channel keyword search. HTTP-only, no login or phone number required.

- **URL**: https://apify.com/scrapesage/telegram-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Social media, News, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 message scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Telegram Scraper - Channels, Messages, Media & Search

Extract data from **public Telegram channels** at scale — full **message history**, **media**, **reactions**, **polls**, **forwards**, **replies**, **link previews**, **channel stats**, and **in-channel keyword search**. **No login, no phone number, no API keys.**

No login / no cookies — HTTP-only (no headless browser) for fast, low-cost, reliable runs.

### Why this Telegram scraper?

| Typical scrapers | This actor |
|---|---|
| Require a phone number, login, or API credentials | No login, no phone number, no API keys — reads the public web preview |
| Return plain message text only | Returns text **plus** views, author, forwards, replies, hashtags, mentions, links, media, polls and link previews |
| Headless browser, slow and expensive | HTTP-only (Cheerio) — fast, low-cost, reliable |
| No way to filter inside a channel | Native **in-channel keyword search** returns only matching messages |
| Whole-timeline only | Filter by date range (newer than / older than, ISO or relative like `7 days`) |
| Channel metadata is an afterthought | Dedicated `channelInfo` mode for title, description, subscriber and content counts |

### Use cases

- **Crypto / web3 monitoring** — track trading-signal channels and community sentiment across many channels at once.
- **OSINT & threat intelligence** — collect message history, forwards, and link previews from public channels for analysis.
- **News & topic aggregation** — pull fresh posts from news and announcement channels and filter to a recent date window.
- **Brand & competitor tracking** — search channels by keyword to surface only mentions you care about.
- **LLM / RAG dataset building** — export clean, structured message records for fine-tuning, retrieval, and sentiment pipelines.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Telegram Scraper**, fill in the inputs you need, and click **Start**.
3. Watch results stream into the dataset table as each record is parsed.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "channels": ["@durov", "https://t.me/telegram"],
    "resultsType": "messages",
    "maxMessages": 200,
    "searchQuery": "",
    "oldestMessageDate": "30 days",
    "downloadMedia": false,
    "proxyConfiguration": { "useApifyProxy": true }
}
````

- **`channels`** *(required, array)* — public channels to scrape. Accepts `@username`, plain `username`, or a `t.me/username` URL (also `t.me/s/username`). Private/invite-only channels are not supported.
- **`resultsType`** *(string, default `messages`)* — `messages` to scrape each channel's messages, or `channelInfo` for channel metadata/stats only.
- **`maxMessages`** *(integer, default `100`)* — max messages per channel. Ignored when `resultsType` is `channelInfo`.
- **`searchQuery`** *(string, optional)* — when set, returns only messages matching this keyword in each channel, using Telegram's native in-channel search. Leave empty to scrape the full timeline.
- **`oldestMessageDate`** *(string, optional)* — stop once messages older than this date are reached. Accepts ISO dates (e.g. `2026-01-01`) or relative values like `7 days`, `3 months`.
- **`newestMessageDate`** *(string, optional)* — skip messages newer than this date. Accepts ISO or relative values like `1 day`.
- **`downloadMedia`** *(boolean, default `false`)* — download photos/videos/documents into the run's key-value store and add a reference to each record. Media URLs are always included regardless of this setting.
- **`proxyConfiguration`** *(object)* — proxy settings; Apify Proxy (datacenter) recommended for reliability at scale.

### Output

In `messages` mode, each message is one dataset record:

```json
{
    "channel": "durov",
    "messageId": 372,
    "url": "https://t.me/durov/372",
    "date": "2026-05-21T14:02:11+00:00",
    "text": "Example post text...",
    "views": 1200000,
    "author": "Pavel Durov",
    "forwardedFrom": null,
    "forwardedFromUrl": null,
    "replyToUrl": null,
    "isPinned": false,
    "hashtags": ["#telegram"],
    "mentions": ["@telegram"],
    "links": ["https://example.com"],
    "media": [{ "type": "photo", "url": "https://cdn5.telesco.pe/file/..." }],
    "poll": null,
    "linkPreview": null
}
```

In `channelInfo` mode, each record contains `channel`, `url`, `title`, `username`, `description`, `avatarUrl`, `subscribers`, and content counts (`photosCount`, `videosCount`, `filesCount`, `linksCount`).

Notes:

- Optional fields are returned as `null` when Telegram doesn't expose them on the public preview (e.g. `author`, `views`, `forwardedFrom`, `poll`, `linkPreview`).
- When `downloadMedia` is enabled and a file is stored, each `media` item gains a `storeKey` pointing to the run's key-value store; media URLs are always present either way.
- Private/invite-only channels are skipped with a clear log message; the run still completes as a success.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it on a cron to keep your data fresh.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions the moment a run finishes.

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/telegram-scraper').call({
    channels: ['@durov', 'https://t.me/telegram'],
    resultsType: 'messages',
    maxMessages: 200,
    oldestMessageDate: '30 days',
    downloadMedia: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} records`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new records straight into your CRM or sheet.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a run finds something new.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "pull the last 200 messages from @durov and summarize what changed this week" and let it run this scraper for you.

### More scrapers from scrapesage

Need data from other sources? Try these scrapesage actors:

- [facebook-ad-library-scraper](https://apify.com/scrapesage/facebook-ad-library-scraper) — Meta/Instagram competitor ad intelligence.
- [google-ads-transparency-scraper](https://apify.com/scrapesage/google-ads-transparency-scraper) — see who's advertising what on Google.
- [bark-scraper](https://apify.com/scrapesage/bark-scraper) — Bark.com provider profiles & leads.
- [sam-gov-scraper](https://apify.com/scrapesage/sam-gov-scraper) — US federal contract opportunities & contacts.
- [eventbrite-scraper](https://apify.com/scrapesage/eventbrite-scraper) — events plus organizer leads with contacts.
- [airbnb-scraper](https://apify.com/scrapesage/airbnb-scraper) — short-stay listings, prices, availability & market monitor.
- [linkedin-jobs-scraper](https://apify.com/scrapesage/linkedin-jobs-scraper) — filter-based LinkedIn job postings, no login.

### Tips

- Pass channels as `@username`, plain `username`, or full `t.me/...` links — the actor normalizes all three.
- Combine `searchQuery` with your channel list to pull only on-topic messages instead of the whole timeline (note: it searches within the channels you provide, not all of Telegram).
- Use `oldestMessageDate` / `newestMessageDate` with relative values like `7 days` to keep recurring runs lightweight.
- Only enable `downloadMedia` when you need the actual files — URLs are always included, and skipping the download keeps runs faster and cheaper.
- Keep `proxyConfiguration` on Apify Proxy (datacenter) for reliable runs at scale.

### FAQ

**Do I need a Telegram account, phone number, or API key?**
No. The actor reads Telegram's public web preview over HTTP — no login, no phone number, no credentials.

**Can it scrape private or invite-only channels?**
No. Only public channels are accessible via the public web preview. Private/invite-only channels (and standard user-account messages) are skipped with a clear log message.

**Is this legal?**
The actor only collects publicly visible data from public channels. You are responsible for using the data in line with Telegram's terms and applicable laws.

**What if a channel has no matching messages?**
Empty results are reported as a successful run. Date filters and `searchQuery` may legitimately return zero records for a given channel.

**In what formats can I export the data?**
JSON, CSV, Excel, XML, or RSS via the Apify console, or programmatically through the [Apify API](https://docs.apify.com/api/v2).

**Where do downloaded media files go?**
Into the run's default key-value store (when `downloadMedia` is enabled), with a `storeKey` reference added to each media item in the dataset.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

## `channels` (type: `array`):

Public Telegram channels to scrape. Accepts @username, plain username, or t.me/username URL (also t.me/s/username). Private/invite-only channels are not supported.

## `resultsType` (type: `string`):

Scrape messages from each channel, or only the channel's metadata/stats.

## `maxMessages` (type: `integer`):

Maximum number of messages to scrape from each channel. Ignored when 'What to scrape' is 'Channel info only'.

## `searchQuery` (type: `string`):

Optional. When set, only messages matching this keyword are returned for each channel (uses Telegram's native in-channel search). Leave empty to scrape the full timeline.

## `oldestMessageDate` (type: `string`):

Optional. Stop scraping a channel once messages older than this date are reached. Accepts ISO date (e.g. 2026-01-01) or relative values like '7 days', '3 months'.

## `newestMessageDate` (type: `string`):

Optional. Skip messages newer than this date. Accepts ISO date or relative values like '1 day'.

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

Download photos/videos/documents attached to messages into the run's key-value store and add a reference to each record. Media URLs are always included regardless of this setting.

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

Proxy settings. Telegram's public web preview is lenient, but a proxy improves reliability at scale. Apify Proxy (datacenter) recommended.

## Actor input object example

```json
{
  "channels": [
    "@telegram",
    "https://t.me/durov"
  ],
  "resultsType": "messages",
  "maxMessages": 100,
  "downloadMedia": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `messages` (type: `string`):

One record per Telegram message (in 'messages' mode) or per channel (in 'channelInfo' mode), stored in the default dataset.

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

Photos, videos, voice notes, and documents downloaded into the default key-value store when 'Download media files' is enabled.

# 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 = {
    "channels": [
        "telegram",
        "durov"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/telegram-scraper").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 = { "channels": [
        "telegram",
        "durov",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/telegram-scraper").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 '{
  "channels": [
    "telegram",
    "durov"
  ]
}' |
apify call scrapesage/telegram-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Telegram Scraper - Channels, Messages, Media & Search",
        "description": "Scrape public Telegram channels: full message history, media, reactions, polls, forwards, replies, link previews, channel stats, and in-channel keyword search. HTTP-only, no login or phone number required.",
        "version": "1.0",
        "x-build-id": "hpNZe6z2f9XPJ3orU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~telegram-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-telegram-scraper",
                "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/scrapesage~telegram-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-telegram-scraper",
                "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/scrapesage~telegram-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-telegram-scraper",
                "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": [
                    "channels"
                ],
                "properties": {
                    "channels": {
                        "title": "Channels / usernames",
                        "type": "array",
                        "description": "Public Telegram channels to scrape. Accepts @username, plain username, or t.me/username URL (also t.me/s/username). Private/invite-only channels are not supported.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsType": {
                        "title": "What to scrape",
                        "enum": [
                            "messages",
                            "channelInfo"
                        ],
                        "type": "string",
                        "description": "Scrape messages from each channel, or only the channel's metadata/stats.",
                        "default": "messages"
                    },
                    "maxMessages": {
                        "title": "Max messages per channel",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of messages to scrape from each channel. Ignored when 'What to scrape' is 'Channel info only'.",
                        "default": 100
                    },
                    "searchQuery": {
                        "title": "Keyword search (within channel)",
                        "type": "string",
                        "description": "Optional. When set, only messages matching this keyword are returned for each channel (uses Telegram's native in-channel search). Leave empty to scrape the full timeline."
                    },
                    "oldestMessageDate": {
                        "title": "Only messages newer than",
                        "type": "string",
                        "description": "Optional. Stop scraping a channel once messages older than this date are reached. Accepts ISO date (e.g. 2026-01-01) or relative values like '7 days', '3 months'."
                    },
                    "newestMessageDate": {
                        "title": "Only messages older than",
                        "type": "string",
                        "description": "Optional. Skip messages newer than this date. Accepts ISO date or relative values like '1 day'."
                    },
                    "downloadMedia": {
                        "title": "Download media files",
                        "type": "boolean",
                        "description": "Download photos/videos/documents attached to messages into the run's key-value store and add a reference to each record. Media URLs are always included regardless of this setting.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Telegram's public web preview is lenient, but a proxy improves reliability at scale. Apify Proxy (datacenter) recommended.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
