# Trump Truth Social — Real-Time Monitor 1s (`seocos/trump-truth-social-realtime`) Actor

Monitor Trump's Truth Social in real-time. Each new post is pushed instantly to your dataset with AI market analysis and trading signals (ticker, direction, confidence). Additional functionality: analysis of his texts, long or short, and connecting brokers

- **URL**: https://apify.com/seocos/trump-truth-social-realtime.md
- **Developed by:** [seocos K.](https://apify.com/seocos) (community)
- **Categories:** Social media, News
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

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

## Trump Truth Social — Real-Time Monitor

Monitor **Donald Trump's Truth Social** posts in real time. Every new post is pushed instantly to your Apify Dataset, complete with **AI-powered market analysis** and trading signals — ticker symbols, direction (LONG/SHORT), and confidence score.

Built for traders, quant researchers, and news aggregators who need sub-minute reaction time to presidential posts.

---

> ⚠️ **Disclaimer — Educational & Research Use Only**
>
> This tool is provided **for educational, research, and informational purposes only**. It is not financial advice.
>
> The AI-generated analysis (LONG/SHORT signals, confidence scores, ticker recommendations) reflects a probabilistic interpretation of post content by a language model. **Markets are complex and unpredictable** — real price movements may differ significantly from, or be the complete opposite of, what the model suggests. Political statements often trigger irrational, short-lived, or delayed market reactions that no model can reliably predict.
>
> **Do not make trading or investment decisions based solely on this data.** Always conduct your own research and consult a licensed financial advisor before acting. The authors and operators of this tool accept no liability for any financial losses resulting from its use.

---

### What You Get

Each item pushed to your dataset:

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Unique Truth Social post ID |
| `content` | string | Full post text (HTML stripped) |
| `created_at` | string | Publish timestamp (ISO 8601) |
| `_detectedAt` | string | Detection timestamp — when *our* monitor first saw the post |
| `url` | string | Direct link to the Truth Social post |
| `analysis` | object | AI signal analysis *(see below)* |

#### `analysis` object (when `includeAnalysis = true`)

```json
{
  "relevant": true,
  "signalStrength": 8,
  "signalType": "LONG",
  "tier": 1,
  "analysis": "Post mentions energy sector deregulation — bullish for oil/gas",
  "recommendations": [
    {
      "ticker": "CL/USDT",
      "direction": "LONG",
      "confidence": 0.82,
      "reasoning": "Direct mention of drill expansion policy"
    }
  ]
}
````

**Signal strength**: 0–10 (0 = no signal, 10 = strong move expected)\
**Tier**: 1 = immediate market impact, 4 = background noise\
**Tickers**: crypto pairs (BTC/USDT, ETH/USDT), commodities (CL/USDT, GC/USDT, NATGAS/USDT), equities (QQQ/USDT)

### Configuration

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `pollIntervalSeconds` | integer | `5` | How often to check for new posts (1–3600 sec) |
| `durationMinutes` | integer | `30` | How long to run (1–60 min) |
| `includeAnalysis` | boolean | `true` | Include AI trading signal analysis |

> **Note**: The API key is managed by the actor owner — you don't need to configure it.

### How It Works

1. Actor starts and takes a **baseline snapshot** of the latest posts (marks them as already seen — no duplicates)
2. Every `pollIntervalSeconds`, it checks for new posts
3. Any post not seen before is **pushed immediately** to your Apify Dataset
4. When `durationMinutes` expires, the actor exits cleanly

### Use Cases

- **Algorithmic trading** — react to Trump posts before prices move
- **News aggregation** — collect and archive every presidential post in real time
- **Research & analytics** — build datasets of Trump social media activity with timestamps
- **Alert systems** — trigger webhooks on Actor finish to notify your team

### Output Example

```json
{
  "id": "113456789012345678",
  "content": "GREAT NEWS for American energy! We will drill, baby, drill! OIL IS BACK!!!",
  "created_at": "2025-01-15T14:32:00.000Z",
  "_detectedAt": "2025-01-15T14:32:04.812Z",
  "url": "https://truthsocial.com/@realDonaldTrump/posts/113456789012345678",
  "analysis": {
    "relevant": true,
    "signalStrength": 9,
    "signalType": "LONG",
    "tier": 1,
    "analysis": "Direct bullish statement on oil production. Energy sector strongly impacted.",
    "recommendations": [
      {
        "ticker": "CL/USDT",
        "direction": "LONG",
        "confidence": 0.91,
        "reasoning": "Explicit pro-drilling statement from the sitting president"
      },
      {
        "ticker": "NATGAS/USDT",
        "direction": "LONG",
        "confidence": 0.74,
        "reasoning": "Energy sector expansion typically positive for natural gas"
      }
    ]
  }
}
```

### Tips

- Set `pollIntervalSeconds: 2` for maximum speed (catches posts within ~2 seconds of publishing)
- Set `durationMinutes: 60` + use **scheduled runs** to maintain continuous coverage
- Set `includeAnalysis: false` if you only need raw post data (faster, no AI processing)
- Use the Apify **webhook** feature to get notified immediately when new posts are found

### Latency

Detection latency is typically **2–10 seconds** from Trump's publish time to your dataset. This is sourced from a 24/7 live monitor, not on-demand scraping.

# Actor input Schema

## `pollIntervalSeconds` (type: `integer`):

How often to check for new posts. Lower = faster detection. Minimum: 1 second.

## `durationMinutes` (type: `integer`):

How long to run the monitor. Maximum: 60 minutes.

## `includeAnalysis` (type: `boolean`):

Attach AI market signal analysis to each post: signal strength, ticker recommendations, direction (LONG/SHORT), and confidence level.

## Actor input object example

```json
{
  "pollIntervalSeconds": 5,
  "durationMinutes": 30,
  "includeAnalysis": true
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("seocos/trump-truth-social-realtime").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("seocos/trump-truth-social-realtime").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 '{}' |
apify call seocos/trump-truth-social-realtime --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trump Truth Social — Real-Time Monitor 1s",
        "description": "Monitor Trump's Truth Social in real-time. Each new post is pushed instantly to your dataset with AI market analysis and trading signals (ticker, direction, confidence). Additional functionality: analysis of his texts, long or short, and connecting brokers",
        "version": "1.0",
        "x-build-id": "9ltDw9DCH7fpzWucH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/seocos~trump-truth-social-realtime/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-seocos-trump-truth-social-realtime",
                "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/seocos~trump-truth-social-realtime/runs": {
            "post": {
                "operationId": "runs-sync-seocos-trump-truth-social-realtime",
                "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/seocos~trump-truth-social-realtime/run-sync": {
            "post": {
                "operationId": "run-sync-seocos-trump-truth-social-realtime",
                "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": {
                    "pollIntervalSeconds": {
                        "title": "Poll Interval (seconds)",
                        "minimum": 1,
                        "maximum": 3600,
                        "type": "integer",
                        "description": "How often to check for new posts. Lower = faster detection. Minimum: 1 second.",
                        "default": 5
                    },
                    "durationMinutes": {
                        "title": "Duration (minutes)",
                        "minimum": 1,
                        "maximum": 60,
                        "type": "integer",
                        "description": "How long to run the monitor. Maximum: 60 minutes.",
                        "default": 30
                    },
                    "includeAnalysis": {
                        "title": "Include AI Trading Analysis",
                        "type": "boolean",
                        "description": "Attach AI market signal analysis to each post: signal strength, ticker recommendations, direction (LONG/SHORT), and confidence level.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
