# Truth Social Scraper — Posts, Profiles & Engagement API (`bovi/truth-social-scraper`) Actor

Scrape Truth Social posts and profiles with no login. Returns full post text, upvotes, reblogs, replies, media URLs, link cards, hashtags, mentions, plus account verified/premium status and follower counts. Pay per post.

- **URL**: https://apify.com/bovi/truth-social-scraper.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Social media, News, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.84 / 1,000 post / profiles

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 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

## Truth Social Scraper — Posts & Downvotes | $2.00/1K | No Login | Unique Downvote Field

For political researchers, media monitoring agencies, and campaign analytics teams tracking Truth Social at scale.

**We are the only actor with `downvote_count` extraction — critical for sentiment analysis on this platform.**

**Pricing: $2.00 per 1,000 posts.** No monthly fees. No login required.

Extract posts and profile data from any public Truth Social account without login credentials. Returns upvotes, **downvotes** (unique field), link cards, media URLs, reply chains, and author details — pay only per post scraped.

### Pricing example

**$2.00 per 1,000 posts**. 100 posts = $0.20. 1,000 posts = $2.00. 10,000 posts = $20.00. No per-run fee. No proxy cost.

### Sample output

```json
{
  "account_username": "realDonaldTrump",
  "display_name": "Donald J. Trump",
  "post_id": "112345678901234567",
  "content_text": "MAKE AMERICA GREAT AGAIN!",
  "created_at": "2026-05-20T15:42:00Z",
  "replies": 1823,
  "reblogs": 4501,
  "favourites": 22340,
  "upvotes": 22340,
  "downvotes": 312,
  "url": "https://truthsocial.com/@realDonaldTrump/112345678901234567",
  "has_media": false,
  "card_url": null,
  "parse_confidence": 1.0,
  "scraped_at": "2026-06-05T09:00:00Z"
}
````

### What you get

Each record contains:

| Field | Description |
|---|---|
| `account_username` | Username (e.g. `realDonaldTrump`) |
| `display_name` | Full display name |
| `verified` / `premium` | Account verification status |
| `followers` / `following` | Follower counts |
| `post_id` | Unique post ID |
| `content_text` | Post text (HTML stripped) |
| `content_html` | Raw HTML content |
| `created_at` | Post timestamp (ISO 8601 UTC) |
| `replies` | Reply count |
| `reblogs` | Re-truth count |
| `favourites` | Like count |
| `upvotes` | Truth Social upvote count (same as favourites) |
| `downvotes` | Truth Social downvote count — **unique field** |
| `url` | Direct post URL |
| `media_urls` | Array of direct media URLs (images, videos) |
| `card_url` / `card_title` / `card_description` / `card_image_url` | Link card details for shared URLs |
| `mentions` | Mentioned usernames |
| `hashtags` | Hashtag names |
| `in_reply_to_id` | Parent post ID if this is a reply |
| `is_reblog` | Whether this is a re-truth |
| `parse_confidence` | Data quality score 0.0–1.0 |
| `warnings` | List of any data quality issues |

### Why this scraper beats the competition

| | This scraper | apify/truth-social-scraper (official) | Generic Mastodon scraper |
|---|:---:|:---:|:---:|
| Price | **$2.00/1K** | $5.00/1K+ | varies |
| `downvote_count` field | ✓ | ✗ | ✗ |
| Link card extraction (URL/title/image) | ✓ | partial | ✗ |
| Incremental scraping via `sincePostId` | ✓ | ✗ | ✗ |
| `parse_confidence` on every record | ✓ | ✗ | ✗ |
| No login required | ✓ | ✓ | ✓ |

Most Truth Social scrapers on Apify return only basic engagement counts. This scraper adds:

- **`downvotes_count` field** — Truth Social's Mastodon API exposes upvotes and downvotes separately. No other scraper surfaces downvotes, which is critical for sentiment analysis.
- **Link card extraction** — captures the URL, title, description, and preview image of any article or link a post is sharing. Essential for media monitoring and influence research.
- **`parse_confidence` + `warnings` in every record** — self-reported data quality so you know when fields may be incomplete.
- **Incremental scraping** via `sincePostId` cursor — re-run without re-fetching old posts.
- **Account ID input** — supply numeric IDs directly for power workflows that already know them.

### Input

```json
{
  "accountUsernames": ["realDonaldTrump"],
  "maxPostsPerAccount": 100,
  "includeReplies": false,
  "includeReposts": false
}
```

| Field | Type | Default | Description |
|---|---|---|---|
| `accountUsernames` | `string[]` | — | Usernames to scrape (without @) |
| `accountIds` | `string[]` | — | Numeric account IDs (alternative to usernames) |
| `maxPostsPerAccount` | `integer` | 100 | Posts per account (0 = unlimited) |
| `includeReplies` | `boolean` | false | Include reply posts |
| `includeReposts` | `boolean` | false | Include re-truths |
| `sincePostId` | `string` | — | Only fetch posts newer than this ID (incremental) |

### Pricing

**$2.00 per 1,000 posts.** No monthly fees. No login required.

### How it works

Truth Social runs a Mastodon-compatible REST API with public endpoints that require no authentication for public accounts. This scraper uses cursor-based pagination (`max_id`) to efficiently fetch posts in chronological reverse order, normalizes all fields to a flat schema, and strips HTML from post content.

### Limitations

- Only public accounts are accessible (private/deactivated accounts return an error, not empty data)
- Comments on posts require authentication — not accessible without login
- Public timeline and search endpoints are disabled by Truth Social
- Rate limits are not documented; scraping very high volumes may be throttled

### Typical use cases

- **Political monitoring** — track posts from political figures
- **Sentiment analysis** — upvotes/downvotes ratio as engagement signal (unique `downvotes` field)
- **Media intelligence** — extract shared URLs via link cards
- **Research** — academic study of alternative social platform content
- **Alerts and dashboards** — incremental scraping with `sincePostId`

### Incremental / monitoring workflow

Use `sincePostId` to run this actor on a schedule and receive only new posts since the last run. Set `sincePostId` to the highest `post_id` returned in your previous dataset. Ideal for building daily political dashboards or alert systems.

### Use with AI Agents (MCP)

This Truth Social scraper is callable as a **tool by AI agents** (Claude Desktop, Cursor, VS Code, n8n, or any MCP-compatible client) via Apify's hosted Model Context Protocol server.

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

### Integrations

Built for political researchers, media-monitoring agencies, and campaign-analytics teams tracking Truth Social posts and sentiment — the JSON/dataset output drops into the tools you already run, no glue code:

- **n8n / Make / Zapier** — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, HubSpot, your database) with no code: [n8n](https://docs.apify.com/platform/integrations/n8n), [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier).
- **Webhooks** — fire your own endpoint the moment a run finishes, to push results straight into your pipeline ([docs](https://docs.apify.com/platform/integrations/webhooks)).
- **MCP server** — expose this actor as a tool to Claude, Cursor, or any [MCP client](https://mcp.apify.com) so an AI agent can pull this data mid-conversation ([guide](https://blog.apify.com/how-to-use-mcp/)).
- **API & SDKs** — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all [Apify integrations](https://apify.com/integrations).

### More scrapers from our toolkit

Building a data pipeline? These actors pair well with this one — each runs on your own Apify account with the same pay-per-result pricing, no subscription:

- [Twitch Scraper](https://apify.com/bovi/twitch-scraper)
- [Douyin Scraper](https://apify.com/bovi/douyin-scraper)
- [Maigret Username Osint](https://apify.com/bovi/maigret-username-osint)
- [Patreon Scraper](https://apify.com/bovi/patreon-scraper)
- [Pinterest Scraper](https://apify.com/bovi/pinterest-scraper)
- [Reddit Scraper](https://apify.com/bovi/reddit-scraper)

Chain any of them together from the **Integrations** tab (the *Run succeeded* trigger) to build a multi-step workflow — one actor's output feeds the next.

### Use it from your existing tools

#### Use with Claude Desktop / Cursor / Cline (MCP)

Load this actor as a tool in your AI assistant. Call it directly from your AI assistant via the Apify MCP server — no Store browsing needed. Paste this into your MCP client config (e.g. `claude_desktop_config.json`) and restart the client:

```json
{
  "mcpServers": {
    "apify-truth-social-scraper": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/actors-mcp-server",
        "--tools",
        "bovi/truth-social-scraper"
      ],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

Replace `YOUR_APIFY_TOKEN` with your own Apify API token (free at apify.com → Settings → Integrations). Curated to a handful of tools so the agent selects reliably.

#### Works with Clay

Run this actor as an HTTP enrichment step inside a Clay table:

- **Method:** `POST`
- **URL:** `https://api.apify.com/v2/acts/bovi~truth-social-scraper/run-sync-get-dataset-items?token={{apify_token}}`
- **Body (JSON):** map your Clay columns to the actor input (see the Input section above), e.g. `{"accountUsernames": "{{clay_column}}"}`

The run finishes synchronously and returns the dataset rows straight into your Clay table. It runs on Apify's cloud under your own token and usage. Synchronous runs must complete within 300 seconds.

# Actor input Schema

## `accountUsernames` (type: `array`):

List of Truth Social usernames to scrape (without @). Example: realDonaldTrump

## `accountIds` (type: `array`):

List of Truth Social numeric account IDs (alternative to usernames). Use when you already know the ID from a previous scrape.

## `maxPostsPerAccount` (type: `integer`):

Maximum number of posts to return per account. 0 means no limit (may be slow for high-volume accounts).

## `includeReplies` (type: `boolean`):

If enabled, includes posts that are replies to other users. Disabled by default to return only original posts.

## `includeReposts` (type: `boolean`):

If enabled, includes reposted content (re-truths). Disabled by default.

## `sincePostId` (type: `string`):

Only fetch posts newer than this post ID. Use for incremental scraping — set to the last post\_id from the previous run.

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

Apify Proxy settings. RESIDENTIAL recommended — Truth Social sits behind Cloudflare which blocks datacenter IPs.

## Actor input object example

```json
{
  "accountUsernames": [
    "realDonaldTrump"
  ],
  "maxPostsPerAccount": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset containing Truth Social Scraper records (account\_username, display\_name, verified, followers, content\_text, reblogs, favourites, upvotes, downvotes, url, created\_at, parse\_confidence).

# 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 = {
    "accountUsernames": [
        "realDonaldTrump"
    ],
    "maxPostsPerAccount": 100,
    "includeReplies": false,
    "includeReposts": false,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/truth-social-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 = {
    "accountUsernames": ["realDonaldTrump"],
    "maxPostsPerAccount": 100,
    "includeReplies": False,
    "includeReposts": False,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/truth-social-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 '{
  "accountUsernames": [
    "realDonaldTrump"
  ],
  "maxPostsPerAccount": 100,
  "includeReplies": false,
  "includeReposts": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call bovi/truth-social-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Truth Social Scraper — Posts, Profiles & Engagement API",
        "description": "Scrape Truth Social posts and profiles with no login. Returns full post text, upvotes, reblogs, replies, media URLs, link cards, hashtags, mentions, plus account verified/premium status and follower counts. Pay per post.",
        "version": "0.1",
        "x-build-id": "U6V6hc76sgCXDxUPs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bovi~truth-social-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bovi-truth-social-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/bovi~truth-social-scraper/runs": {
            "post": {
                "operationId": "runs-sync-bovi-truth-social-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/bovi~truth-social-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-bovi-truth-social-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",
                "properties": {
                    "accountUsernames": {
                        "title": "Account usernames",
                        "type": "array",
                        "description": "List of Truth Social usernames to scrape (without @). Example: realDonaldTrump",
                        "items": {
                            "type": "string"
                        }
                    },
                    "accountIds": {
                        "title": "Account IDs",
                        "type": "array",
                        "description": "List of Truth Social numeric account IDs (alternative to usernames). Use when you already know the ID from a previous scrape.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPostsPerAccount": {
                        "title": "Max posts per account",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of posts to return per account. 0 means no limit (may be slow for high-volume accounts)."
                    },
                    "includeReplies": {
                        "title": "Include replies",
                        "type": "boolean",
                        "description": "If enabled, includes posts that are replies to other users. Disabled by default to return only original posts."
                    },
                    "includeReposts": {
                        "title": "Include reposts (re-truths)",
                        "type": "boolean",
                        "description": "If enabled, includes reposted content (re-truths). Disabled by default."
                    },
                    "sincePostId": {
                        "title": "Since post ID (cursor)",
                        "type": "string",
                        "description": "Only fetch posts newer than this post ID. Use for incremental scraping — set to the last post_id from the previous run."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. RESIDENTIAL recommended — Truth Social sits behind Cloudflare which blocks datacenter IPs.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
