# Truth Social Scraper (`automation-lab/truth-social-scraper`) Actor

Extract posts and profiles from Truth Social. Scrape Donald Trump and any public profile's posts, get engagement metrics, media, and author data. No API key needed. Export to JSON, CSV, or Excel.

- **URL**: https://apify.com/automation-lab/truth-social-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

### What does Truth Social Scraper do?

[Truth Social Scraper](https://apify.com/automation-lab/truth-social-scraper) is a fast, reliable tool for extracting posts and profile data from [Truth Social](https://truthsocial.com) — the social media platform used by Donald Trump, political figures, and millions of conservative users. Extract posts from any public profile, fetch specific posts by URL, or pull recent activity from top accounts.

The scraper uses the Mastodon-compatible Truth Social API combined with residential proxy rotation to bypass Cloudflare protection, delivering **clean, structured JSON data** with full post content, engagement metrics, author details, and media attachments.

**No API key or Truth Social account required.** The scraper handles authentication automatically.

### Who is Truth Social Scraper for?

**🔬 Political researchers and academics**
- Track statements and policy positions of political figures over time
- Analyze communication patterns, posting frequency, and engagement trends
- Build datasets for political science research and NLP analysis

**📰 Journalists and media organizations**
- Monitor Truth Social for breaking news from political figures
- Verify claims and track evolving statements
- Archive public statements with timestamps and engagement metrics

**📊 Marketing analysts and strategists**
- Analyze audience engagement on political content
- Track brand mentions and political sentiment
- Benchmark posting strategies and content performance

**🛠 Developers and data engineers**
- Build news monitoring dashboards and alert systems
- Feed Truth Social data into analytics pipelines
- Create sentiment analysis and NLP datasets from political discourse

### Why use Truth Social Scraper?

- ✅ **Actually works** — competitors often break when Cloudflare updates. Our residential proxy rotation handles CF challenges automatically.
- ✅ **No account needed** — works without a Truth Social login or API credentials
- ✅ **Rich data extraction** — captures all post fields including engagement counts, media attachments, author profiles, and hashtags
- ✅ **Flexible modes** — scrape profiles, fetch specific posts, or get trending content
- ✅ **Scale on demand** — handle any volume from a single post to thousands, with pagination built in
- ✅ **Clean, flat JSON** — no nested objects, ready for spreadsheets, databases, and data pipelines
- ✅ **Export anywhere** — download as JSON, CSV, Excel, XML, or RSS from Apify Console
- ✅ **Schedule runs** — set up daily or hourly monitoring with Apify's built-in scheduler

### What data can you extract?

#### 📝 Post data

| Field | Description |
|-------|-------------|
| `id` | Unique post ID |
| `url` | Direct URL to the post |
| `content` | Post text (HTML stripped, plain text) |
| `contentHtml` | Raw HTML content |
| `createdAt` | Publication timestamp (ISO 8601) |
| `repliesCount` | Number of replies |
| `reblogsCount` | Number of ReTruths (reposts) |
| `favouritesCount` | Number of likes/favorites |
| `isReblog` | Whether this is a ReTruth |
| `rebloggedFromUrl` | Original post URL (if ReTruth) |
| `inReplyToId` | Parent post ID (if reply) |
| `mediaAttachments` | Images and video URLs |
| `hashtags` | List of hashtag names |
| `mentions` | List of mentioned usernames |
| `visibility` | Post visibility (public/unlisted) |
| `language` | Detected language code |
| `scrapedAt` | When this post was scraped |

#### 👤 Author profile data

| Field | Description |
|-------|-------------|
| `authorId` | User account ID |
| `authorUsername` | Username (e.g., "realDonaldTrump") |
| `authorDisplayName` | Display name (e.g., "Donald J. Trump") |
| `authorUrl` | Profile URL |
| `authorAvatarUrl` | Profile picture URL |
| `authorFollowersCount` | Number of followers |
| `authorFollowingCount` | Number following |
| `authorPostsCount` | Total posts published |
| `authorVerified` | Verified account status |
| `authorCreatedAt` | Account creation date |

### How much does it cost to scrape Truth Social?

This Actor uses **pay-per-event** (PPE) pricing — you pay only for what you scrape. No monthly subscription. All platform costs included.

| | Free | Starter ($29/mo) | Scale ($199/mo) | Business ($999/mo) |
|---|---|---|---|---|
| **Per post** | $0.0023 | $0.002 | $0.00156 | $0.0012 |
| **1,000 posts** | $2.30 | $2.00 | $1.56 | $1.20 |
| **10,000 posts** | $23.00 | $20.00 | $15.60 | $12.00 |

Higher-tier plans get additional volume discounts (up to 72% off for enterprise).

**Real-world cost examples:**

| Task | Posts | Duration | Cost (Free tier) |
|------|-------|----------|-----------------|
| Scrape Trump's last 50 posts | 50 | ~15s | ~$0.12 |
| Monitor 5 accounts, 20 posts each | 100 | ~30s | ~$0.23 |
| Daily digest: top 200 posts | 200 | ~60s | ~$0.46 |
| Weekly archive: 500 posts | 500 | ~2min | ~$1.15 |

**Free plan estimate:** With Apify's $5 free monthly credits, you can scrape approximately **2,170 posts per month** at no cost.

### How to scrape Truth Social posts

1. **Open** [Truth Social Scraper](https://apify.com/automation-lab/truth-social-scraper) on Apify Store
2. **Select a mode** — Profile, Trending, or Specific Post
3. **Enter inputs** — usernames (e.g., `realDonaldTrump`) or post URLs
4. **Set max posts** — how many posts to scrape per account
5. **Click "Start"** — results appear in the dataset within seconds
6. **Export data** — download as JSON, CSV, Excel, XML, or RSS

**Input examples:**

Profile mode — scrape posts from specific accounts:
```json
{
    "mode": "profile",
    "usernames": ["realDonaldTrump", "DonaldTrumpJr", "KariLake"],
    "maxPosts": 50,
    "includeReplies": false,
    "includeReblogs": true
}
````

Post mode — fetch specific posts by URL:

```json
{
    "mode": "post",
    "postUrls": [
        "https://truthsocial.com/@realDonaldTrump/posts/116337483523761845",
        "https://truthsocial.com/@realDonaldTrump/posts/116300000000000000"
    ]
}
```

Trending mode — get recent posts from top accounts:

```json
{
    "mode": "trending",
    "maxPosts": 100
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `mode` | string | `profile` | Scraping mode: `profile`, `trending`, or `post` |
| `usernames` | string\[] | `[]` | Truth Social usernames to scrape (without @). Used in profile mode. |
| `postUrls` | string\[] | `[]` | Post URLs to fetch. Used in post mode. |
| `maxPosts` | integer | `50` | Max posts to scrape per user or total. Minimum: 1. |
| `includeReplies` | boolean | `false` | Include reply posts (posts responding to others) |
| `includeReblogs` | boolean | `true` | Include ReTruths (reposted content) |

### Output examples

**Typical post output:**

```json
{
    "id": "116337483523761845",
    "url": "https://truthsocial.com/@realDonaldTrump/116337483523761845",
    "content": "I would like to thank the hardworking Commissioners and Staff...",
    "contentHtml": "<p>I would like to thank the hardworking Commissioners...</p>",
    "createdAt": "2026-04-02T22:32:01.152Z",
    "visibility": "public",
    "language": "en",
    "repliesCount": 1199,
    "reblogsCount": 2593,
    "favouritesCount": 10562,
    "isReblog": false,
    "rebloggedFromUrl": null,
    "inReplyToId": null,
    "mediaAttachments": [
        {
            "id": "123456789",
            "type": "image",
            "url": "https://media.truthsocial.com/media_attachments/...",
            "previewUrl": "https://media.truthsocial.com/preview/...",
            "description": null
        }
    ],
    "hashtags": [],
    "mentions": [],
    "authorId": "107780257626128497",
    "authorUsername": "realDonaldTrump",
    "authorDisplayName": "Donald J. Trump",
    "authorUrl": "https://truthsocial.com/@realDonaldTrump",
    "authorAvatarUrl": "https://media.truthsocial.com/accounts/avatars/...",
    "authorFollowersCount": 12078420,
    "authorFollowingCount": 52,
    "authorPostsCount": 1840,
    "authorVerified": false,
    "authorCreatedAt": "2022-02-11T16:16:57.705Z",
    "scrapedAt": "2026-04-03T00:00:00.000Z"
}
```

### Tips for best results

- **Start small:** Use `maxPosts: 10` for your first run to verify data format before scaling up
- **Multiple accounts:** Add multiple usernames to a single run — the scraper processes them sequentially
- **No replies by default:** Set `includeReplies: false` (default) to focus on original content; set to `true` if you need conversation threads
- **ReTruths:** Keep `includeReblogs: true` (default) for complete posting history; disable to see only original posts
- **Schedule monitoring:** Use Apify's scheduler to run daily and maintain an archive of posts over time
- **Cost control:** For large archives, use `maxPosts: 100` per run and paginate manually using post IDs

### Integrations

**Truth Social Scraper → Google Sheets (political monitoring)**
Export Trump's daily posts to a Google Sheet automatically. Connect via Zapier or Make, filter posts by keyword, and share with your research team.

**Truth Social Scraper → Slack/Discord (news alerts)**
Set up hourly runs and send new posts to a team channel. Use Apify webhooks to trigger on run completion and filter for high-engagement posts.

**Truth Social Scraper → Elasticsearch (full-text search)**
Use Apify's API to push scraped posts into Elasticsearch for full-text search, keyword monitoring, and sentiment analysis across thousands of posts.

**Truth Social Scraper → Power BI / Tableau (analytics dashboard)**
Schedule daily runs and connect Apify datasets to your BI tool via CSV export or REST API for engagement trend visualizations.

**Truth Social Scraper → Custom NLP pipeline**
Use the Actor's API to feed raw post text into sentiment analysis, topic modeling, or entity extraction pipelines for political research.

**Monitoring workflow:** Schedule runs at `0 */6 * * *` (every 6 hours) to capture new posts from monitored accounts and detect posting patterns.

### Using the Apify API

Run this actor programmatically using the Apify API.

**Node.js:**

```javascript
const { ApifyClient } = require('apify-client');

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

const run = await client.actor('automation-lab/truth-social-scraper').call({
    mode: 'profile',
    usernames: ['realDonaldTrump', 'KariLake'],
    maxPosts: 50,
    includeReplies: false,
    includeReblogs: true,
});

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

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

run = client.actor('automation-lab/truth-social-scraper').call(run_input={
    'mode': 'profile',
    'usernames': ['realDonaldTrump', 'KariLake'],
    'maxPosts': 50,
    'includeReplies': False,
    'includeReblogs': True,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(f'Scraped {len(items)} posts')
```

**cURL:**

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~truth-social-scraper/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "profile",
    "usernames": ["realDonaldTrump"],
    "maxPosts": 50
  }'
```

### Use with AI agents via MCP

Truth Social Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com"
        }
    }
}
```

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- "Use automation-lab/truth-social-scraper to fetch the last 50 posts from realDonaldTrump and summarize the main topics"
- "Scrape Trump and Kari Lake's Truth Social posts from this week and compare their posting frequency"
- "Get the 10 most-liked recent posts from realDonaldTrump on Truth Social"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Is it legal to scrape Truth Social?

Truth Social's posts are publicly accessible without login for most profiles, which places them in the same category as other public social media content. Web scraping of publicly available data is generally permissible for research, journalism, and analysis purposes under US law.

**Key guidelines:**

- ✅ **Scrape public posts only** — this tool only accesses content visible to non-logged-in users
- ✅ **Respect rate limits** — the scraper includes built-in delays to avoid overloading servers
- ✅ **Academic and journalistic use** — collecting public statements from public figures is well-established
- ⚠️ **No automated account creation** — do not use this tool to create accounts or engage with the platform
- ⚠️ **GDPR compliance** — if storing data about EU citizens, ensure proper data handling and retention policies
- ⚠️ **Check ToS regularly** — Truth Social's terms of service may evolve

Apify recommends using scraped data responsibly and in compliance with all applicable laws. For detailed guidance, see [Apify's web scraping legality guide](https://apify.com/legal).

### FAQ

**How many posts can I scrape?**
There's no hard limit — the scraper paginates through a user's post history. In practice, most accounts have hundreds to thousands of posts. Set `maxPosts: 0` for unlimited (though very large archives may take several minutes).

**How much does it cost to scrape 1,000 posts?**
On the free tier: $2.30 (at $0.0023/post). On the Starter plan: $2.00. On Scale: $1.56. Your first $5 in free credits covers ~2,170 posts.

**Is this faster than the official Truth Social API?**
Truth Social doesn't offer a public API for third-party developers. This scraper uses the Mastodon-compatible internal API with residential proxies to reliably deliver data.

**Why are some posts returning null for certain fields?**
Some fields like `language` may be null if Truth Social didn't detect or store the value. Media attachments are empty arrays for text-only posts. This is expected behavior.

**Why am I getting 0 results?**
Common causes: (1) The username doesn't exist on Truth Social — double-check spelling. (2) The account may be private or deactivated. (3) Residential proxy connectivity issues — try re-running. Contact support if the issue persists.

**How do I scrape posts from a specific date range?**
Filter results by `createdAt` field after scraping. Alternatively, use `maxPosts` to get recent posts, then check timestamps in the output.

**Can I scrape posts by hashtag?**
Hashtag timeline search requires authentication which is not yet supported. Use profile mode to scrape accounts that commonly use specific hashtags.

**How do I monitor new posts over time?**
Use Apify's scheduler to run the actor every hour or day. Combine with Apify's deduplication — compare `id` fields to identify new posts since the last run.

### Other social media scrapers

Looking for scrapers for other platforms? Check out our full collection:

- 🎵 [TikTok Scraper](https://apify.com/automation-lab/tiktok-scraper) — videos, profiles, trending content
- 🐦 [Twitter Scraper](https://apify.com/automation-lab/twitter-scraper) — tweets, profiles, hashtags
- 📸 [Instagram Scraper](https://apify.com/automation-lab/instagram-scraper) — posts, profiles, hashtags
- 📺 [YouTube Scraper](https://apify.com/automation-lab/youtube-scraper) — videos, channels, comments
- 💬 [TikTok Comments Scraper](https://apify.com/automation-lab/tiktok-comments-scraper) — comments and replies
- 🎬 [TikTok Profile Scraper](https://apify.com/automation-lab/tiktok-profile-scraper) — detailed profile data
- 🔍 [TikTok Search Scraper](https://apify.com/automation-lab/tiktok-search-scraper) — search result videos
- 🎤 [TikTok Sound Scraper](https://apify.com/automation-lab/tiktok-sound-scraper) — sound/audio trending data
- 🏷️ [TikTok Hashtag Scraper](https://apify.com/automation-lab/tiktok-hashtag-scraper) — hashtag videos and metadata

# Actor input Schema

## `mode` (type: `string`):

Select what to scrape: <strong>profile</strong> = posts from specific users, <strong>trending</strong> = recent posts from top Truth Social accounts, <strong>post</strong> = specific posts by URL.

## `usernames` (type: `array`):

Enter Truth Social usernames to scrape (without the @ sign). Used in <strong>profile</strong> mode. Example: <code>realDonaldTrump</code>

## `postUrls` (type: `array`):

Enter specific Truth Social post URLs to fetch. Used in <strong>post</strong> mode. Example: <code>https://truthsocial.com/@realDonaldTrump/posts/123456789</code>

## `maxPosts` (type: `integer`):

Maximum number of posts to extract per user (profile mode) or total posts (trending mode). Minimum: 1.

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

Include posts that are replies to other posts. Disabled by default to focus on original content.

## `includeReblogs` (type: `boolean`):

Include posts re-shared from other users (ReTruths).

## Actor input object example

```json
{
  "mode": "profile",
  "usernames": [
    "realDonaldTrump"
  ],
  "postUrls": [],
  "maxPosts": 10,
  "includeReplies": false,
  "includeReblogs": true
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "profile",
    "usernames": [
        "realDonaldTrump"
    ],
    "postUrls": [],
    "maxPosts": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "mode": "profile",
    "usernames": ["realDonaldTrump"],
    "postUrls": [],
    "maxPosts": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/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 '{
  "mode": "profile",
  "usernames": [
    "realDonaldTrump"
  ],
  "postUrls": [],
  "maxPosts": 10
}' |
apify call automation-lab/truth-social-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Truth Social Scraper",
        "description": "Extract posts and profiles from Truth Social. Scrape Donald Trump and any public profile's posts, get engagement metrics, media, and author data. No API key needed. Export to JSON, CSV, or Excel.",
        "version": "0.1",
        "x-build-id": "ik5tgutJEHeFEfe8E"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~truth-social-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-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/automation-lab~truth-social-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-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/automation-lab~truth-social-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "🎯 Scraping mode",
                        "enum": [
                            "profile",
                            "trending",
                            "post"
                        ],
                        "type": "string",
                        "description": "Select what to scrape: <strong>profile</strong> = posts from specific users, <strong>trending</strong> = recent posts from top Truth Social accounts, <strong>post</strong> = specific posts by URL.",
                        "default": "profile"
                    },
                    "usernames": {
                        "title": "Usernames",
                        "type": "array",
                        "description": "Enter Truth Social usernames to scrape (without the @ sign). Used in <strong>profile</strong> mode. Example: <code>realDonaldTrump</code>",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "postUrls": {
                        "title": "Post URLs",
                        "type": "array",
                        "description": "Enter specific Truth Social post URLs to fetch. Used in <strong>post</strong> mode. Example: <code>https://truthsocial.com/@realDonaldTrump/posts/123456789</code>",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPosts": {
                        "title": "Max posts",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of posts to extract per user (profile mode) or total posts (trending mode). Minimum: 1.",
                        "default": 50
                    },
                    "includeReplies": {
                        "title": "Include reply posts",
                        "type": "boolean",
                        "description": "Include posts that are replies to other posts. Disabled by default to focus on original content.",
                        "default": false
                    },
                    "includeReblogs": {
                        "title": "Include ReTruths (reblogs)",
                        "type": "boolean",
                        "description": "Include posts re-shared from other users (ReTruths).",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```