Pricing

from $4.99 / 1,000 results

Truth Social Scraper By Keyword Search

📰 Truth Social Scraper collects public profiles, posts, comments & hashtags from Truth Social—complete with timestamps, links & engagement metrics. 📊 Export CSV/JSON for analytics, monitoring & lead gen. ⚡ Perfect for research, newsrooms, brand tracking & sentiment.

Pricing

from $4.99 / 1,000 results

Rating

0.0

(0)

Developer

API Empire

Actor stats

Bookmarked

Total users

Monthly active users

2 days ago

Last modified

Data Type	Key Fields	JSON Field Names
Posts	ID, timestamp, body text, permalink, reply flag	`id`, `created_at`, `content`, `url`, `in_reply_to_id`
Author / profile data (embedded per post)	Handle, display name	`account.acct`, `account.username`
Media attachments	Attached photos / video, one array per post	`media_attachments`
Re-truths & quotes	Full nested post object when the row is a repost or quote-post	`reblog`, `quote`
Keyword match data (added by this Actor)	Which terms hit, how many times, a text snippet, new-since-last-run flag	`matchedKeywords`, `matchCount`, `keywordSnippet`, `isNewMatch`

For AI engineers and agent builders

Feed matchedKeywords, keywordSnippet, and content straight into a RAG index or an agent's tool-call response — every field arrives typed and already plain-text (when cleanContent is on), so there's no HTML stripping step before the text hits an embedding model. A monitoring agent can poll a run on a schedule, read isNewMatch to skip posts it has already indexed, and only embed genuinely new hits, keeping the vector store from re-ingesting the same post twice.

For journalists and media-monitoring teams

Track when a public figure's profile posts specific terms — a policy name, a company, an opponent's name — without manually refreshing a timeline. keywordSnippet gives enough context to triage a hit before opening the full post, and matchCount + matchedKeywords let you sort by how strongly a post matches your watchlist across a batch of saved rows.

For researchers and analysts

Academic and political-communication researchers can pull a bounded, keyword-scoped sample of public posts from named accounts for discourse analysis, without needing platform credentials or hitting private data — every field returned comes from Truth Social's public API surface, the same one the website itself renders from.

For developers building data products

Because output is a stable, typed JSON row per post, you can schedule this Actor and pipe its dataset into a warehouse, a Slack alert, or a dashboard without writing a parser. The isNewMatch flag (see How many posts can you scrape) is designed specifically so a downstream pipeline can filter to genuinely new rows instead of re-processing a full re-fetch every run.

Open Truth Social Scraper By Keyword Search on its Apify Store listing and click Try for free (or Start, if you already have it saved to your account).
Add one or more handles under truthSocialUsername (the @ is optional — the Actor strips it), or switch to Advanced and add post IDs/URLs under fetchSinglePostByIdOrUrl to fetch specific posts instead of a whole feed.
Add your terms under keywords, choose keywordMatchMode (any or all), and set caseSensitive, onlyFetchReplies, and onlyFetchPostsWithMedia to narrow what gets kept. Leave keywords empty to keep every post.
Set maxPosts (5–5000) and click Start. Enabling Apify Proxy under proxyConfiguration (RESIDENTIAL is prefilled) is strongly recommended — Truth Social sits behind Cloudflare.
Open the Dataset tab once the run finishes and export as JSON, CSV, Excel, or one of Apify's other formats — or pull it programmatically (see Integrate).

The Actor is actively maintained against Truth Social's Mastodon-compatible API and Cloudflare configuration, and the output schema is kept stable so downstream integrations don't need to change when the underlying site does. No specific fix turnaround is published or guaranteed.

⬇️ Input

All fields are optional — there are no required parameters in the input schema. Leaving everything at default scrapes 40 recent posts from realDonaldTrump with no keyword filtering.

Parameter	Type	Default	Constraints
`truthSocialUsername`	array (stringList)	(none — falls back to `realDonaldTrump` if empty)	One handle per line; `@` optional
`keywords`	array (stringList)	(none — empty = keep every post)	One term/phrase per line; phrases match as substrings
`keywordMatchMode`	string (select)	`"any"`	Enum: `"any"` (OR), `"all"` (AND)
`caseSensitive`	boolean	`false`	—
`maxPosts`	integer	`40`	`minimum: 5`, `maximum: 5000`
`continueFromLastPostId`	boolean	`false`	—
`onlyFetchReplies`	boolean	`false`	—
`onlyFetchPostsWithMedia`	boolean	`false`	—
`cleanContent`	boolean	`true`	Matching always uses plain text regardless of this setting
`startFromPostId`	string (textfield)	(none)	Must be exactly 18 digits; do not combine with `continueFromLastPostId`
`fetchSinglePostByIdOrUrl`	array (stringList)	(none)	Post IDs or full Truth Social post URLs, one per line; when set, profile-feed mode is skipped entirely
`proxyConfiguration`	object (proxy editor)	`{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}`	Standard Apify Proxy configuration object

Field notes, read from the source:

truthSocialUsername — every non-empty handle in the list is scraped, one profile after another, in a single run. maxPosts applies per profile, not to the run as a whole: three usernames with maxPosts: 100 can produce up to 300 saved rows before keyword filtering, not 100.
keywords — empty list = base-scraper behaviour (every post kept, matchedKeywords empty, matchCount 0). Multi-word phrases are matched as plain substrings, not tokenized/fuzzy.
maxPosts — counts posts that already passed the onlyFetchReplies / onlyFetchPostsWithMedia filters during pagination, not raw posts pulled from the feed. The Actor keeps requesting more pages from Truth Social until it has collected this many qualifying posts (or the profile's feed runs out). Keyword filtering happens after this cap is reached — a narrow watchlist can still return zero saved rows even after scanning the full maxPosts allowance. Not used when fetchSinglePostByIdOrUrl has entries.
startFromPostId — loads posts strictly older than this ID; the Actor rejects anything that isn't exactly 18 digits, and rejects combining it with continueFromLastPostId (they express contradictory starting points).
fetchSinglePostByIdOrUrl — when this has entries, profile-feed mode (and maxPosts) is skipped completely; only the listed posts are fetched and checked against your keywords.
proxyConfiguration — Truth Social sits behind Cloudflare. The Actor tries a direct connection and Apify's auto-proxy first, but defaults to residential proxy on repeated blocks; leaving the RESIDENTIAL group enabled (as prefilled) gives it the best chance of completing a run without escalating through failed tiers first.

Common pitfall: setting continueFromLastPostId to true expecting it to behave like isNewMatch — they track state differently (see How many posts can you scrape); if you only care about "what's new since last time," filter the output on isNewMatch: true instead of relying on continueFromLastPostId alone.

Legacy field names: the Actor also still accepts an older set of field names for backward compatibility with earlier input configurations — urls, singlePostId, useLastPostId, startFromId, onlyReplies, onlyMedia, and username. These aren't part of the current input schema shown above (so they won't appear as form fields in the Apify Console) and aren't documented further here; if your saved input still uses them, they continue to map onto the same behavior as their current equivalents (fetchSinglePostByIdOrUrl, continueFromLastPostId, startFromPostId, onlyFetchReplies, onlyFetchPostsWithMedia, truthSocialUsername). New integrations should use the current names in the table above.

Example input

{
  "truthSocialUsername": ["realDonaldTrump"],
  "keywords": ["America", "great", "win"],
  "keywordMatchMode": "any",
  "caseSensitive": false,
  "maxPosts": 100,
  "continueFromLastPostId": false,
  "onlyFetchReplies": false,
  "onlyFetchPostsWithMedia": false,
  "cleanContent": true,
  "startFromPostId": "",
  "fetchSinglePostByIdOrUrl": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}

⬆️ Output

Each row lands in the run's default dataset as soon as it's matched — rows stream in during the run rather than appearing all at once at the end. Every row is Truth Social's full Mastodon-compatible status object, unmodified except for optional HTML-to-plain-text cleaning of content (cleanContent), plus four fields the Actor computes: matchedKeywords, matchCount, keywordSnippet, and isNewMatch. Export as JSON, CSV, Excel, XML, RSS, or HTML table directly from the Apify dataset tab, or pull it via the API or Python/JS clients.

Scraped post

{
  "id": "113987654321098765",
  "created_at": "2026-07-24T18:32:00.000Z",
  "content": "America is doing GREAT again — big win for everyone who believed!",
  "url": "https://truthsocial.com/@realDonaldTrump/113987654321098765",
  "in_reply_to_id": null,
  "account": {
    "id": "107780257626128497",
    "username": "realDonaldTrump",
    "acct": "realDonaldTrump",
    "display_name": "Donald J. Trump"
  },
  "media_attachments": [
    {
      "id": "113987654300000001",
      "type": "image",
      "url": "https://static-assets-1.truthsocial.com/media/example.jpg"
    }
  ],
  "reblog": null,
  "quote": null,
  "matchedKeywords": ["America", "great", "win"],
  "matchCount": 3,
  "keywordSnippet": "America is doing GREAT again — big win for everyone who believed!",
  "isNewMatch": true
}

Fields confirmed in the scraping code (src/main.py): id, created_at, content (cleaned to plain text when cleanContent is on — HTML entities decoded, tags stripped), url, in_reply_to_id (drives the onlyFetchReplies filter), account with its nested acct / username (used to scope keyword-match tracking per author), media_attachments (checked as a non-empty array for onlyFetchPostsWithMedia), and reblog / quote (nested, full post objects in the same shape, present when the row is a repost or quote-post — the Actor reads their content too when matching keywords, and cleans them recursively when cleanContent is on). Because the Actor calls Truth Social's Mastodon-compatible endpoints directly and passes the response through unmodified, every other field Mastodon's public Status entity defines (favourites_count, reblogs_count, replies_count, visibility, language, sensitive, spoiler_text, card, poll, emojis, application, and so on) also comes through on each row exactly as Truth Social's API returns it — the Actor does not filter, rename, or drop any of them.

Fields added by this Actor:

Field	Type	Meaning
`matchedKeywords`	array of strings	The distinct watchlist terms found in this post (own text plus any reblog/quote text). Empty when `keywords` is empty.
`matchCount`	integer	Total number of keyword occurrences across the post's text, summed across all matched terms. `0` when `keywords` is empty.
`keywordSnippet`	string or `null`	~160 characters of plain text centred on the first keyword match, with `…` markers when the window is truncated. `null` when there is no match (base mode) or no matched position.
`isNewMatch`	boolean or `null`	`true` — this post ID wasn't in the previous saved snapshot for this profile + keyword-watchlist combination (a new hit). `false` — already seen on an earlier run with the same watchlist. `null` — first-ever run for this profile + watchlist (no baseline to compare against yet).

The dataset's default table view only surfaces ten of these keys (id, created_at, content, matchedKeywords, matchCount, keywordSnippet, isNewMatch, url, account, media_attachments) for readability — every field above is still present in the underlying JSON row; switch to the Overview/raw JSON view or export the dataset to see the rest.

Feature	Truth Social Scraper By Keyword Search	Generic alternative
Output format	Typed JSON, full status object + keyword fields	Often raw HTML or partial JSON requiring a parser
Keyword logic	`any`/`all` match modes, case sensitivity toggle, phrase substrings	Frequently single-keyword only, no AND/OR choice
Cross-run dedup	`isNewMatch` flag backed by a persistent named key-value store, tracked per profile + watchlist	Usually none — every run re-returns everything
Single-post fetch	`fetchSinglePostByIdOrUrl` bypasses feed scraping entirely for targeted lookups	Usually feed-only
Anti-bot handling	Direct → auto-proxy → residential escalation with TLS impersonation and automatic IP rotation	Varies widely; many require you to supply your own proxy pool

For comparison, Threads Search & Monitor's Apify listing advertises a "dedup-aware monitor mode" backed by a named key-value store as its differentiator among Threads scrapers, and Reddit Search Scraper's listing advertises pay-per-result pricing with no API key required — both checked on the Apify Store 2026-07-25, not measured here. This Actor's isNewMatch mechanism is architecturally the same idea (a persisted, per-scope snapshot of previously matched post IDs) applied to Truth Social specifically.

If you're building an AI agent or RAG pipeline, the output-format row is the decision-maker — parsing HTML inside an agent loop is a reliability failure mode, not a feature.

⚠️ How many posts can you scrape with this Actor?

maxPosts caps how many qualifying posts (after the reply/media filters, before keyword filtering) the Actor collects per profile, and the input schema bounds it between 5 and 5000. There is no additional hard cap enforced in the scraping code itself beyond that schema range — the code only re-enforces the floor of 5 internally; the ceiling of 5000 is enforced by Apify's input validation before the run starts.

Pagination works by requesting Truth Social's timeline API in pages of up to 40 posts at a time, waiting roughly 4.5 seconds (plus a small random jitter) between pages to avoid triggering Cloudflare, and continuing until either maxPosts qualifying posts have been collected or the profile's feed is exhausted. With multiple profiles in truthSocialUsername, this budget applies separately to each one and profiles are processed one after another, not in parallel — so total posts scanned (and dataset rows saved, before keyword filtering) can be a multiple of maxPosts.

fetchSinglePostByIdOrUrl bypasses this entirely: it fetches exactly the posts you list, one HTTP call per ID/URL, with no maxPosts limit applying.

On dedup across runs: the Actor maintains two separate cross-run mechanisms, and they are not equally durable. The isNewMatch field is backed by a named Apify key-value store (truth-social-keyword-monitor-state), which Apify persists across separate runs by design — it reliably tells you which matched posts are new versus already seen, scoped per profile and per exact keyword/mode/case-sensitivity combination, capped at the 5,000 most recent post IDs per scope. The continueFromLastPostId bookmark, by contrast, is stored in the run's default key-value store — and Apify creates a fresh default key-value store for every run. If you're setting up a scheduled watchlist, treat isNewMatch: true as the reliable "what's new" signal, and don't assume continueFromLastPostId alone prevents re-scraping already-seen posts on a schedule — verify the behavior in your own account before depending on it for a production monitor. No benchmark run time is published for this Actor.

Truth Social Scraper By Keyword Search works with any language or tool that can call the Apify API — there's no bespoke SDK requirement.

REST API integration

from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")

run_input = {
    "truthSocialUsername": ["realDonaldTrump"],
    "keywords": ["America", "great", "win"],
    "keywordMatchMode": "any",
    "maxPosts": 100,
}

run = client.actor("<YOUR_USERNAME>/truth-social-keyword-monitor").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["id"], item.get("matchedKeywords"), item.get("keywordSnippet"))

Works in Python, Node.js, Go, Ruby, cURL — anything that can authenticate to the Apify API with your account token and read a dataset back.

Automation platforms (n8n, Make, LangChain)

n8n — use the official Apify node (or an HTTP Request node against the Apify API) to start a run with your input JSON and read the resulting dataset items into the rest of your workflow.
Make — Apify's Make app exposes "Run an Actor" and "Get dataset items" modules; wire the Actor's output straight into a Slack, Sheets, or CRM module for alerting on new keyword matches.
LangChain — load a finished dataset with LangChain's ApifyDatasetLoader, mapping each row's content (or keywordSnippet) into document text for retrieval or summarization chains.

Scheduling a recurring watchlist

There is no scheduling logic inside the Actor itself — recurring "monitor" behavior is Apify's Scheduler feature, external to this Actor. Create a Schedule on the Actor (e.g., hourly or daily) with your saved input, and use isNewMatch: true on each run's output to isolate genuinely new hits, since (as noted above) that flag is the durable cross-run signal, not continueFromLastPostId. You can also attach an Apify webhook to the run's ACTOR.RUN.SUCCEEDED event to push a notification (or trigger a downstream automation) the moment a scheduled run finishes, instead of polling the dataset yourself.

Yes, when limited to publicly accessible posts and profiles. Truth Social Scraper By Keyword Search only reads data Truth Social's own public, unauthenticated API already serves — it does not log in, bypass a paywall, or access private/suspended accounts. Because post authors, handles, and display names are personal data under data-protection law, GDPR and CCPA principles apply to how you store and use anything you collect, particularly at scale or for anything beyond ad-hoc research: you need a lawful basis for processing, and you're responsible for how long you retain it and who you share it with. Truth Social's own Terms of Service govern automated access to the platform independent of data-protection law. Consult legal counsel for commercial use cases involving bulk personal data.

❓ Frequently asked questions

Yes. No Truth Social login, account, or API key is used anywhere in the Actor — it reads the same public API endpoints Truth Social's own website calls. The only credential involved is your own Apify account for running the Actor and, optionally, Apify Proxy (no separate sign-up required — it's built into the proxyConfiguration input).

How often is the scraped data updated?

Every run performs a live fetch against Truth Social's API at the moment it executes — nothing is cached or served from a previous run's snapshot. Re-run the Actor (manually or on an Apify Schedule) whenever you want fresh data; there is no automatic background refresh between runs.

What happens if a post has been deleted, or a profile handle doesn't exist?

These two failure modes behave differently, by design of the underlying code. Fetching a specific deleted/removed post via fetchSinglePostByIdOrUrl is handled gracefully — Truth Social returns HTTP 404, the Actor logs it as skipped, and the run continues with the remaining IDs. An invalid or nonexistent profile handle, however, fails the account lookup step and is not caught the same way — it raises an error that stops the whole run. If you're scraping multiple profiles in one run, double-check each handle first; one bad handle currently aborts the batch rather than skipping just that profile.

No. Only publicly accessible profiles and posts are returned — the Actor has no login step and cannot see anything a logged-out visitor to truthsocial.com couldn't also see.

Yes. Add one or more post IDs or full post URLs to fetchSinglePostByIdOrUrl under Advanced — when that list has entries, profile-feed mode (and maxPosts) is skipped entirely, and only those specific posts are fetched and checked against your keyword watchlist.

Yes — it's callable as a standard HTTP/API operation by any agent framework that can start an Apify Actor run and read back a dataset (see Integrate). Every response is typed JSON with stable field names, so there's no HTML-parsing step between the Actor's output and an LLM context window or vector store.

How does this handle Truth Social's Cloudflare protection?

The Actor starts with residential-proxy requests by default (the fastest path to avoiding a block in practice for this site), using a Chrome-131 TLS fingerprint via impit for direct calls and curl-cffi/httpx for proxied calls, and rotates to a fresh residential exit IP after a 401/403/429 or a Cloudflare interstitial. If residential proxy isn't available (no proxyConfiguration set), it falls back through a direct connection and Apify's auto-proxy tier first. See Why not build this yourself? for the retry ceiling.

Yes — this is the Actor's core use case. Attach an Apify Schedule to re-run the same profile(s) and watchlist on a cadence, and filter each run's dataset on isNewMatch: true to isolate posts you haven't seen before. That flag is backed by a persistent named key-value store scoped to the exact profile + keyword-set + match-mode + case-sensitivity combination, so switching your watchlist starts a fresh baseline rather than mislabeling old posts as new.

Reddit Search Scraper's Apify listing advertises pay-per-result pricing from roughly $1.50 per 1,000 results with no Reddit API key required, and Threads Search & Monitor's listing advertises a dedicated "Monitor" mode with a dedup-aware, named-store-backed new-post flag — both checked on the Apify Store 2026-07-25, not measured here. This Actor targets a platform neither of those covers (Truth Social) and applies the same category of idea — persistent, scoped dedup tracking — to isNewMatch, alongside an any/all phrase-matching watchlist and a direct single-post fetch mode.

Yes. Every row is typed, normalized JSON with stable field names — no HTML, no CSS selectors, no scraping artifacts to clean up before passing it to an LLM context window, indexing it into a vector store, or routing it through an agent tool call.

Yes. Enable Apify Proxy under proxyConfiguration (the RESIDENTIAL group is prefilled by default) and the Actor handles connection tiering, retries, and IP rotation internally — there's no separate proxy account or pool to provision.

The Actor is maintained against Truth Social's current API and Cloudflare configuration, and the output schema (field names and types) is kept stable so downstream integrations don't break when the underlying site changes. No specific turnaround time is published or guaranteed for fixes.

Why did my run save zero rows even though the profile clearly posted about my keyword?

Two independent gates run before a post is saved, and either one can produce zero rows. First, maxPosts bounds how many reply/media-filtered posts are pulled from the feed in that run — if your keyword only appears further back in the profile's history than maxPosts reaches, increase it or use startFromPostId to page deeper. Second, keywordMatchMode: "all" requires every term in keywords to appear in the same post; a broad watchlist with "all" set is much stricter than it looks. Switch to "any" first to confirm matches exist, then tighten to "all" once you've verified the watchlist.

Can I combine keyword filtering with fetching a single post by ID?

Yes. fetchSinglePostByIdOrUrl and keywords are independent — when you fetch specific posts, each one is still checked against your watchlist and gets matchedKeywords, matchCount, keywordSnippet, and isNewMatch computed the same way a profile-feed post would. Leave keywords empty if you just want the raw post(s) back with no filtering.

💬 Your feedback

Found a bug, an inconsistency, or a field you need that isn't in the output? We want to know. Open an issue from the Actor's page on the Apify Store (Issues tab) or reach out through your Apify Console — reports like these are how the keyword-matching logic and Cloudflare handling stay current as Truth Social's site changes.

Truth Social Scraper

simpleapi/truth-social-scraper

📰 Truth Social Scraper extracts posts, profiles, timelines, hashtags, mentions & engagement metrics from Truth Social. ⚙️ Clean, structured data with pagination and CSV/JSON export. 🚀 Ideal for social listening, brand monitoring, research & competitive analysis.