# X Twitter Profile Lookup (`agentx/x-twitter-profile-lookup`) Actor

Look up 1 to 1,000 public X usernames or profile URLs and export source-reported profile fields, counts, labels, links, imagery, and available pinned-post details, with explicit not-found rows.

- **URL**: https://apify.com/agentx/x-twitter-profile-lookup.md
- **Developed by:** [AgentX](https://apify.com/agentx) (community)
- **Categories:** Social media, Lead generation, Developer tools
- **Stats:** 131 total users, 2 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $4.50 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

Twitter Info Scraper converts a batch of public X usernames or profile URLs into reviewable Dataset rows. A successful lookup has 47 top-level fields; a username that X reports as missing produces a four-field `not found` row instead of disappearing from the batch.

- Submit 1 to 1,000 usernames, `@handles`, or x.com/twitter.com profile URLs.
- Receive source-reported profile text, counts, labels, links, imagery, and available pinned-post data.
- Keep successful and not-found observations in the same auditable Dataset.
- Treat every count, label, flag, URL, and post as a changing source snapshot—not independent verification.

[Run Twitter Info Scraper](https://console.apify.com/actors/PVpATK5xrZz1JBNvn/input) or connect through the [Apify API](https://docs.apify.com/api/v2) and [MCP integration](https://docs.apify.com/integrations/mcp). Result rows, including not-found rows, are billable; review public-profile data and source rights before reuse.

### Why Choose This API

This Actor is designed for repeatable public-profile lookup rather than visual browsing. Inputs are normalized from plain usernames, handles, and profile URLs, then processed in batches. The default Dataset preserves a row for a username when the source explicitly reports that no account was found, which makes reconciliation easier than silently dropping a requested identifier.

A successful row contains 47 stable top-level keys. They cover processing metadata, public account identifiers, display text, source-provided verification and label fields, privacy and sensitivity flags, follower and activity counters, professional-account values, profile imagery, expanded URLs, public birth-date visibility, withheld-country codes, recent posting-source labels, and the available pinned-post observation. The key `pined` intentionally keeps the runtime spelling for compatibility.

The contract is deliberately honest about source boundaries. X can omit profile fields, return empty arrays, hide a birth date, expose no pinned post, protect posts, or change counters between runs. A blue-check field reflects the current source signal; X explains that a blue check is associated with an eligible Premium subscription and does not use the former notable-and-authentic review. This Actor does not certify identity, authenticity, influence, ownership, safety, or commercial suitability.

### Quick Start Guide

Enter a list under `usernames`. The runtime accepts up to 1,000 list entries and normalizes recognized X or Twitter profile URLs to their username component. Blank normalized entries are ignored, but the run stops if no usable username remains.

```json
{
  "usernames": [
    "OpenAI",
    "@GitHub",
    "https://x.com/apify"
  ]
}
```

Click **Start** in the Actor console. When the run finishes, open the default Dataset and inspect `status` first. `success` indicates that the source returned a profile object; `not found` indicates that the source returned an empty user result. A successful Actor process does not guarantee that every requested account resolves, and transient X responses can still make an entire batch unavailable.

For production use, start with a small known list, verify both the row count and statuses, then scale. Repeated inputs can create repeated observations across batches, so deduplicate upstream if one row per unique username is required.

### Input Parameters

| Field | Type | Required | Accepted range | Behavior |
|---|---|---:|---|---|
| `usernames` | array of strings | Yes | 1–1,000 entries | Accepts usernames, `@handles`, x.com URLs, and twitter.com URLs. |

Normalization removes a leading `@`, extracts the first path component after a recognized domain, drops query strings and fragments, and lowercases the request key. The source may return its own capitalization in a successful row. Non-string elements fail validation. Entries that normalize to an empty string are skipped, and at least one usable value is required.

The limit applies to submitted list entries, not guaranteed successful profiles. Lookups are grouped into batches of ten and retried across available proxy routes. If a batch cannot be completed with all requested normalized names, that batch may produce no rows. No input requests tweet history, contact data, private posts, followers lists, or a full posting archive.

### Output Data Schema

Successful records expose 47 top-level keys. The major groups are:

| Group | Representative fields | Important interpretation |
|---|---|---|
| Processing | `status`, `processor`, `processed_at` | Observation metadata, not a source guarantee. |
| Identity text | `user_id`, `user_name`, `display_name`, `description`, `location` | Public/source-visible profile values. |
| Labels and access | `verified`, `verified_type`, `blue_verified`, `identity_verified`, `protected`, `sensitive` | Source flags; no independent identity or safety check. |
| Counts | `followers_count`, `following_count`, `statuses_count`, `favourites_count`, `listed_count`, `media_count` | Dynamic snapshots that can change immediately. |
| Professional fields | `account_type`, `account_category`, `creator_subscriptions`, `business_affiliates` | Optional raw profile values, not verified business facts. |
| Links and media | `avatar_url`, `banner_url`, `profile_urls`, `description_urls`, `tipjar_accounts` | Source-exposed URLs and handles; validate before use. |
| Timeline context | `user_devices`, `pinned_tweet_ids`, `pined` | Recent posting-source labels and one available pinned-post observation. |

The `pined` object can contain 18 defined keys: ID, constructed URL, creation time, text, source, language, hashtags, URLs, mentions, variable media entities, conversation ID, quote flag, and six engagement counters. It is `{}` when the current timeline response has no pin entry. `extended_entities` remains source-shaped because media types have different nested structures.

```json
{
  "status": "success",
  "processor": "https://apify.com/agentx/twitter-info-scraper",
  "processed_at": "2026-07-23T18:00:00+00:00",
  "user_id": "783214",
  "user_name": "OpenAI",
  "display_name": "OpenAI",
  "description": "Source-visible profile biography",
  "location": "",
  "blue_verified": true,
  "identity_verified": false,
  "protected": false,
  "followers_count": 0,
  "following_count": 0,
  "statuses_count": 0,
  "profile_urls": [],
  "description_urls": [],
  "user_devices": ["X Web App"],
  "blocked_countries": [],
  "pined": {}
}
```

The example is abbreviated and uses illustrative dynamic values. A `not found` row contains only `status`, `processor`, `processed_at`, and the normalized `user_name`; consumers must not assume the other 43 keys are present on that branch.

### Integration Examples

Use the Actor ID `agentx/twitter-info-scraper` with the API, an Apify client, a scheduler, webhook automation, or an MCP-enabled agent. The same input object is used on every surface. Keep the API token in a secret manager and never embed it in public code.

```json
{
  "method": "POST",
  "url": "https://api.apify.com/v2/acts/agentx~twitter-info-scraper/runs?waitForFinish=120",
  "headers": {
    "Authorization": "Bearer YOUR_APIFY_TOKEN",
    "Content-Type": "application/json"
  },
  "body": {
    "usernames": ["OpenAI", "@GitHub", "https://x.com/apify"]
  }
}
```

After the run reaches a terminal state, read `defaultDatasetId` and request its items. For robust pipelines, retain the input value beside the normalized `user_name`, branch on `status`, and record `processed_at`. Retry transient batch failures separately; do not retry a stable not-found observation indefinitely without a business reason.

MCP clients should inspect the current input schema before calling the Actor. Some MCP plans may restrict execution of particular public Actors even when details and datasets remain readable. In that case, use the authenticated REST API or an Apify client and keep MCP for independent run and Dataset readback.

### Pricing & Cost Calculator

The local pay-per-event configuration has three event families. **Actor Usage** is `$0.00001` per metered usage event, **Actor Start** is `$0.01` and is charged according to memory with a minimum of one event, and **Result** is charged once per Dataset row. Both 47-field success rows and four-field not-found rows are results.

| Plan tier | Result price per row |
|---|---:|
| Free | `$0.00500` |
| Bronze | `$0.00483` |
| Silver | `$0.00467` |
| Gold | `$0.00450` |
| Platinum | `$0.00450` |
| Diamond | `$0.00450` |

At the Free result rate, one written row is `$0.00500`; 100 rows are `$0.50000`; and 1,000 rows are `$5.00000`. Add the Start event and metered Actor Usage. A request for 100 usernames that writes 90 success rows plus 10 not-found rows produces 100 Result events, not 90. A batch that writes nothing produces no Result event, although start and usage charges may still apply.

Treat these calculations as planning examples. The active price shown by Apify at run time controls billing, and platform-managed publication can temporarily show an older pricing snapshot after a code build. Use `maxTotalChargeUsd` as a financial guard, but do not treat it as a substitute for input-size controls or post-run event review.

### Use Cases & Applications

Profile enrichment teams can attach public X observations to an existing, lawfully obtained account list. The row provides stable field names for current biography text, URLs, source labels, and counters while retaining the timestamp needed to identify the observation as a snapshot.

Analysts can run the same usernames on a schedule and calculate changes outside the Actor. Store each run rather than overwriting historical rows, compare like-for-like statuses, and avoid interpreting follower growth as causation, authenticity, or campaign effectiveness without additional evidence.

Editorial and research workflows can triage public accounts by location text, professional category, protected status, or visible label. Those values are leads for human review, not adjudications. X notes that profile labels can be platform-applied or user-triggered, and protected posts have different visibility from public posts.

Automation builders can reconcile mixed input formats, separate unresolved usernames, and join successful rows with datasets from other public sources. Do not use the result as a background check, identity proof, credit signal, employment decision, or automated eligibility decision.

### FAQ

**Does this download every post from an account?**
No. It performs profile lookup and requests recent timeline context to derive posting-source labels and one available pinned-post object. It does not return a post archive.

**Does `blue_verified` prove identity or authenticity?**
No. It mirrors a source flag. X describes a blue check as tied to an eligible Premium subscription; the former notable-and-authentic review is not implied. `identity_verified` is also a source field, not an AgentX verification service.

**Why does a result have only four fields?**
When X returns an empty user result, the Actor writes a not-found row with status, processor, timestamp, and normalized username. This is intentional and billable.

**Why is the pinned-post key spelled `pined`?**
That spelling is part of the current runtime output contract. Changing it would break existing consumers, so documentation and schema preserve it.

**Are counters historical totals?**
They are current source-reported snapshots. Meanings, availability, and values can change, and repeated runs can differ.

**Can protected accounts be scraped fully?**
No. Public profile information may still be visible, but protected posts are limited by X visibility rules. Expect missing timeline or pinned-post data.

**Is one row guaranteed per submitted entry?**
No. A recognized not-found response becomes a row, but a transient or incomplete batch can exhaust retries without writing that batch.

### Trust & Certifications

Trust comes from a narrow, inspectable contract: one required input, explicit normalization, stable success keys, an explicit sparse not-found branch, observation timestamps, and event counts that can be reconciled with Dataset rows. The schema names nullable and optional source values rather than filling gaps with inferred facts.

There is no claim that AgentX, this Actor, or a Dataset row is an identity-verification, brand-safety, fraud-detection, KYC, certification, or official X service. Labels and checkmarks retain the context described in [X profile-label guidance](https://help.x.com/en/rules-and-policies/profile-labels). Important decisions should return to the live profile and qualified human review.

### Legal & Compliance

Use the Actor only for lawful purposes and public data you are entitled to process. Follow X terms, Apify terms, privacy and data-protection requirements, contractual duties, and rules that apply to your jurisdiction and use case. Minimize inputs, define a retention period, restrict access, and honor deletion or correction obligations where applicable.

Public does not mean unrestricted. X says common profile fields such as biography, location, website, and picture are generally public, while birth-date visibility is configurable. Review [profile visibility](https://help.x.com/en/safety-and-security/birthday-visibility-settings) and [public versus protected posts](https://help.x.com/en/safety-and-security/public-and-protected-posts) before designing downstream handling.

Do not infer sensitive traits, deanonymize people, harass users, evade access controls, or republish personal data without a valid basis. Media URLs, biographies, names, and posts may carry intellectual-property, privacy, publicity, or safety considerations. This documentation is operational guidance, not legal advice.

### Related Tools

- [X Twitter Community API](https://apify.com/agentx/x-twitter-community-api?fpr=aiagentapi) — look up public X Community profiles and membership context.
- [TikTok Creator API](https://apify.com/agentx/tiktok-creator-api?fpr=aiagentapi) — collect source-available creator videos or reposts.
- [Instagram Creator Scraper](https://apify.com/agentx/instagram-creator-scraper?fpr=aiagentapi) — retrieve public creator-profile observations.
- [LinkedIn Profile Lookup](https://apify.com/agentx/linkedin-profile-lookup?fpr=aiagentapi) — enrich a professional-profile review workflow.
- [Google Maps Store Scraper](https://apify.com/agentx/google-maps-store-scraper?fpr=aiagentapi) — add public place and business-listing context.
- [YouTube Market Intelligence](https://apify.com/agentx/youtube-market-intelligence?fpr=aiagentapi) — research public channel and niche observations.

Choose tools by the source and entity you actually need. Outputs from different platforms should be joined with explicit provenance and observation time rather than treated as a single verified identity graph.

### Support & Community

For reproducible support, provide the Actor run ID, UTC time, a redacted input shape, expected row count, actual status mix, and whether the problem affects profile lookup, timeline context, Dataset writing, or billing events. Never post API tokens or private identifiers in a public channel.

Use the [AgentX support channel](https://t.me/AiAgentApi) for product questions. For platform execution, storage, API, or billing behavior, consult the [Apify Actor documentation](https://docs.apify.com/platform/actors). Last updated: July 23, 2026.

# Actor input Schema

## `usernames` (type: `array`):

Enter 1 to 1,000 X usernames, @handles, or x.com/twitter.com profile URLs. Empty normalized entries are ignored; at least one usable username is required. Results may be a 47-field success row or a four-field not-found row.

## Actor input object example

```json
{
  "usernames": [
    "OpenAI"
  ]
}
```

# Actor output Schema

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

Open profile and not-found rows in the default Dataset. Successful rows expose 47 top-level fields; not-found rows contain status, processor, processed\_at, and user\_name.

# 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 = {
    "usernames": [
        "OpenAI"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentx/x-twitter-profile-lookup").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 = { "usernames": ["OpenAI"] }

# Run the Actor and wait for it to finish
run = client.actor("agentx/x-twitter-profile-lookup").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 '{
  "usernames": [
    "OpenAI"
  ]
}' |
apify call agentx/x-twitter-profile-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=agentx/x-twitter-profile-lookup",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

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