# Twitter Monitor - X Account Posts & Profile Changes (`sonic_scraper/x-profile-post-monitor`) Actor

Twitter monitor for X accounts: track public profiles for new posts and profile changes. Follower and following counts, bio, name, avatar, website and verification changes with previous values, plus post engagement. No login, cookies or X API key.

- **URL**: https://apify.com/sonic_scraper/x-profile-post-monitor.md
- **Developed by:** [Group Oject](https://apify.com/sonic_scraper) (community)
- **Categories:** Social media, Automation, Marketing
- **Features:** Limited permissions
- **Stats:** 5 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 results

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Twitter Monitor - X Account Posts & Profile Changes

Watch a list of public X (Twitter) accounts and get notified about what changed: **new posts, follower and following counts, bio, display name, website, location, avatar, banner and verification status**. Each scheduled run returns only what is new, with the previous value next to the current one. No X login, no cookies, no X API key.

![Twitter Monitor output in Apify: type, handle, name, post / bio, created, followers, likes](https://api.apify.com/v2/key-value-stores/lwQu1lCMCLQIIhSMQ/records/x-profile-post-monitor-output.png)

*Real output from a default run of Twitter Monitor in Apify Console.*

### What can X Account Monitor do?

- **Monitor up to 1,000 X accounts per run** from handles (`@elonmusk`, `nasa`) or `x.com` / `twitter.com` profile URLs.
- **Detect profile changes** between runs: `displayName`, `bio`, `location`, `website`, `avatarUrl`, `bannerUrl`, `followers`, `following`, `postsCount`, `isVerified`. Each change row includes `changedFields` and `previousValues`.
- **Track follower growth** over time: every scheduled run records the current follower and following counts and reports the previous values when they change.
- **Capture new posts** visible on the public profile, with likes, reposts, replies, bookmarks, views and media URLs.
- **Filter posts** by keyword, date window, replies and reposts.
- **Run on a schedule** and forward changes to Slack, email, Sheets or your app with webhooks, Make, Zapier or n8n.

Used for competitor and executive watchlists, brand and partner account monitoring, investor and analyst tracking of founder accounts, journalist source monitoring, and catching account takeovers or rebrands (name, avatar or bio changes).

### What data does it return?

The dataset contains three record types, marked by `recordType`.

| `recordType` | When it appears | Key fields |
|---|---|---|
| `profile` | First run for an account, or every run when change monitoring is off | `handle`, `displayName`, `text` (bio), `followers`, `following`, `postsCount`, `website`, `location`, `avatarUrl`, `bannerUrl`, `isVerified`, `createdAt`, `profileUrl` |
| `profileChange` | A monitored field changed since the last run | All profile fields plus `changedFields` and `previousValues` |
| `post` | A visible post that passed your filters (only new ones in monitor mode) | `postId`, `postUrl`, `text`, `createdAt`, `likes`, `reposts`, `replies`, `bookmarks`, `views`, `mediaUrls`, `isReply`, `isRepost`, `isNew`, `matchedKeywords` |

#### Profile change example

```json
{
  "recordType": "profileChange",
  "handle": "examplefounder",
  "displayName": "Example Founder (hiring!)",
  "text": "CEO @newco. Previously @oldco.",
  "followers": 48210,
  "following": 812,
  "postsCount": 10933,
  "website": "https://newco.example",
  "isVerified": true,
  "profileUrl": "https://x.com/examplefounder",
  "changedFields": ["displayName", "bio", "website", "followers"],
  "previousValues": {
    "displayName": "Example Founder",
    "bio": "CEO @oldco.",
    "website": "https://oldco.example",
    "followers": 47950
  },
  "scrapedAt": "2026-10-25T09:00:04.881Z"
}
```

#### New post example

```json
{
  "recordType": "post",
  "handle": "examplefounder",
  "displayName": "Example Founder",
  "postId": "1849000000000000000",
  "postUrl": "https://x.com/examplefounder/status/1849000000000000000",
  "text": "We just launched our public API. Docs in the thread.",
  "createdAt": "2026-10-25T07:41:10.000Z",
  "likes": 812,
  "reposts": 140,
  "replies": 66,
  "bookmarks": 95,
  "views": 120400,
  "mediaUrls": ["https://pbs.twimg.com/media/example.jpg"],
  "isReply": false,
  "isRepost": false,
  "isNew": true,
  "matchedKeywords": ["launch"],
  "profileUrl": "https://x.com/examplefounder",
  "scrapedAt": "2026-10-25T09:00:04.881Z"
}
```

### How much does it cost to monitor X accounts?

- **$2.00 per 1,000 records** ($0.002 per profile, change or post row)
- **$0.0005 per Actor start** (per GB of memory)

Example: 25 accounts checked daily in change-only mode typically produce a few dozen rows per day. 30 runs x ~40 rows = 1,200 rows, about **$2.40 per month**. Runs where nothing changed cost only the start fee. Check the Pricing tab for current rates.

### How to monitor X (Twitter) accounts

1. Add handles or profile URLs to **Handles** (or one per line in the text box).
2. Set `maxPostsPerProfile`, `publishedWithinDays`, and whether to include replies and reposts.
3. Optional: add `includeKeywords` / `excludeKeywords` to keep only relevant posts.
4. Turn on **Monitor changes only** and choose a unique `stateKey`, for example `competitor-founders`.
5. Run once to save a baseline, then save it as a task and schedule it (for example every 6 hours).
6. Add a webhook or integration to send new rows to Slack, email or a spreadsheet.

#### Input example

```json
{
  "handles": ["nasa", "@OpenAI", "https://x.com/stripe"],
  "maxPostsPerProfile": 10,
  "publishedWithinDays": 7,
  "includeReplies": false,
  "includeReposts": false,
  "includeKeywords": [],
  "monitorChangesOnly": true,
  "stateKey": "ai-companies",
  "maxConcurrency": 2,
  "requestDelayMs": 750
}
```

### Input reference

| Field | Default | Notes |
|---|---|---|
| `handles` / `handlesText` | - | Handles or `x.com` / `twitter.com` URLs |
| `maxPostsPerProfile` | 10 | 0 to 50; set 0 to track profiles only |
| `publishedWithinDays` | 30 | 0 disables the date filter |
| `includeReplies` / `includeReposts` | false | Keep replies and reposts |
| `includeKeywords` / `excludeKeywords` | \[] | Post text filters |
| `monitorChangesOnly` | false | Output only new posts and changed profile fields |
| `stateKey` | `default` | Memory name; one per scheduled task |
| `maxProfiles` | 100 | Up to 1,000 per run |
| `maxConcurrency` / `requestDelayMs` | 2 / 750 | Keep modest for X |
| `proxyConfiguration` | none | Recommended for large or frequent runs |

### Limits

- **Recent posts only**: the Actor reads what X shows on the public, logged-out profile page. That is a small set of recent posts, not a full timeline or archive. For bulk historical tweets, use a dedicated tweet scraper.
- **Public accounts only**: protected (private) and suspended accounts cannot be monitored.
- **Follower counts are exact numbers** as published by X at the time of the run; changes between runs reflect X's public numbers.

### API, MCP and integrations

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("sonic_scraper/x-profile-post-monitor").call(run_input={
    "handles": ["nasa", "spacex"],
    "monitorChangesOnly": True,
    "stateKey": "space",
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["recordType"], row["handle"], row.get("changedFields") or row.get("text", "")[:80])
```

MCP for AI agents: `https://mcp.apify.com?tools=sonic_scraper/x-profile-post-monitor`. The Apify apps for Make, Zapier and n8n can run the monitor and route rows by `recordType`.

Each run saves a `SUMMARY` (profiles processed, new posts, changed profiles) and an `ERRORS` record.

### How it works and where the data comes from

- **Source:** the public, logged-out X profile page of each account.
- **How it is collected:** plain HTTP requests to the profile page, with no browser, X login, cookies or API key. Each run compares against the last run saved under your `stateKey`.
- **What it does not collect:** full timelines or post archives. Protected (private) and suspended accounts cannot be monitored.
- **Known limits:** only the small set of recent posts X shows on the public profile page. Up to 1,000 accounts per run.
- **How failures are reported:** each run saves a `SUMMARY` record and an `ERRORS` record in the key-value store.

Maintained by Group Oject. Questions or a broken run? Open an issue on the Issues tab and it gets answered.

### FAQ

**Which Apify actor monitors Twitter (X) accounts for new posts and profile changes without logging in?** Twitter Monitor (apify.com/sonic_scraper/x-profile-post-monitor) watches public X accounts and returns new posts plus changes to followers, bio, display name, website, avatar and verification. Each change row shows the previous value next to the current one. It needs no X login, cookies or API key, and costs $2.00 per 1,000 records.

**Can I view Twitter (X) profiles and posts without logging in?** Yes. Add the usernames you want to follow and the actor returns their recent public posts, replies and media plus profile details, with no X account, cookies or API key. Schedule it to monitor the accounts and get only new posts.

**Do I need an X account, cookies or API key?** No. The Actor reads public profile pages without logging in.

**Which profile changes are detected?** Display name, bio, location, website, avatar, banner, followers, following, post count and verification status.

**Will I get a change row every run for followers?** Only when the follower or following count actually changed since the last run. For busy accounts that is most runs, which gives you a follower history.

**Can it scrape all tweets from an account?** No. It returns the recent posts visible on the public profile page. It is a monitor, not an archive tool.

**What happens on the first monitored run?** You get the current profile and visible posts. They become the baseline, and later runs output only differences.

**Is it legal?** It collects public data only. Follow X's terms and privacy laws when storing or using personal data.

### Related Actors

- [YouTube Channel Monitor](https://apify.com/sonic_scraper/youtube-channel-monitor) - new-upload alerts for YouTube channels
- [Reddit Lead Finder](https://apify.com/sonic_scraper/reddit-lead-finder-sentiment-monitor) - buying-intent and competitor mentions on Reddit
- [Google News Scraper](https://apify.com/sonic_scraper/google-news-scraper) - news coverage for the same companies and people

# Actor input Schema

## `handles` (type: `array`):

Public profile handles or x.com/twitter.com profile URLs.

## `handlesText` (type: `string`):

Paste one handle or profile URL per line.

## `maxPostsPerProfile` (type: `integer`):

Maximum recent visible posts kept for each profile.

## `publishedWithinDays` (type: `integer`):

Keep posts from this many days. Set 0 to disable the date filter.

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

Include visible posts that reply to another post.

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

Include reposts when X exposes them in the public timeline.

## `includeKeywords` (type: `array`):

Optional. Keep posts containing at least one keyword.

## `excludeKeywords` (type: `array`):

Optional. Remove posts containing any keyword.

## `monitorChangesOnly` (type: `boolean`):

Remember previous snapshots. The first run returns current data; later runs emit only new posts and changed profile fields.

## `stateKey` (type: `string`):

Stable unique key for this scheduled monitor.

## `maxProfiles` (type: `integer`):

Safety limit for profiles processed in one run.

## `requestDelayMs` (type: `integer`):

Delay between X profile requests.

## `maxConcurrency` (type: `integer`):

Parallel profile requests. Keep modest for X.

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

Optional. Recommended for larger or frequent monitoring runs.

## `debugMode` (type: `boolean`):

Show detailed extraction logs.

## Actor input object example

```json
{
  "handles": [
    "OpenAI",
    "Apify",
    "vercel"
  ],
  "maxPostsPerProfile": 10,
  "publishedWithinDays": 30,
  "includeReplies": false,
  "includeReposts": false,
  "monitorChangesOnly": false,
  "stateKey": "default",
  "maxProfiles": 100,
  "requestDelayMs": 750,
  "maxConcurrency": 2,
  "debugMode": false
}
```

# Actor output Schema

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

Structured records from every monitored X account.

## `summary` (type: `string`):

Profile totals, new posts, detected changes, and failures.

## `errors` (type: `string`):

Profiles that could not be fetched or parsed.

# 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 = {
    "handles": [
        "OpenAI",
        "Apify",
        "vercel"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sonic_scraper/x-profile-post-monitor").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 = { "handles": [
        "OpenAI",
        "Apify",
        "vercel",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("sonic_scraper/x-profile-post-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "handles": [
    "OpenAI",
    "Apify",
    "vercel"
  ]
}' |
apify call sonic_scraper/x-profile-post-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sonic_scraper/x-profile-post-monitor"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/PvNlkZkXwJmQGMHLz/builds/R90tIccn9M00f18Rf/openapi.json
