Twitter X Posts Scraper (Media & Link Extraction)

Twitter X Posts Scraper — Extract Posts, Media and Outbound Links

Twitter X Posts Scraper (Media & Link Extraction) pulls recent posts from any public X (Twitter) profile and extracts every image, every video bitrate variant, poster-supplied alt text, and every in-text link resolved from its shortened t.co form to its real destination — all as typed JSON, no HTML to parse. Point it at a username, handle, profile URL, or numeric user ID and it returns each post's text, engagement counts, and author profile fields alongside a full media and outbound-link breakdown, running logged out with no cookies or account required. Filter to media-only posts, sort by recency or engagement, and pipe structured rows straight into an app, spreadsheet, or AI pipeline.

What is Twitter X Posts Scraper (Media & Link Extraction)?

Twitter X Posts Scraper (Media & Link Extraction) is an Apify Actor that scrapes recent posts from one or more X (Twitter) profiles and returns a media- and link-complete version of every post: the base post and author fields, plus every photo, every MP4 variant of every video and GIF, image alt text, and every outbound link already expanded from t.co to its real destination. It works logged out — no X account, password, or cookie is required, and no MCP server is exposed for it.

• Scrape recent posts from any public profile, handle, or numeric user ID
• Extract every photo and every video/GIF bitrate variant per post, not just the first
• Resolve every in-text t.co link to its real destination and display URL
• Filter to media-only posts, or sort by recent, oldest, or most-liked
• Export as JSON or CSV, or pull rows through the Apify API

Whether you're calling it a Twitter media scraper, an X video URL extractor, or a Twitter link-extraction tool, the job is the same one this Actor does: turn a profile's post history into structured rows where the media and every outbound link are already resolved fields, not something you re-derive from HTML or a raw t.co redirect.

What data does Twitter X Posts Scraper collect? 🖼️

Each saved row is a single post, but that post carries three distinct blocks of data: the post itself, the author's profile as it stood at fetch time, and a full media/link breakdown extracted from the same response — no second request needed.

Data Type	Key Fields	JSON Field Names
Posts	text, engagement counts, timestamp, permalink	description, likes, replies, reposts, quotes, views, bookmarks, date_posted, url
Author profiles	handle, display name, bio, verification, follower/following counts	user_posted, name, biography, is_verified, followers, following, posts_count, profile_image_link
Media & links	every image + alt text, every video variant, resolved outbound links, media summary	allPhotos, allVideos, outboundLinks, mediaCount, hasMedia

Quote-tweets add a fourth, nested block: quoted_post, carrying the quoted post's text, ID, and quoting author — documented in full under Output below.

What's accessible	What's not
Public post text, engagement counts, timestamp	Direct messages, drafts, or scheduled-not-yet-posted content
All images and video/GIF variants attached to a public post	Media attached to protected/private-account posts
Author's public profile fields (bio, follower count, avatar, verification)	Analytics-only metrics X shows solely to the account owner (e.g. impression breakdowns)
In-text links already expanded by X to their real destination	X's own link-preview "card" title/description text (not parsed as a field)

Need more X data?

If you also need to see what's trending on X by location, or want the reply thread under a post — including a verified-only filter — API Empire runs companion Actors for that: Twitter Trends Scraper & Country List Per Trend and Twitter X Reply Scraper By Verified & Engagement Filter. X Twitter Posts Search & Post Replies combines keyword/post search with its own reply-thread capture in a single run.

Why not build this yourself?

X does publish an official API, but building and running your own scraper against X's logged-out surface — which is what this Actor uses — is a different, ongoing engineering problem, not a one-time script.

X's guest (logged-out) API requires two tokens the site issues dynamically: a guest bearer authorization header and an x-guest-token, both emitted only when a real browser loads x.com. Getting them means running headless Chromium, capturing the tokens off live network traffic, and refreshing them per run — Playwright, in this Actor's case. Resolving a username to its numeric user ID additionally needs a current GraphQL operation hash (queryId) that X rotates without notice; a DIY script has to harvest it from X's own JS bundles or keep a fallback list current by hand. On top of that, X's REST endpoints sit behind a TLS fingerprint check that a plain HTTP client fails outright, so requests need browser-accurate TLS impersonation (this Actor uses curl_cffi with Chrome impersonation) just to get a 200 back.

None of that is a one-time cost. Query hashes rotate, guest-token issuance changes, and TLS fingerprinting gets stricter — each is a maintenance burden that falls on you with a DIY script, and on the Actor's maintainer here instead. There's also an infrastructure floor before any of that logic runs at all: a working headless-Chromium install (Playwright plus its browser binaries) just to harvest tokens, kept current as browser versions and X's own bot heuristics move — overhead a hosted Actor absorbs for you.

Why do developers and teams scrape X posts for media and links?

For AI engineers and agent builders

allPhotos, allVideos, and outboundLinks give an agent a ready-made media and citation graph for a profile without a browser render step. A RAG pipeline can index description alongside outboundLinks[].url to ground an agent's answers about what a brand or account actually linked to, while mediaCount and hasMedia let a tool call cheaply skip text-only posts before spending a vision-model call on an image.

For marketers and brand teams

mediaOnly: true plus sortOrder: "popular" turns a profile scan into a ranked feed of a competitor's or your own account's best-performing visual content, with likes, reposts, and views attached to every row. Pulling allPhotos[].altText also surfaces exactly which images a brand described for accessibility — useful for auditing a competitor's content-ops discipline, not just their creative.

For researchers and analysts

Because the Actor runs logged out and returns only what X already serves to an anonymous visitor, it fits public-data research on posting behavior, link-sharing patterns, and media use across accounts. outboundLinks gives a clean, already-expanded dataset of what an account actually links out to, and hashtags and tagged_users give a light co-occurrence signal for topic or network studies — no manual t.co unshortening step before analysis, and no browser automation to maintain on your end.

For developers building data products

id, url, and date_posted on every row make it straightforward to build an append-only pipeline — schedule the Actor, dedupe on id, and keep a rolling archive of a set of profiles' media and link activity without maintaining your own X client, token harvester, or TLS-impersonation layer.

How to scrape X posts (step by step)

1. Open Twitter X Posts Scraper (Media & Link Extraction) on the Apify Store and click Try for free
2. Add one or more accounts to startUrls — a username, @handle, full profile URL, or numeric user ID, one per line
3. Toggle extractAllMedia, includeAltText, extractOutboundLinks, and mediaOnly to match what you need — all default on except mediaOnly
4. Click Start and let the run finish
5. Download results as JSON or CSV from the dataset, or pull them through the Apify API

What to do when X changes its structure

The Actor is maintained, and the output schema — field names and types — stays stable on your end even when X changes its internal page or API structure. No numeric turnaround time is published; treat the schema as the stable contract and the underlying fetch logic as something that gets updated as needed.

⬇️ Input

Parameter	Required	Type	Description	Example Value
startUrls	Yes	array	One handle or profile URL per line — every post from these accounts is scanned for media and links. Accepts https://x.com/username, username or @username, or a numeric user ID.	["natgeo", "https://x.com/NASA", "@SpaceX"]
extractAllMedia	No	boolean	Capture every image on a post (not just the first) plus every MP4 bitrate variant of each video/GIF. Populates allPhotos[] and allVideos[]. Default true.	true
includeAltText	No	boolean	Attach the poster-supplied accessibility alt text to each image in allPhotos[].altText. Null when the poster set none. Default true.	true
extractOutboundLinks	No	boolean	Expand every in-text t.co short link to its real destination URL in outboundLinks[], with the display URL X shows. Default true.	true
mediaOnly	No	boolean	Live filter — drop text-only posts and return only posts carrying at least one photo, video, or GIF. Default false.	false
sortOrder	No	string	Order posts before saving. Enum: recent (newest first), oldest (oldest first), popular (most liked first). Default recent.	"recent"
maxTweets	No	integer	Upper limit of posts to scan per profile. Higher values take longer. Minimum 1, maximum 100. Default 10.	25
proxyConfiguration	No	object	Apify Proxy settings. Default is no proxy (useApifyProxy: false). The Actor is designed to step through datacenter then residential proxy groups if a request fails while a proxy is enabled.	{"useApifyProxy": false}

Example input

{
  "startUrls": ["natgeo", "https://x.com/NASA", "@SpaceX"],
  "extractAllMedia": true,
  "includeAltText": true,
  "extractOutboundLinks": true,
  "mediaOnly": false,
  "sortOrder": "recent",
  "maxTweets": 25,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}

Common pitfall: startUrls accepts usernames, handles, profile URLs, and numeric user IDs — but not a direct post/status URL (https://x.com/user/status/12345). A status URL is detected and skipped with a log warning instead of being scraped; provide the author's username or profile URL to get their posts instead. Also note mediaOnly filters after fetching up to maxTweets posts, so a media-heavy mediaOnly: true run can return fewer rows than maxTweets if some fetched posts were text-only.

⬆️ Output

Every result is one typed JSON row per post, exported as JSON or CSV, or read straight from the dataset through the Apify API. The dataset's default view — 30 columns — is the complete row; nothing is pushed that isn't shown in the view for this Actor. Each row is charged once as the row_result event when it is saved; there are no separate uncharged status or error rows to filter out.

If you export to CSV, nested fields — quoted_post, allPhotos, allVideos, and outboundLinks — come through as a JSON-encoded string in their column rather than separate columns, which is standard Apify dataset-to-CSV behavior for any array or object field. Use the JSON export, or the Apify API/apify_client, if you need those nested structures parsed rather than stringified.

Scraped post

{
  "id": "1834829102938471234",
  "url": "https://x.com/natgeo/status/1834829102938471234",
  "user_posted": "natgeo",
  "name": "National Geographic",
  "description": "A humpback whale breaches off the coast of Alaska — see the full gallery https://t.co/aBcDeFghij",
  "date_posted": "2026-07-20T14:32:05.000Z",
  "likes": 18420,
  "replies": 312,
  "reposts": 2104,
  "quotes": 87,
  "views": "412903",
  "bookmarks": 963,
  "is_verified": true,
  "followers": 29800000,
  "following": 214,
  "posts_count": 48210,
  "profile_image_link": "https://pbs.twimg.com/profile_images/1234567890/natgeo_normal.jpg",
  "biography": "Taking the world's photo album since 1888. 📷🌍",
  "hashtags": ["Wildlife", "Alaska"],
  "tagged_users": null,
  "photos": "https://pbs.twimg.com/media/F1a2B3c4D5e_orig.jpg",
  "videos": null,
  "quoted_post": {
    "data_posted": null,
    "description": null,
    "post_id": null,
    "profile_id": null,
    "profile_name": null,
    "url": null,
    "videos": null
  },
  "external_url": "https://natgeo.com",
  "input": {
    "url": "https://x.com/natgeo/status/1834829102938471234/"
  },
  "allPhotos": [
    {
      "url": "https://pbs.twimg.com/media/F1a2B3c4D5e_orig.jpg",
      "altText": "A humpback whale breaching, seen from a boat off the Alaskan coast."
    },
    {
      "url": "https://pbs.twimg.com/media/F1a2B3c4D5f_orig.jpg",
      "altText": null
    }
  ],
  "allVideos": [],
  "outboundLinks": [
    {
      "url": "https://www.natgeo.com/animals/gallery/humpback-whales-alaska",
      "displayUrl": "natgeo.com/animals/galler…"
    }
  ],
  "mediaCount": 2,
  "hasMedia": true
}

Field notes:

• photos and videos are the base fields — photos is only the first photo's URL (or null), and videos is the base MP4 URL list sorted highest-bitrate-first (or null). Use allPhotos / allVideos for the complete set.
• hashtags and tagged_users come back as null, not [], when a post has none — check for null rather than array length.
• views is returned as the string X's API supplies (e.g. "412903"), not a number.
• external_url is the author's bio link, not a link from inside this specific post — post-level links live in outboundLinks.
• input.url holds this specific post's own permalink, constructed by the Actor — it is not the startUrls entry you originally supplied.
• quoted_post.data_posted is spelled exactly that way (not date_posted) — the field name is carried over unchanged from the base Actor's schema and preserved here for compatibility with existing integrations.
• quoted_post.url and quoted_post.videos are always null in the current build, even when a post quotes another post with a URL or video — the quoted post's ID, text, and author are populated, but its own URL and video list are not currently filled in.
• allPhotos and allVideos are always [] when extractAllMedia is false; outboundLinks is always [] when extractOutboundLinks is false; altText is always null when includeAltText is false.
• allVideos[].bitrate is null for animated GIFs — X serves GIF variants without a declared bitrate — and allVideos[].type is "video" or "animated_gif".

A post with video and a quote-tweet

Video posts and quote-tweets shape the same 30 fields differently — photos/allPhotos stay empty, videos/allVideos populate, and quoted_post fills in when the post quotes another one:

{
  "id": "1839221004471234567",
  "url": "https://x.com/nasa/status/1839221004471234567",
  "user_posted": "NASA",
  "name": "NASA",
  "description": "Watch the booster separation in real time 🚀 https://t.co/xYzAbC1234",
  "date_posted": "2026-07-18T09:05:41.000Z",
  "likes": 54210,
  "replies": 1890,
  "reposts": 9320,
  "quotes": 640,
  "views": "2104883",
  "bookmarks": 3410,
  "is_verified": true,
  "followers": 96500000,
  "following": 428,
  "posts_count": 71230,
  "profile_image_link": "https://pbs.twimg.com/profile_images/0987654321/nasa_normal.jpg",
  "biography": "Explore the universe and discover our home planet.",
  "hashtags": null,
  "tagged_users": ["SpaceX"],
  "photos": null,
  "videos": [
    "https://video.twimg.com/ext_tw_video/1839221004471234567/pu/vid/1280x720/high.mp4",
    "https://video.twimg.com/ext_tw_video/1839221004471234567/pu/vid/640x360/low.mp4"
  ],
  "quoted_post": {
    "data_posted": "2026-07-18T08:40:12.000Z",
    "description": "Liftoff confirmed. All systems nominal.",
    "post_id": "1839218881239001234",
    "profile_id": "34743251",
    "profile_name": "SpaceX",
    "url": null,
    "videos": null
  },
  "external_url": "https://nasa.gov",
  "input": {
    "url": "https://x.com/NASA/status/1839221004471234567/"
  },
  "allPhotos": [],
  "allVideos": [
    {
      "url": "https://video.twimg.com/ext_tw_video/1839221004471234567/pu/vid/1280x720/high.mp4",
      "bitrate": 2176000,
      "type": "video"
    },
    {
      "url": "https://video.twimg.com/ext_tw_video/1839221004471234567/pu/vid/640x360/low.mp4",
      "bitrate": 832000,
      "type": "video"
    }
  ],
  "outboundLinks": [],
  "mediaCount": 1,
  "hasMedia": true
}

Here description still shows the raw https://t.co/xYzAbC1234 because that particular short link points at the attached video itself rather than an external page — X doesn't emit a matching entities.urls entry for it, so outboundLinks stays empty even though extractOutboundLinks is on. outboundLinks only fills for links to pages outside the post's own media.

How does Twitter X Posts Scraper extract media and links?

All of it comes from the same logged-out UserTweets GraphQL response the Actor already fetches to get post text and engagement counts — media and link extraction adds zero extra HTTP requests per post.

• Images: every entry in the post's extended_entities.media array with type: "photo" is captured, using each entry's media_url_https. includeAltText additionally reads ext_alt_text off each image — null when the poster didn't set one, never guessed or filled in.
• Videos and GIFs: for every media entry typed video or animated_gif, every variant in video_info.variants with content_type: "video/mp4" is kept, with its bitrate and the parent type (video vs animated_gif). Non-MP4 variants (X also lists an .m3u8 manifest) are not included.
• Outbound links: only in-text hyperlinks the post's own entities.urls array lists are resolved — each entry already carries an expanded_url (the real destination) and a display_url (what X shows in the post) straight from X's response, so the Actor reads them rather than making its own unshortening request. t.co links that point at the post's own attached image or video (not an external page) don't appear in entities.urls at all, so they're correctly absent from outboundLinks.
• Not extracted: X's link-preview "cards" — the title/description/thumbnail summary X sometimes renders under a shared article link — are not parsed into a separate field. If a shared link also renders a card, only the link itself (via outboundLinks) and any of its own image/video (if the card happens to be classified as post media) are captured, not the card's title or description text.

How does Twitter X Posts Scraper compare to other X scrapers?

Feature	Twitter X Posts Scraper (Media & Link Extraction)	Generic alternative
Every image + every video bitrate variant per post	✅ allPhotos[] / allVideos[] on every row	Usually one thumbnail or a single media URL only
Image alt text	✅ includeAltText toggle, allPhotos[].altText	Not documented on the two lowest-priced X media scrapers checked on the Apify Store, 2026-07-25
Outbound link resolution	✅ outboundLinks[] with expanded + display URL, no extra request	Not offered as a distinct field on the listings checked
Export formats	✅ JSON, CSV	contactminerlabs's Twitter (X) Media Posts Scraper – Cheap listing advertises JSON, CSV, Excel, and XML/HTML export, checked on the Apify Store 2026-07-25 — not verified here
Pricing model	✅ Pay-per-result (row_result event), no subscription	contactminerlabs's listing advertises a flat $14.89/month subscription, checked on the Apify Store 2026-07-25

If you're building an AI agent or RAG pipeline, the output format row is the decision-maker — parsing a thumbnail URL or scraped HTML inside an agent loop is a reliability failure mode, not a feature.

How many posts can you scrape with Twitter X Posts Scraper?

maxTweets caps posts scraped per profile at a minimum of 1 and a maximum of 100, defaulting to 10 — set it once and it applies to every entry in startUrls. Under the hood, posts are fetched in pages of up to 20 per request (min(20, maxTweets)) via X's cursor-based pagination: each request passes the previous page's bottom cursor, and the loop stops as soon as either maxTweets is reached or X stops returning a next-page cursor — whichever comes first. If mediaOnly is enabled, filtering happens after this loop finishes, on the already-fetched batch, so it can never pull in extra pages to compensate for text-only posts that get filtered out. There is no separate cap on how many profiles you can list in startUrls — each is processed in turn, in the order supplied. No benchmark run time is published; actual duration depends on how many profiles you list and how many posts you request per profile.

Integrate Twitter X Posts Scraper and automate your workflow

Twitter X Posts Scraper (Media & Link Extraction) works with any language or tool that can send an HTTP request, since it runs as a standard Apify Actor.

REST API integration

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("<YOUR_USERNAME>/twitter-x-posts-scraper-media-link-extraction").call(run_input={
    "startUrls": ["natgeo", "@NASA"],
    "extractAllMedia": True,
    "extractOutboundLinks": True,
    "mediaOnly": True,
    "maxTweets": 25,
})

for post in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(post["user_posted"], post["mediaCount"], len(post["outboundLinks"]))

Works in Python, Node.js, Go, Ruby, cURL — any language that can make an HTTP request.

Automation platforms (n8n, Make, LangChain)

In n8n, use the official Apify node (or an HTTP Request node against the Apify run endpoint with your API token) configured with this Actor's ID and the JSON input shown above, then feed dataset output into any downstream node. In Make, the Apify app's "Run Actor" module accepts the same input and can hand the resulting dataset items straight to a Google Sheets or Airtable module. In LangChain, wrap the Apify API call in a custom tool (or use langchain's Apify integration) so an agent can call the Actor mid-chain and receive allPhotos, allVideos, and outboundLinks as structured tool output rather than raw HTML.

Is it legal to scrape X posts and profile data?

Yes — Twitter X Posts Scraper (Media & Link Extraction) only collects data that X already shows to any logged-out visitor on a public profile: post text, engagement counts, media, and the author's public profile fields. Nothing behind a login wall, a private-account gate, or a protected-tweet setting is accessed.

Because the output includes identifiable information about the people posting — handles, display names, bios, profile photos, follower counts — it falls under personal-data regimes like GDPR and CCPA where those apply, even though the source is public. Public availability affects what's technically accessible, not automatically your lawful basis for storing or reusing it. Separately, running automated collection against X also implicates X's own Terms of Service, independent of personal-data law — review the current terms for your use case before scraping at scale. Consult legal counsel before using this data for profiling, marketing outreach, or any other commercial use case involving bulk personal data.

❓ Frequently asked questions

How am I charged for using this Actor?

Twitter X Posts Scraper (Media & Link Extraction) runs on Apify's pay-per-event model with one charged event, row_result — you're billed once for each post row actually saved to the dataset. A profile that can't be resolved, or that returns zero posts (empty account, or every post filtered out by mediaOnly), produces no rows and so incurs no row_result charges for that entry. See the Actor's Pricing tab on its Apify Store page for the current per-result rate and any platform usage charges.

Does Twitter X Posts Scraper work without a Twitter/X account?

Yes. The Actor runs entirely logged out — it harvests its own guest authorization token and guest token from x.com at the start of each run using a headless browser. You don't provide an X username, password, or cookie; the only credential involved is your own Apify account to run the Actor.

How often is the scraped data updated?

Every run fetches live from X at the moment it runs — there is no caching layer. Two runs minutes apart on the same profile can return different engagement counts if the post has picked up new likes, replies, or reposts in between.

What happens if a profile doesn't exist, is private, or has no posts?

If X can't resolve the given handle to a user ID (a suspended, deactivated, or nonexistent account), the Actor logs that it couldn't find a user ID for that entry and moves on to the next one in startUrls — no row is produced for it, and the rest of your batch still runs. Because only guest, logged-out access is used, protected/private accounts behave the same way as accounts with no visible posts: the request returns nothing to extract.

Can I scrape private or protected X accounts?

No. Only content visible to a logged-out visitor is returned — the same data a browser sees on a public profile without signing in. Protected (private) accounts return no posts.

Does Twitter X Posts Scraper work for AI agent workflows and LLM pipelines?

Yes. It's callable as a standard HTTP endpoint through the Apify API, so any agent framework — LangChain, CrewAI, a custom tool definition, n8n — can invoke it and get back typed JSON with no parsing step before passing results into an LLM context window or a vector store.

How does Twitter X Posts Scraper handle X's anti-bot system?

It authenticates as a guest by loading x.com in a headless Chromium browser (Playwright) and capturing the bearer token and guest token X issues to real browser sessions, then makes API calls with curl_cffi using Chrome TLS impersonation to get past X's TLS-fingerprint checks — a plain HTTP client without that impersonation gets challenged before it ever reaches the API. When proxyConfiguration has a proxy enabled, the Actor is built to escalate on a failed request first to an Apify datacenter proxy group, then to a residential proxy group, so a single blocked request doesn't necessarily end the run.

What happens if X rate-limits or blocks a request mid-run?

The Actor logs the failed request and, if a proxy is configured, is built to retry through its datacenter-then-residential proxy escalation described above before giving up on that particular page or profile. If a given profile's posts can't be fetched at all, that profile contributes zero rows to the dataset rather than partial or fabricated data, and the run continues on to the next profile in startUrls.

How does Twitter X Posts Scraper compare to other X scrapers?

Checked on the Apify Store on 2026-07-25, contactminerlabs/twitter-x-media-posts-scraper---cheap targets keyword/hashtag/username search on a flat $14.89/month subscription and returns a flatter field set (tweetId, mediaUrl, thumbnail) without a documented alt-text or link-resolution field. scrapepilot/social-profile-extractor-find-facebook-linkedin-twitter is a different tool entirely — it crawls websites for social profile links, not X posts. This Actor's difference for X specifically is depth per post: every image, every video variant, alt text, and pre-expanded outbound links, on a pay-per-result model.

Does Twitter X Posts Scraper return data in a format LLMs can use directly?

Yes. Every response is typed, normalized JSON with stable field names across runs — no HTML, no selectors, no parsing step. Pass a row directly into an LLM's context window, index it into a vector store, or route it through an agent tool.

Can I use Twitter X Posts Scraper without managing proxies?

Yes. By default the Actor runs with no proxy at all (useApifyProxy: false), using its own guest-token and TLS-impersonation approach to reach X directly. If you do enable proxyConfiguration, the Actor acquires and rotates Apify Proxy URLs itself — you never create or manage a proxy session by hand.

What happens when X changes its structure or blocks the scraper?

The scraper is maintained, and the output schema is designed to stay stable on your end — field names and types don't change just because X changes its internal page or API structure. No specific turnaround time is published for fixes.

Can I schedule this Actor to run automatically?

Yes — this is a standard Apify Actor feature, not something specific to this build. Set up an Apify Schedule against this Actor from the Apify Console (or the API) to run it hourly, daily, or on any cron interval, and optionally trigger a webhook when each run finishes so downstream systems pick up new posts without polling.

💬 Your feedback

Found a bug, or a field X exposes that isn't in the output? We want to know. Open an issue on the Actor's Issues tab in Apify Console with a sample profile or post URL, and it'll be looked at. Field requests backed by a real example (a post URL where the field is visible) are the fastest to act on.