# 𝕏(twitter) User Profile (`truefetch/x-user-profile`) Actor

Twitter user profile scraper exports up to 1,000 identity-matched public X accounts per run with 38 possible sparse fields and no placeholder rows.

- **URL**: https://apify.com/truefetch/x-user-profile.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Social media, Lead generation, Integrations
- **Features:** Limited permissions
- **Stats:** 148 total users, 21 monthly users, 99.4% runs succeeded, 4 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.25 / 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) User Profile

**𝕏(twitter) User Profile is a twitter user profile scraper that transforms 1–1,000 known public X handles or exact profile URLs into identity-matched records with up to 38 sparse fields.** It gives research, enrichment, monitoring, and data-quality workflows a consistent Dataset while excluding unavailable accounts and placeholder results.

- **One required list accepts 1–1,000 handles, @handles, or canonical HTTPS X/Twitter profile URLs.**
- **Every retained row matches the requested normalized handle and can expose 35 business fields plus three processing fields.**
- **Unavailable or mismatched accounts produce no Dataset placeholder and no Profile Result charge.**
- **Avatar and banner references remain only after their images are validated and stored successfully.**

[**Run a NASA profile test**](https://apify.com/truefetch/x-user-profile) · [**View the API**](https://apify.com/truefetch/x-user-profile/api)

The smallest successful FREE-tier test costs $0.01 for Actor Start plus $0.00300 for one Profile Result, or **$0.01300 total**.

### What does 𝕏(twitter) User Profile do?

𝕏(twitter) User Profile resolves known public X accounts into timestamped profile snapshots. A successful row can include numeric and screen-name identity, display name, bio, public location, account dates, verification labels, affiliate label, public counters, professional category, source-reported account flags, profile and bio links, pinned-post context, first-seen posting-source labels, stored imagery, and processing provenance.

The contract is deliberately based on handles rather than discovery. It does not search for a person by display name, bio, email, company, location, or keyword. It does not return follower or following lists, a full post archive, replies, direct messages, private fields, or contact details. A workflow must already know which account it wants to inspect.

Successful core data is not discarded merely because the optional recent-timeline request fails. Conversely, a response whose returned handle does not match the requested normalized handle is rejected. This distinction protects valid profile rows while preventing a technically valid but wrong account from being labeled as the requested user.

### How do I run 𝕏(twitter) User Profile?

𝕏(twitter) User Profile needs one `usernames` array containing at least one usable public handle.

1. Open the [Actor input page](https://console.apify.com/actors/NFWpiIrH8lepzKJoL/input).
2. Keep the prefilled `NASA` handle or replace it with a known account.
3. Start the run and wait for ready, unavailable, and failed counts.
4. Inspect the default Dataset count independently of the submitted list length.
5. Preserve the run ID, Dataset ID, `user_id`, `user_name`, and `processed_at` with downstream records.

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

Use one known account for the first test. After confirming the schema and current billing, expand to a representative list. Repeating the same handle in different letter cases does not create duplicate work because normalization is case-insensitive.

### What data does 𝕏(twitter) User Profile return?

𝕏(twitter) User Profile returns one sparse Dataset item per successfully resolved identity, with up to 38 top-level fields.

| Group | Fields | Purpose |
| --- | --- | --- |
| Identity | `user_id`, `user_name`, `display_name`, `description`, `location` | Public account identity and self-presented context |
| Labels | `verified`, `blue_verified`, `verified_type`, `verified_at`, `affiliate_label` | Source-reported verification and affiliation signals |
| Counts | `followers_count`, `following_count`, `statuses_count`, `favourites_count`, `listed_count`, `media_count` | Point-in-time public metrics |
| Account | `created_at`, `protected`, `sensitive`, `account_type`, `account_category`, `creator_subscriptions`, `business_affiliates`, `highlighted_tweets` | Account attributes returned by the source |
| Links/media | `profile_urls`, `description_urls`, `avatar_url`, `banner_url` | Public links and stored images |
| Timeline | `pinned_tweet`, `pinned_tweet_ids`, `posting_sources` | Available pinned context and sampled source labels |
| Other | `birthdate`, `profile_language`, `custom_timelines`, `default_profile` | Sparse source-dependent details |
| Processing | `status`, `processor`, `processed_at` | Result status, producing Actor, and observation time |

The example is abbreviated. A real result can contain up to 38 top-level keys, and nested `pinned_tweet` keys depend on the available public post.

```json
{
  "user_id":"11348282",
  "user_name":"NASA",
  "display_name":"NASA",
  "description":"There's space for everybody.",
  "followers_count":92268545,
  "blue_verified":true,
  "status":"success",
  "processor":"https://apify.com/truefetch/x-user-profile",
  "processed_at":"2026-08-12T19:00:00+00:00"
}
```

An absent key means it was not retained from that response. It is not evidence that the real-world value is zero or permanently missing. False booleans and zero counters remain when the source explicitly reports them because those states can be meaningful.

### What inputs can I configure?

𝕏(twitter) User Profile exposes exactly one required property and no hidden filter.

| Input | Type | Required | Range | Accepted form |
| --- | --- | --- | --- | --- |
| `usernames` | array of strings | Yes | 1–1,000 items | Handle, @handle, or exact HTTPS X/Twitter one-segment profile URL |

A handle contains 1–15 letters, digits, or underscores. A URL must use HTTPS, an exact `x.com` or `twitter.com` host, no credentials, no custom port, and exactly one path segment. Post, list, search, and foreign URLs do not match the contract.

The runtime strips one leading `@`, normalizes case, and removes duplicates while preserving first-seen order. It does not accept numeric user IDs, display-name queries, cookies, X credentials, result limits, follower thresholds, location constraints, language filters, or date windows.

### What platforms and markets does 𝕏(twitter) User Profile cover?

𝕏(twitter) User Profile covers public accounts on X that can be identified by a current handle or X/Twitter profile URL. There is no country, language, profession, account-type, or market selector, so coverage must not be interpreted as a geographic or demographic guarantee.

Public bios, locations, names, and pinned posts can use any language returned by the source. `profile_language` is a source-reported value when present; it is not a language analysis performed by this Actor. Consumers remain responsible for translation and regional interpretation.

Protected accounts can expose public profile metadata while restricting post access. Suspended, unavailable, incomplete, or identity-mismatched accounts produce no row. X controls visibility and availability, so the same list can yield different results over time.

### Why use 𝕏(twitter) User Profile?

𝕏(twitter) User Profile replaces repeated manual copying with a stable input contract, sparse JSON, source identity checks, timestamps, Dataset exports, and repeatable billing. It is especially useful when a workflow already has a list of known handles and needs comparable public account observations.

Partial batch handling preserves useful work. One unavailable account does not remove other valid profiles, and only unresolved handles advance to another request route. Optional pinned-timeline failure leaves the identity-valid core profile intact.

The Actor also separates media success from profile success. Avatar and banner links are rewritten only after validated storage; a failed image is removed without erasing the text profile. This keeps the output from retaining temporary source media URLs that were never stored.

### Who is 𝕏(twitter) User Profile for?

**Researchers** can compare public identity, bio, links, labels, counts, and pinned context across a selected panel while preserving collection time.

**Creator and partnership teams** can qualify known accounts before human review. The fields provide context, not consent, authenticity, affiliation, or permission to contact someone.

**Data engineers** can normalize handle lists, export successful rows, and join by `user_id` or normalized `user_name` while keeping sparse-field semantics explicit.

**Monitoring teams** can schedule repeated observations and watch directional changes in bios, counts, categories, links, or pinned posts. Historical storage and interpretation belong downstream.

**Quality teams** can distinguish invalid input, unavailable identity, optional field absence, media failure, and integration failure instead of treating every empty outcome as the same problem.

### How can I use 𝕏(twitter) User Profile through the API or MCP?

𝕏(twitter) User Profile uses Actor ID `NFWpiIrH8lepzKJoL`; the equivalent name is `truefetch/x-user-profile`.

```bash
curl -X POST "https://api.apify.com/v2/acts/NFWpiIrH8lepzKJoL/runs?token=$APIFY_TOKEN" -H "Content-Type: application/json" -d '{"usernames":["NASA"]}'
```

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("NFWpiIrH8lepzKJoL").call(run_input={"usernames": ["NASA"]})
items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('NFWpiIrH8lepzKJoL').call({ usernames: ['NASA'] });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

For MCP, connect the official Apify MCP server, refresh tool discovery, select `truefetch/x-user-profile`, and pass the same `{"usernames":["NASA"]}` object. Keep tokens in secrets and poll the returned run ID if a client-side wait expires.

### How much does 𝕏(twitter) User Profile cost?

𝕏(twitter) User Profile costs $0.00300 per saved Profile Result on FREE plus $0.01 Actor Start; the smallest successful run costs $0.01300.

| Event | FREE | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| Actor Start | $0.01000 | $0.01000 | $0.01000 | $0.01000 | $0.01000 | $0.01000 |
| Profile Result | $0.00300 | $0.00270 | $0.00240 | $0.00225 | $0.00225 | $0.00225 |

Actor Start is charged once per run. Profile Result repeats only after successful Dataset persistence. The smallest FREE calculation is `$0.01 + $0.00300 = $0.01300`; an unavailable account has no Result event. Prices can change, so verify the live [pricing page](https://apify.com/truefetch/x-user-profile/pricing).

### How does 𝕏(twitter) User Profile compare with alternatives?

𝕏(twitter) User Profile is appropriate for repeatable lookup of known handles with a 38-field sparse contract. Manual browsing is preferable when one consequential profile needs immediate visual and post context. A user-search product is needed when the account is unknown and discovery starts from a name, keyword, or bio.

X provides official authenticated [User Lookup](https://docs.x.com/x-api/users/lookup/introduction) endpoints. Choose them when an approved developer account, the official API policy and quota contract, or specific official fields are required. This Actor is independent and not affiliated with X.

Choose another product for full timelines, replies, follower/following lists, contact discovery, private data, DMs, account actions, or engagement predictions. This Actor returns public profile observations, not a relationship graph or identity-verification service.

### What are the limits and troubleshooting steps?

𝕏(twitter) User Profile can return fewer rows than inputs because invalid and duplicate values normalize away, while unavailable, incomplete, and mismatched accounts do not create placeholders.

- Confirm a 1–15 character handle or exact HTTPS one-segment profile URL.
- Open the profile manually and inspect ready, unavailable, and failed terminal counts.
- Treat a missing optional key as unobserved rather than factual zero.
- Retain the valid text profile when an avatar or banner is absent.
- Remember that `posting_sources` is sampled, not a complete device history.
- Poll an existing run after client wait expiry instead of creating a duplicate.
- Test a representative subset before sending the 1,000-item ceiling.

For support, provide the run ID, redacted input, terminal status, Dataset count, observed key set, and expected behavior. Never send credentials, tokens, private Datasets, or unrelated personal data.

### Frequently asked questions

#### How do I scrape a public X user profile by handle?

Place the handle in `usernames`. A successful identity match creates one sparse profile row with the available public fields.

#### Can I submit Twitter profile URLs and @handles together?

Yes. Both normalize to case-insensitive handles, and duplicates are removed in first-seen order.

#### Does the scraper return every post, follower, or followed account?

No. It returns profile context and available pinned-post data, not full timelines or relationship lists.

#### Is there a free Twitter profile API?

This Actor is pay per event. The current smallest successful FREE-tier test is $0.01300 rather than a promise of permanently free access.

#### Can I schedule runs to monitor X profiles over time?

Yes. Retain `processed_at` and your historical rows, then interpret changes cautiously because source values and availability can move.

#### Why did a valid-looking handle produce no row?

The account may be unavailable, incomplete, renamed, or returned under a different identity. The Actor omits it rather than emitting a misleading placeholder.

### Related TrueFetch Actors

𝕏(twitter) User Profile pairs with exactly three TrueFetch products when a workflow expands from one account type to another public entity.

- **[X Twitter Community Scraper](https://apify.com/truefetch/x-twitter-community-scraper)** — resolve selected public X Communities under a separate contract.
- **[Instagram Profile API](https://apify.com/truefetch/instagram-profile-api)** — enrich a known Instagram account with platform-specific fields.
- **[LinkedIn Profile API](https://apify.com/truefetch/linkedin-profile-api)** — resolve one known public LinkedIn member URL.

Review each Actor's inputs, fields, billing unit, and source boundary before combining records.

### Support

𝕏(twitter) User Profile support covers handle validation, unavailable identities, sparse fields, pinned context, Result billing, Dataset access, and API or MCP integration in the [TrueFetch Telegram group](https://t.me/TrueFetch).

Include the run ID, redacted input, terminal message, Dataset item count, observed keys, and expected behavior. Do not send tokens, credentials, private Dataset content, or unrelated personal information.

[**Run a NASA profile test**](https://apify.com/truefetch/x-user-profile) · [**View the API**](https://apify.com/truefetch/x-user-profile/api)

**Last Updated:** August 12, 2026

# Actor input Schema

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

Provide 1 to 1,000 X handles, @handles, or exact HTTPS profile URLs for public account extraction. Only successfully resolved profiles create Dataset items.

## Actor input object example

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

# Actor output Schema

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

Open successfully resolved public profile rows in the default Dataset. Each row exposes up to 38 sparse top-level fields.

# 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": [
        "NASA"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/x-user-profile").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": ["NASA"] }

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

```

## MCP server setup

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

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/NFWpiIrH8lepzKJoL/builds/zrJ8iTiaaTvRaXILv/openapi.json