# X (Twitter) Public Intel - Profiles, Posts, Engagement Velocity (`seibs.co/x-twitter-intel`) Actor Profile intel, post records, and engagement-velocity signals from X's public logged-out surfaces. No login, no cookies, no API keys. Built for brand monitoring, competitor watch, and agent pipelines - with watchlist monitor mode. Recent posts per profile (about 20), not a firehose. - **URL**: https://apify.com/seibs.co/x-twitter-intel.md - **Developed by:** [Seibs.co](https://apify.com/seibs.co) (community) - **Categories:** Social media, Marketing, AI - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $8.00 / 1,000 profile records This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## X (Twitter) Public Intel > **TL;DR for brand, competitor-watch, and AI-agent teams:** A logged-out, public-data intelligence actor for X (Twitter). Give it handles, get back a clean profile snapshot (followers, following, post count, verified, bio, created date), the profile's recent posts as normalized records, and an **engagement-velocity signal** per profile - average engagement, engagement-per-follower, posting cadence, newest-post velocity, and a **momentum flag** when a post is taking off. Plus a **brand_monitor** mode for Apify Schedules that emits new-post and follower-delta digests. No login, no cookies, no API key. **Honest cap: roughly the 20 most recent posts per profile** that X's public syndication surface exposes - this is an intel tool, not a firehose. The official X API runs pay-per-use up to $42k+/mo enterprise; this reads the same public surface anonymous visitors already see. ### Run it in 30 seconds ```python ## Via the Apify Python SDK from apify_client import ApifyClient client = ApifyClient("") run = client.actor("seibs.co/x-twitter-intel").call(run_input={ "mode": "profile_intel", "handles": ["nasa", "openai"] }) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) ```` Or via curl: ```bash curl -X POST "https://api.apify.com/v2/acts/seibs.co~x-twitter-intel/run-sync-get-dataset-items?token=" \ -H "Content-Type: application/json" \ -d '{"mode": "profile_intel", "handles": ["nasa", "openai"]}' ``` Or click "Try for free" on this page if you prefer the no-code UI. ### What you get Each run produces: - A clean dataset, filterable in the Apify console and downloadable as CSV or JSON - Four dataset views: `overview` (AI-agent skim), `signals` (one row per profile), `posts` (every post field), and `profiles` - A sample-output preview at [`.actor/sample-output.json`](./.actor/sample-output.json) Three record types: - `profile_record` - handle, display name, bio, followers, following, post count, verified flags, account-created date, profile URL - `post_record` - text, author, timestamp, like/retweet/reply/quote counts (where the public surface exposes them), media/link flags, hashtags, mentions, reply/quote/retweet flags, conversation id - `engagement_velocity_signal` - the intel layer, one per profile (see below) ### Live example output Real, unmodified output from runs against live public profiles (no login required to view): - **Profile intel showcase** (`profile_intel` over a few well-known public handles): a `profile_record` + recent `post_record`s + one `engagement_velocity_signal` per handle, with momentum flags where a recent post is outrunning the account's median pace. - **Posts lookup** (`posts_lookup` over a list of tweet ids / status URLs): one `post_record` each, resolved from the public per-post surface. To reproduce: run `profile_intel` with `handles=["nasa","openai"]`, or `posts_lookup` with a couple of status URLs. If a profile fetch returns a `fetch_error` that mentions rate limiting, switch `apify_proxy_groups` to `["RESIDENTIAL"]` (see Responsible use, below). ### What does X Public Intel do? It reads X's public, logged-out **syndication** surfaces - the same data X serves to anonymous visitors through its embeddable timeline and tweet widgets - and layers an intelligence engine on top. - For a **handle**, it fetches the public profile-timeline surface, extracts the profile fields and the ~20 recent posts the surface renders, normalizes each post, and computes one engagement-velocity signal. - For a **tweet id or status URL**, it fetches the public per-post surface and normalizes it (with an oEmbed fallback if that surface returns nothing). - In **brand\_monitor** mode under an Apify Schedule, it compares against a stored baseline and emits only the change - new posts and follower deltas - as a digest. It does this without logging in, without cookies, and without the paid X API. ### Responsible use / data scope **This is the most important section on this actor. Read it.** This actor is a **public-data tool**, and that is a deliberate design and legal posture, not an afterthought: - **Logged-out, public data only.** It reads only X's public, logged-out syndication surfaces - the same data X serves to an anonymous visitor through its embeddable widgets. It does **not** log in, does **not** use or accept cookies or session tokens, and does **not** use the paid X API. Because it never creates an account, it never accepts X's terms of service (the legally relevant distinction: courts have held that terms do not bar logged-off scraping of public data). - **No login, no paywall bypass.** There is no credential field, anywhere. Protected (private) accounts are not publicly readable, so they are out of scope. DMs, follower/following lists, and any non-public surface are out of scope. - **Respects the public surface limits.** X's public logged-out surface renders roughly the **20 most recent posts** per profile, and there is no public "load more" without a login. This actor caps at that and says so plainly. It does not pretend to firehose, and it cannot keyword-search (logged-out search is not publicly exposed - track handles instead). - **PII minimized.** Records carry only what X already shows publicly on the logged-out widget: handle, display name, public bio, public follower/following/post counts. We do not enrich into private contact data, and we do not collect anything the public widget does not already render. - **Proportionate-visitor behavior.** Real-browser TLS fingerprint, low concurrency (default 2), jittered delays, and backoff - so the actor behaves like a normal visitor, both as a courtesy and as a legal mitigation. - **You are responsible for lawful use of the outputs.** Public does not mean unregulated: GDPR (EU) and CCPA (CA) apply to personal data even when it is public. Use the outputs lawfully for your jurisdiction and purpose. - **Not affiliated.** This actor is not affiliated with, endorsed by, or sponsored by X Corp. "X" and "Twitter" are trademarks of their owner and are used here only to describe what the actor reads. ### AI / RAG / Agent A turn-key social-intel feed for AI agents, brand-monitoring copilots, and research bots. Records arrive pre-normalized - `engagement_velocity_signal` exposes `avg_engagement`, `engagement_per_follower_permille`, `posts_per_week`, and `momentum_flag` so an agent can ask "which of my competitors posted something that is taking off right now?" without parsing raw HTML. The `overview` dataset view is a narrow, token-efficient slice; an MCP-compatible link returns the first 50 records as a clean JSON array. Compatible with **LangChain**, **LlamaIndex**, **Pinecone**, **Weaviate**, **Chroma**, and any **MCP**-aware agent runtime (see the sibling `mcp-x-twitter-intel` actor for direct tool-call wiring with agentic payments). ### Features - **Profile intel** - one clean snapshot per handle: followers, following, post count, verified flags, bio, account-created date, profile URL. - **Recent-post records** - up to ~20 recent posts per profile, normalized: text, timestamp, full per-post engagement counts (likes, retweets, replies, quotes), media/link flags, hashtags, mentions, reply/quote/retweet flags, conversation id. - **Engagement-velocity engine** - the intel layer: average engagement, engagement-per-follower (per 1,000), posts-per-week cadence, hours since the last post, newest-post likes-per-hour, and a `momentum_flag` when the newest post outruns the profile's median pace by 2x. - **Posts lookup** - resolve a list of tweet ids or status URLs to post records, with an oEmbed fallback for posts the primary surface cannot return. - **Brand monitor + Schedules** - run a watchlist on a cron; monitor mode emits only the delta (new posts + follower changes) with an optional Slack digest. - **Block-aware** - if X rate-limits a datacenter IP, the actor backs off, rotates its session, and (if still blocked) emits a `fetch_error` that tells you to switch to residential proxies - never a crashed run. - **Cost-control** - per-run budget guard + demo-mode soft-fail so runs finish SUCCEEDED. ### Use cases - **Brand monitoring** - track your own accounts' follower trajectory, posting cadence, and which posts are taking off (momentum flag). - **Competitor watch** - the same metrics across a list of competitor handles; compare engagement-per-follower, not just raw follower counts. - **Campaign / launch tracking** - point posts\_lookup at a set of campaign status URLs and pull engagement into your own dashboard. - **AI agent grounding** - a clean, pre-normalized profile + post feed an agent can reason over via the MCP-friendly views. - **Alt-data / research** - account growth and engagement signals over time via scheduled monitor runs. ### Modes | Mode | What it returns | |---|---| | `profile_intel` | Per handle: a `profile_record`, a `post_record` per recent post (up to ~20), and one `engagement_velocity_signal`. | | `posts_lookup` | Per tweet id / status URL: one `post_record`. Partial metrics on this surface (likes + replies; retweet/quote counts are not exposed per-post). | | `brand_monitor` | `profile_intel` over a watchlist, built for Apify Schedules. Under a schedule it emits the new-posts + follower-delta digest. | ### Input See [`.actor/input_schema.json`](./.actor/input_schema.json) for the full form. Key fields: ```json { "mode": "profile_intel", "handles": ["nasa", "openai"], "max_posts_per_profile": 20, "include_replies": false, "use_apify_proxy": true, "apify_proxy_groups": ["DATACENTER"] } ``` For posts\_lookup: ```json { "mode": "posts_lookup", "post_inputs": ["20", "https://x.com/nasa/status/1234567890123456789"] } ``` No API key or login is required - these are public syndication surfaces. Handles work with or without a leading `@`. ### Output One `engagement_velocity_signal` per profile (the headline), then one `profile_record` and the `post_record`s for each handle. ```json { "record_type": "engagement_velocity_signal", "handle": "skylinebrew", "followers_count": 48230, "posts_analyzed": 20, "avg_engagement": 380.0, "engagement_per_follower_permille": 7.8789, "posts_per_week": 11.29, "hours_since_last_post": 5.2, "newest_post_likes_per_hour": 173.08, "momentum_ratio": 2.41, "momentum_flag": true, "follower_delta": 412, "new_post_count": 3 } ``` ```json { "record_type": "post_record", "tweet_id": "1799001234567890123", "author_handle": "skylinebrew", "text": "New drop: Ethiopia Guji, washed. Blueberry, jasmine, a long syrupy finish.", "created_at": "2026-06-12T08:51:00.000Z", "like_count": 900, "retweet_count": 118, "reply_count": 82, "quote_count": 24, "is_reply": false, "has_media": true, "hashtags": ["coffee", "singleorigin"], "status_url": "https://x.com/skylinebrew/status/1799001234567890123", "metrics_source": "profile_timeline" } ``` Failed fetches still emit a `fetch_error` record with a `reason` (and, on a block, guidance to switch to residential proxies) for a complete audit. ### Pricing Pay-per-event: | Event | Price | When charged | |---|---|---| | `profile_record` | $0.008 | Per public profile snapshot returned. | | `post_record` | $0.003 | Per post returned (profile\_intel posts, posts\_lookup results). | | `engagement_velocity_signal` | $0.010 | Once per profile - the intel-layer rollup. | | `scheduled_delta_run` | $0.050 | Once per scheduled brand\_monitor run (the delta digest). | A run that returns nothing costs nothing. A typical 2-handle `profile_intel` run (profile + ~20 posts + 1 signal each) costs roughly **$0.14 - $0.16** total. ### FAQ **Q: Why only ~20 posts per profile?** A: That is roughly the most X's public, logged-out syndication surface renders. There is no public "load more" without a login, and this actor stays logged-out by design (that is the whole legal posture - see Responsible use). So it caps at the public surface and tells you so, rather than pretending to firehose. If you need deep historical volume, that requires the paid X API or a logged-in scraper - neither of which this actor is. **Q: Can it search by keyword or hashtag?** A: No. Logged-out keyword/hashtag search is not exposed on the public surface, so this actor does not offer it. Track specific **handles** instead (your accounts, competitors, campaign authors) - that is what the public surface supports, and it is the higher-signal approach for brand and competitor monitoring anyway. **Q: Will it get blocked?** A: X rate-limits bare datacenter IPs on the profile-timeline surface aggressively - you may see `fetch_error` records that say "rate-limited / blocked". The actor handles this: it backs off, rotates its session, and surfaces a clear reason rather than crashing. The fix is to set `apify_proxy_groups` to `["RESIDENTIAL"]` and keep `concurrency` at 1-2. The per-post (tweet id) surface is much more tolerant and usually works on datacenter proxies. Behaving like a normal visitor - residential IP, real browser fingerprint, low rate - is both the technical fix and the legal posture. **Q: Why not just use the official X API?** A: Cost. X's official API has no real free tier, runs pay-per-use, and tops out at **$42,000-$50,000+/month** for enterprise volume. Anyone who needs more than a trickle is priced out. This actor reads the same public surface an anonymous visitor already sees, for Apify pay-per-event cents - no API token, no subscription. **Q: Does it work for private accounts?** A: No. Protected (private) accounts are not publicly readable, so they are out of scope. The actor only reads what X serves to a logged-out visitor. **Q: Some posts\_lookup records are missing retweet/quote counts. Why?** A: The public per-post surface (used by posts\_lookup) exposes like\_count and reply\_count but not separate retweet/quote counts. Those fields come through fully via the profile-timeline surface, so use `profile_intel` when you need complete per-post metrics. Each record carries a `metrics_source` and a `metrics_note` so you always know what you are looking at. ### Save your input as an Apify Task Apify Tasks let you save a configured input once and re-run it with one click - the foundation for schedules, brand\_monitor mode, and the follower/post baseline (the baseline is most useful when the same handle list runs on a cadence). 1. Click `Run` with your input configured. 2. Click `Save as task`. 3. Name it (e.g. `competitor-watch - daily`). 4. Reload the task page and click `Start` anytime. ### Run this daily with Apify Schedules 1. Save your input as a Task (above), with `mode` set to `brand_monitor`. 2. Go to https://console.apify.com/schedules and `Create new schedule`. 3. Pick your Task and set a cron expression (daily 9am: `0 9 * * *`). 4. Save. Each run refreshes the baseline and surfaces the day's new posts and follower changes. ### Monitor mode (beta) When this actor runs under an Apify Schedule in `brand_monitor` mode, monitor mode emits only the change-delta (new posts + follower deltas across the watchlist) with a digest record at the top, instead of re-emitting everything. Provide `monitor_webhook_url` and the digest also fires to your Slack channel. Cost: one `scheduled_delta_run` event ($0.05) per scheduled run plus standard PPE on the records emitted. ### Related Actors - [hiring-signal-intel](https://apify.com/seibs.co/hiring-signal-intel) - live job-postings intent signals from public ATS feeds; pair social momentum with hiring momentum. - [reddit-topic-watcher](https://apify.com/seibs.co/reddit-topic-watcher) - watch Reddit topics for the same brand/competitor monitoring, on a different platform. - [google-maps-reviews-pro](https://apify.com/seibs.co/google-maps-reviews-pro) - public review intelligence to round out a brand-monitoring stack. ### Support Open an issue via the Apify Store contact link. Include the run ID and input config so the issue is reproducible. ### Changelog See [CHANGELOG.md](./CHANGELOG.md). ### Found this useful? If this actor saved you time or money, please leave a quick review on the Apify Store. Reviews help other buyers find work that solves their problem: https://apify.com/seibs.co/x-twitter-intel#reviews # Actor input Schema ## `mode` (type: `string`): profile\_intel = per handle, a profile\_record + a post\_record per recent post + one engagement\_velocity\_signal. posts\_lookup = resolve tweet ids / status URLs to a post\_record each (partial metrics: likes + replies, but not retweet/quote counts on this surface). brand\_monitor = profile\_intel over a watchlist, built for Apify Schedules - under a schedule it emits the new-posts + follower-delta digest. ## `handles` (type: `array`): X / Twitter handles to profile, with or without a leading @ (e.g. \['nasa', '@openai']). Used by profile\_intel and brand\_monitor. Each handle returns a profile\_record, up to ~20 recent post\_records, and one engagement\_velocity\_signal. Hard cap of 50 handles. Note: private (protected) accounts are not publicly readable. ## `post_inputs` (type: `array`): Tweet ids or full status URLs to resolve, for posts\_lookup mode. Both shapes work: '1234567890123456789' or 'https://x.com/nasa/status/1234567890123456789'. Each resolves to one post\_record. The public per-post surface exposes like\_count and reply\_count but not separate retweet/quote counts - use profile\_intel for full per-post metrics. Hard cap of 200. ## `max_posts_per_profile` (type: `integer`): How many recent posts to return per profile. Capped at 20 because that is roughly the most X's public logged-out syndication surface renders - there is no public 'load more' without a login, so this actor does not pretend to firehose. Default 20. ## `include_replies` (type: `boolean`): Include the profile's reply posts. When off (default), posts flagged is\_reply are filtered out so you get original posts only. ## `monitor_webhook_url` (type: `string`): When this actor runs under an Apify Schedule (brand\_monitor mode), post the change digest (new posts + follower deltas) to this Slack-compatible webhook URL. ## `use_apify_proxy` (type: `boolean`): Route requests through Apify Proxy. Recommended on. X's profile-timeline surface rate-limits bare datacenter IPs aggressively. ## `apify_proxy_groups` (type: `array`): Apify Proxy groups. DATACENTER is the cheap default and works for the per-post (cdn.syndication) surface. If you see fetch\_error 'blocked / rate-limited' records on profile fetches, switch this to \['RESIDENTIAL'] - the profile-timeline surface blocks datacenter IPs hard. ## `concurrency` (type: `integer`): Parallel fetches. Kept low (default 2, max 4) to behave like a normal visitor and avoid rate limits - a courtesy and a legal mitigation per the public-data posture. ## Actor input object example ```json { "mode": "profile_intel", "handles": [ "nasa", "openai" ], "post_inputs": [], "max_posts_per_profile": 20, "include_replies": false, "monitor_webhook_url": "", "use_apify_proxy": true, "apify_proxy_groups": [ "DATACENTER" ], "concurrency": 2 } ``` # Actor output Schema ## `datasetItems` (type: `string`): Narrow, token-efficient slice of every record. Consumer: LLM agents (Claude, GPT, LangChain tools), MCP hosts, brand-monitoring dashboards. ## `datasetItemsSignals` (type: `string`): Per-profile intel rollup: average engagement, engagement-per-follower, cadence, newest-post velocity, momentum, and monitor deltas. Consumer: brand/competitor watch, social analytics, alt-data. ## `datasetItemsPosts` (type: `string`): All posts with full normalized fields. Consumer: humans browsing, RAG ingest, export. ## `datasetItemsProfiles` (type: `string`): Profile snapshots with full public fields. Consumer: competitor/account tracking, CRM enrichment. ## `datasetItemsMcp` (type: `string`): First 50 overview records as a clean JSON array. Wrap on the agent side in an MCP tool-call envelope. Consumer: MCP servers, Claude Desktop, Cursor, OpenAI Assistants tool calls. ## `datasetItemsCsv` (type: `string`): Spreadsheet-friendly export of the overview view. Consumer: marketing / social teams, Excel / Google Sheets users. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "mode": "profile_intel", "handles": [ "nasa", "openai" ] }; // Run the Actor and wait for it to finish const run = await client.actor("seibs.co/x-twitter-intel").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "mode": "profile_intel", "handles": [ "nasa", "openai", ], } # Run the Actor and wait for it to finish run = client.actor("seibs.co/x-twitter-intel").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_intel", "handles": [ "nasa", "openai" ] }' | apify call seibs.co/x-twitter-intel --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=seibs.co/x-twitter-intel", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "X (Twitter) Public Intel - Profiles, Posts, Engagement Velocity", "description": "Profile intel, post records, and engagement-velocity signals from X's public logged-out surfaces. No login, no cookies, no API keys. Built for brand monitoring, competitor watch, and agent pipelines - with watchlist monitor mode. Recent posts per profile (about 20), not a firehose.", "version": "0.1", "x-build-id": "pHHJPHqAYFy4yfPBC" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/seibs.co~x-twitter-intel/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-seibs.co-x-twitter-intel", "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/seibs.co~x-twitter-intel/runs": { "post": { "operationId": "runs-sync-seibs.co-x-twitter-intel", "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/seibs.co~x-twitter-intel/run-sync": { "post": { "operationId": "run-sync-seibs.co-x-twitter-intel", "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": "Mode", "enum": [ "profile_intel", "posts_lookup", "brand_monitor" ], "type": "string", "description": "profile_intel = per handle, a profile_record + a post_record per recent post + one engagement_velocity_signal. posts_lookup = resolve tweet ids / status URLs to a post_record each (partial metrics: likes + replies, but not retweet/quote counts on this surface). brand_monitor = profile_intel over a watchlist, built for Apify Schedules - under a schedule it emits the new-posts + follower-delta digest.", "default": "profile_intel" }, "handles": { "title": "X handles (with or without @)", "maxItems": 50, "type": "array", "description": "X / Twitter handles to profile, with or without a leading @ (e.g. ['nasa', '@openai']). Used by profile_intel and brand_monitor. Each handle returns a profile_record, up to ~20 recent post_records, and one engagement_velocity_signal. Hard cap of 50 handles. Note: private (protected) accounts are not publicly readable.", "default": [], "items": { "type": "string" } }, "post_inputs": { "title": "Tweet ids or status URLs (posts_lookup)", "maxItems": 200, "type": "array", "description": "Tweet ids or full status URLs to resolve, for posts_lookup mode. Both shapes work: '1234567890123456789' or 'https://x.com/nasa/status/1234567890123456789'. Each resolves to one post_record. The public per-post surface exposes like_count and reply_count but not separate retweet/quote counts - use profile_intel for full per-post metrics. Hard cap of 200.", "default": [], "items": { "type": "string" } }, "max_posts_per_profile": { "title": "Max posts per profile", "minimum": 1, "maximum": 20, "type": "integer", "description": "How many recent posts to return per profile. Capped at 20 because that is roughly the most X's public logged-out syndication surface renders - there is no public 'load more' without a login, so this actor does not pretend to firehose. Default 20.", "default": 20 }, "include_replies": { "title": "Include replies", "type": "boolean", "description": "Include the profile's reply posts. When off (default), posts flagged is_reply are filtered out so you get original posts only.", "default": false }, "monitor_webhook_url": { "title": "Monitor webhook URL (Slack, optional)", "type": "string", "description": "When this actor runs under an Apify Schedule (brand_monitor mode), post the change digest (new posts + follower deltas) to this Slack-compatible webhook URL.", "default": "" }, "use_apify_proxy": { "title": "Use Apify Proxy", "type": "boolean", "description": "Route requests through Apify Proxy. Recommended on. X's profile-timeline surface rate-limits bare datacenter IPs aggressively.", "default": true }, "apify_proxy_groups": { "title": "Proxy groups", "type": "array", "description": "Apify Proxy groups. DATACENTER is the cheap default and works for the per-post (cdn.syndication) surface. If you see fetch_error 'blocked / rate-limited' records on profile fetches, switch this to ['RESIDENTIAL'] - the profile-timeline surface blocks datacenter IPs hard.", "default": [ "DATACENTER" ], "items": { "type": "string" } }, "concurrency": { "title": "Max concurrent requests", "minimum": 1, "maximum": 4, "type": "integer", "description": "Parallel fetches. Kept low (default 2, max 4) to behave like a normal visitor and avoid rate limits - a courtesy and a legal mitigation per the public-data posture.", "default": 2 } } }, "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 } } } } } } } } } } ```