Twitter X Profile Viewer

Twitter X Profile Scraper — Bio, Followers and Verification Data

Twitter X Profile Viewer pulls public X (Twitter) profile data — bio, follower and following counts, blue-verification status, affiliate badges, and pinned tweet IDs — for any list of usernames or profile URLs, and returns it as clean, structured JSON. No X account, API key, or login is required. Every profile streams straight to the dataset the moment it's parsed. Give it a list of handles and start a run to see it work.

---

What is Twitter X Profile Viewer?

Twitter X Profile Viewer is an Apify Actor that fetches a public X (Twitter) profile page for each username or URL you provide, parses the page's own embedded profile data, and returns identity, stats, verification, affiliate-badge, and pinned-tweet fields as one JSON record per profile. It runs against X's logged-out, server-rendered profile pages — no X account, cookie, or API key is needed to use it. It's built for growth and social-media teams, researchers, and developers or AI engineers who need structured public profile data without maintaining their own scraper or an X API integration.

---

What X (Twitter) profile data is publicly available to scrape?

Anyone who opens a public X profile without logging in can already see the fields below — nothing here requires an account.

Data Category	Publicly Available (no login)	Restricted (requires login)
Name, username, bio, location	Yes	—
Avatar and banner images	Yes	—
Follower / following / tweet counts	Yes	—
Blue-verification status and type	Yes	—
Affiliate / organization badge	Yes	—
Pinned tweet IDs	Yes	—
Account creation date	Yes	—
Full follower / following lists	No	Requires login
Tweet content, timeline, replies, DMs	No	Requires login

Twitter X Profile Viewer only returns publicly visible data — what any visitor sees. Nothing behind a login wall.

---

What data can I extract with Twitter X Profile Viewer?

Every run returns identity, engagement, verification, and pinned-content fields for each profile, grouped below exactly as the Actor builds each dataset record.

Identity & profile fields

Field Name	Description
user_id	The account's numeric X/Twitter rest_id.
username	The account's current handle, without the @.
name	The account's display name.
profile_url	Canonical https://x.com/<username> link.
bio	Profile description text.
location	Free-text location field on the profile.
profile_image	Upscaled (400x400) avatar URL.
profile_banner	Profile header/banner image URL.
created_at	Account creation date, ISO 8601 UTC.
input	The exact URL or username string as supplied in the input.

Stats & status fields

Field Name	Description
account_status	One of active, protected, unavailable, not_found, parse_error, invalid_input.
followers_count	Follower count at scrape time.
following_count	Following count at scrape time.
tweets_count	Total posts count at scrape time.
media_count	Total photos and videos posted, from the account's Media tab.
is_blue_verified	Whether the account has an active X Premium / Blue subscription checkmark.
verification_type	Verification category when set, e.g. Government, Business.
is_protected	Whether tweets are protected / the account is private.

Affiliate & pinned-content fields

Field Name	Description
affiliate_name	Name of the affiliated organization badge, if any.
affiliate_url	Link target of the affiliate badge, if any.
affiliate_badge	Icon image URL of the affiliate badge, if any.
pinned_tweet_ids	IDs of tweets currently pinned to the profile.
scraped_at	UTC timestamp the record was scraped, ISO 8601.

🤖 Add-on: Need profile data from other platforms too?

Twitter X Profile Viewer is a single-platform scraper — there's no companion X/Twitter Actor in this catalog to cross-sell here. If you're building a cross-platform profile dataset, the same account also publishes a LinkedIn People Profile Scraper and an Instagram Transcript API & Profile Scraper for the equivalent public-profile fields on those platforms.

---

How does Twitter X Profile Scraper differ from the official X API?

The official X API requires registering a developer account and app at console.x.com and authenticating every call with a bearer token; Twitter X Profile Viewer needs neither — you paste usernames or URLs and run it. As of the current X API documentation (docs.x.com, checked 2026-09-03), access is billed on a pay-per-usage credit model rather than a fixed free tier, and covers a much broader surface (posts, DMs, Spaces, Lists, trends) that each need their own authorization scope.

Feature	X API (Official)	Twitter X Profile Viewer
Account setup	Developer account, app registration, bearer token	None — no account or key
Pricing model	Pay-per-usage credits (per current X API docs)	Apify pay-per-event pricing
Scope	Broad: posts, DMs, Spaces, Lists, trends, users	Focused: public profile fields only
Data source	X's own authorized REST/GraphQL endpoints	Public, logged-out profile pages
Output shape	Raw API response shape per endpoint/version	One fixed, flat JSON schema per profile
Bulk lookups	One account/session per authorized call	Up to 100,000 usernames/URLs in one run

Use the official X API when you need authenticated actions (posting, DMs, private timelines) or data outside a public profile page. Use Twitter X Profile Viewer when you only need public profile fields without registering a developer app or managing API credentials.

---

How to use Twitter X Profile Viewer

Twitter X Profile Viewer is an Apify Actor — there's no separate signup or API key to obtain before your first run.

1. Open the Actor's page on the Apify Store and click Run, or start it from your Apify Console.
2. Add your list of profiles in the urls field — the only required input. Mix bare usernames, @handles, and full URLs freely.
3. Optionally set proxyConfiguration if you want to force a starting proxy tier or region; leave it as-is to let the Actor manage proxy escalation automatically.
4. Start the run.
5. Read results as JSON or CSV from the dataset, or pull them via the Apify API once the run finishes.

How to scale to bulk profile extraction

urls is an array input (minItems: 1, maxItems: 100000), so bulk extraction is native — paste as many usernames or URLs as you need into that one field and they all run in a single execution. The Actor normalizes and de-duplicates entries before sending any request, so elonmusk, @elonmusk, and https://x.com/elonmusk in the same list only cost one request.

---

What can you do with X (Twitter) profile data?

• 🎯 A growth marketer building an outreach list uses followers_count and is_blue_verified to prioritize established, verified accounts before sending pitches.
• 🕵️ A trust & safety researcher checking impersonation reports uses verification_type and affiliate_badge to confirm whether an account is genuinely tied to the organization it claims.
• 📈 A social-media analyst benchmarking competitor accounts uses followers_count, following_count, and tweets_count to compare growth and posting cadence over time.
• 🧵 A content team auditing brand accounts uses pinned_tweet_ids and bio to check what each account is currently featuring without opening every profile manually.
• 🤖 An AI engineer building a lead-enrichment agent feeds bio, name, and location into a RAG pipeline so an LLM can summarize a prospect's public X presence before drafting outreach.

Because output is typed JSON with stable field names, these same fields can be called directly from an agent tool or MCP client — see Integrations below.

---

How does Twitter X Profile Viewer handle rate limits and blocking?

The Actor starts every run with no proxy at all. Only if X responds with HTTP 403, 429, or 5xx does it escalate to a datacenter proxy, and only if the datacenter tier is also blocked does it escalate again to a residential proxy — once escalated, the run stays on that tier for every remaining profile rather than flip-flopping. Requests also rotate across x.com, twitter.com, and mobile.twitter.com on a transport failure. Each profile gets up to 3 request attempts by default, with exponential backoff (capped at 20 seconds, plus jitter) between attempts, and up to 5 profiles are processed concurrently.

⚠️ If 12 consecutive requests never reach X at all (a dead proxy or network path, not a block), the run halts early — everything already scraped is preserved in the dataset, but remaining usernames are not attempted.

If a single profile exhausts all retries, it is skipped rather than retried indefinitely; see FAQ for what that means for row counts.

---

⬇️ Input

Parameter	Required	Type	Description	Example Value
urls	Yes	array of strings	One profile per entry: full URL (https://x.com/elonmusk), bare username (elonmusk), or @handle (@elonmusk). twitter.com and mobile.twitter.com links are accepted too. 1–100,000 entries.	["elonmusk", "@nasa", "https://x.com/SpaceX"]
proxyConfiguration	No	object	Apify Proxy configuration. Defaults to no proxy (useApifyProxy: false) — the Actor auto-escalates to datacenter, then residential, only if X actually blocks the run. Set this only to force a starting tier or region.	{ "useApifyProxy": true }

Example input

{
  "urls": [
    "elonmusk",
    "nasa",
    "https://x.com/SpaceX",
    "@sundarpichai",
    "https://twitter.com/OpenAI"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}

---

⬆️ Output

Each run produces typed, normalized JSON with the same 23 fields on every record, whether the profile is active, protected, suspended, or missing. Results are available as the full dataset (JSON), a CSV export, and six pre-built dataset views (Overview, Profile details, Statistics, Verification & affiliate, Pinned tweets, Run metadata) for browsing without a wide table.

This Actor uses pay-per-event pricing on the row_result event. Any profile that gets far enough to complete a request — active, protected, unavailable, not found, or a parse error — is a billed row_result. Rows written for malformed input (account_status: "invalid_input") are saved to the dataset but are not charged. To view only billed rows, filter the dataset on account_status != "invalid_input".

Example output

{
  "user_id": "44196397",
  "username": "elonmusk",
  "name": "Elon Musk",
  "profile_url": "https://x.com/elonmusk",
  "bio": "Mars, Cars, Chips 'n Dip",
  "location": "Austin, Texas",
  "profile_image": "https://pbs.twimg.com/profile_images/2053244804520427520/m8mdWZCG_400x400.jpg",
  "profile_banner": "https://pbs.twimg.com/profile_banners/44196397/1774145451",
  "is_blue_verified": true,
  "verification_type": null,
  "account_status": "active",
  "followers_count": 241511630,
  "following_count": 1399,
  "tweets_count": 78412,
  "media_count": 9821,
  "created_at": "2009-06-02T20:12:29.000Z",
  "is_protected": false,
  "affiliate_name": "Tesla",
  "affiliate_url": "https://x.com/Tesla",
  "affiliate_badge": "https://pbs.twimg.com/semantic_core_img/1683397672663019521/oYSEyBpN?format=png&name=orig",
  "pinned_tweet_ids": ["1832456789012345678"],
  "scraped_at": "2026-09-03T10:15:22.481Z",
  "input": "elonmusk"
}

---

How does it work?

For each username, the Actor sends a plain HTTPS GET to the profile page using browser TLS impersonation (via curl_cffi, impersonating Chrome) — no headless browser is launched. X's current web client server-renders the whole profile object inline in the HTML as embedded React Server Components data, so the Actor parses that block directly rather than calling a private API. A separate, publicly available guest-session call fills in media_count, which isn't present on the profile page itself. Field lookups use targeted, anchored patterns with an unscoped fallback for each one, so a single renamed field degrades to null instead of breaking the whole record — which keeps the output schema stable across X's UI and template changes. Only what's already visible to a logged-out visitor is ever returned.

---

Integrations

Twitter X Profile Viewer runs on the Apify platform, so it works with anything that can call an Apify Actor: the REST API, official SDKs, or Apify's own no-code and agent integrations.

Calling Twitter X Profile Viewer programmatically

from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")

run = client.actor("<store-owner>/twitter-x-profile-viewer").call(
    run_input={"urls": ["elonmusk", "nasa", "https://x.com/SpaceX"]}
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["username"], item["account_status"], item["followers_count"])

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request with your Apify API token as the bearer credential.

MCP integration for AI agents

Twitter X Profile Viewer is reachable through Apify's own MCP server rather than a bundled MCP server of its own. Register the hosted server at https://mcp.apify.com, or run it locally with npx @apify/actors-mcp-server and an APIFY_TOKEN environment variable, then pass this Actor's Store ID via --actors so your MCP client (Claude Desktop, or any MCP-compatible agent framework) can call it as a tool.

No-code tools (n8n, Make, LangChain)

In n8n, use the Apify node, or an HTTP Request node pointed at the Actor's run endpoint, to trigger a run and pull results straight into your workflow. In Make, add an HTTP module against the same run endpoint with your API token as the bearer header. In LangChain, use ApifyWrapper to start the Actor and load its dataset directly as documents for a retrieval pipeline.

---

Is it legal to scrape X (Twitter) profiles?

Scraping publicly accessible profile data is generally permitted, since Twitter X Profile Viewer only returns what any logged-out visitor can already see on a profile page — nothing behind a login wall. Because profile fields like name, bio, and location can constitute personal data, GDPR and CCPA (and similar regional laws) still govern how you store, process, and reuse it once collected, independent of how it was obtained. Consult legal counsel if your use case involves bulk storage of personal data.

---

Frequently asked questions

What X (Twitter) profile fields does Twitter X Profile Viewer return?

The top fields are username, name, bio, followers_count, and is_blue_verified, alongside 18 more identity, stats, and affiliate fields — see What data can I extract above for the full list.

Does Twitter X Profile Viewer require an X account or login?

No. It fetches the same logged-out profile page any anonymous visitor sees; the only authenticated-feeling call it makes internally is a public guest-token request X's own web client uses to bootstrap itself, and it never uses your credentials.

How many profiles can I extract in one run?

The urls input accepts between 1 and 100,000 entries per run, and duplicates (mixed formats included) are automatically collapsed to a single request before scraping starts.

What happens if a profile is private, suspended, or doesn't exist?

Each outcome gets its own account_status: not_found for a nonexistent handle, protected for a private account, unavailable for suspended or deactivated accounts, and parse_error if X's page structure doesn't match what the Actor expects. All four are still written to the dataset as a full record with the rest of the fields set to null. The one exception: if a request to a username fails completely after all retries (a dead connection, not a block), no row is written for it at all — reconcile your output count against your input list if that matters for your use case.

Can I scrape multiple X (Twitter) profiles at once?

Yes — urls is an array, so a single run accepts any mix of usernames, @handles, and full profile URLs up to the 100,000-entry limit.

Does Twitter X Profile Viewer work with Claude, ChatGPT, and other AI agent tools?

Yes. It's callable as an HTTP endpoint by any agent framework, and it's reachable through Apify's own MCP server (https://mcp.apify.com or @apify/actors-mcp-server) for MCP-compatible clients like Claude Desktop.

How does Twitter X Profile Viewer compare to other X (Twitter) profile scrapers?

Twitter X Profile Viewer's main structural differences are its 3-tier proxy escalation (direct → datacenter → residential, only when actually blocked) and its dataset schema, which includes verification type, affiliate badge, and pinned tweet IDs alongside the usual identity and count fields in every record.

Does Twitter X Profile Viewer return data in a format LLMs can use directly?

Yes. Output is typed, normalized JSON with consistent field names across runs — no HTML parsing or selectors needed. Pass it directly to an LLM, index it into a vector store, or feed it to an agent tool.

What happens when X changes its layout or anti-bot system?

The parser is built around anchored field lookups with an unscoped fallback for each one, so an isolated field rename degrades to null rather than breaking the run, and the output schema stays the same regardless of X's page structure. No specific update turnaround time is promised.

Can I use Twitter X Profile Viewer without managing proxies or browser infrastructure?

Yes. The Actor handles proxy tier selection and escalation (via Apify Proxy) and host fallback internally, and it makes plain HTTPS requests with browser TLS impersonation rather than launching a browser, so there's no headless browser infrastructure to manage either.

Which X (Twitter) profile fields work best for AI training data and RAG indexing?

For RAG, index the high-information text fields: bio, name, and location. For structured training features, use the fields that stay consistently typed across every record: followers_count, following_count, tweets_count, is_blue_verified, and account_status. All fields return as typed primitives (strings, numbers, booleans, or arrays), never as embedded HTML or markup.

---

Related scrapers

Scraper Name	What it extracts
LinkedIn People Profile Scraper	Public LinkedIn profile fields — headline, current role, and public activity.
Linkedin Profile Scraper with Email & Company Data (No Cookie)	LinkedIn profiles enriched with email and company details.
Instagram Transcript API & Profile Scraper - AI Video to Text	Instagram profile data plus AI-generated video transcripts.
TikTok Posts Scraper	Post-level data from TikTok accounts.
TikTok Keyword Search Scraper	TikTok posts and accounts matching a search keyword.

---

Your feedback

Found a bug, or need a field this Actor doesn't return yet? Let us know at dev.scraperengine@gmail.com — bug reports and field requests go straight to the team maintaining this Actor.