Threads Scraper - Scrape Threads by Meta Posts & Profiles (No Login Required)

Scrape public Threads by Meta profiles and posts without any login, cookies, or API key. This Instagram Threads scraper extracts post text, engagement data (likes, replies, reposts), media URLs, follower counts, and more from any public profile on Meta's Threads platform. Use it for Threads monitoring, Threads analytics, brand tracking, influencer research, and competitive intelligence.

Features

• No login required - Scrape Threads data without any account, cookies, or Meta Threads API key
• Threads profile scraper - Extract display name, bio, follower/following counts, verified status, profile picture, and link in bio
• Threads post scraper - Get full post text, timestamps, media URLs (images, videos, carousels), hashtags, and @mentions
• Threads engagement data - Capture like counts, reply counts, and repost counts for every post
• Search functionality - Search for posts by keyword across all of Threads
• Single post extraction - Scrape any individual Threads post by URL
• Threads monitoring - Schedule recurring runs to track brand mentions and competitor activity
• Threads analytics - Export structured data for engagement rate analysis and content research
• GraphQL interception - Captures Threads' internal API responses for accurate, structured data
• DOM fallback - Automatically falls back to DOM extraction when API interception is unavailable
• Handles pagination - Infinite scroll support to load hundreds of posts per profile
• Anti-detection - Residential proxies and randomized delays to avoid rate limiting

How the Threads Scraper Works

This Threads crawler uses a dual-extraction strategy: it first attempts to intercept Threads' internal GraphQL API responses via Chrome DevTools Protocol, then falls back to DOM parsing if needed. No Meta Threads API access or authentication is required.

flowchart TD
    A[User Input: usernames, URLs, or search query] --> B[Puppeteer launches headless browser]
    B --> C[Navigate to Threads profile/post/search page]
    C --> D{Page loads with React hydration}
    D --> E[CDP Network Listener intercepts GraphQL API responses]
    D --> F[Auto-scroll triggers infinite scroll pagination]
    F --> E
    E --> G{GraphQL data captured?}
    G -->|Yes| H[Parse structured post & profile data from API response]
    G -->|No| I[DOM Fallback: extract data from rendered HTML]
    H --> J[Normalize & format output]
    I --> J
    J --> K[Filter: exclude replies/reposts if configured]
    K --> L[Push to Apify Dataset]
    L --> M[Output: JSON with posts, profiles, engagement metrics]

Scraping Architecture

The Threads data extraction pipeline uses network-level interception combined with browser rendering to reliably scrape Threads without login credentials.

flowchart LR
    subgraph Input
        U[Usernames]
        T[Thread URLs]
        S[Search Query]
    end

    subgraph Browser["Puppeteer Browser Engine"]
        direction TB
        CDP[Chrome DevTools Protocol]
        NI[Network Interceptor]
        CDP --> NI
        NI -->|Captures| GQL[GraphQL / Barcelona API responses]
        RENDER[Page Renderer]
        RENDER -->|If no API data| DOM[DOM Extractor]
    end

    subgraph Processing
        direction TB
        PROFILE[Profile Parser\nname, bio, followers, verified]
        POSTS[Post Parser\ntext, media, timestamps]
        ENGAGE[Engagement Parser\nlikes, replies, reposts]
    end

    subgraph Output
        DS[Apify Dataset]
        API[REST API]
        SHEETS[Google Sheets]
        WEBHOOK[Webhooks]
    end

    U --> Browser
    T --> Browser
    S --> Browser
    GQL --> Processing
    DOM --> Processing
    Processing --> DS
    DS --> API
    DS --> SHEETS
    DS --> WEBHOOK

Use Cases

• Social media monitoring - Track what's being said about your brand on Threads
• Influencer analysis - Evaluate influencer reach, engagement rates, and content quality on Threads
• Competitive intelligence - Monitor competitor activity and messaging on Meta Threads
• Content research - Find trending topics, hashtags, and content formats
• Brand tracking - Monitor brand mentions across multiple Threads profiles
• Market research - Understand audience sentiment and engagement patterns
• Threads analytics dashboard - Feed scraped data into BI tools for visualization
• Lead generation - Discover active accounts in your niche on Threads by Meta

Input

Field	Type	Default	Description
usernames	Array of strings	[]	Threads usernames to scrape (without @). Example: ["zuck", "instagram"]
threadUrls	Array of strings	[]	Direct URLs to specific Threads posts
searchQuery	String	""	Search for posts containing this text
maxPosts	Integer	50	Maximum posts to scrape per user (1-1000)
includeReplies	Boolean	false	Include reply posts in results
includeReposts	Boolean	false	Include reposted content in results
proxyConfiguration	Object	Apify Residential	Proxy settings

Input Example - Scrape Threads Profiles

{
    "usernames": ["zuck", "instagram"],
    "maxPosts": 100,
    "includeReplies": false,
    "includeReposts": false
}

Input Example - Search Threads Posts

{
    "searchQuery": "artificial intelligence",
    "maxPosts": 50
}

Input Example - Scrape a Single Threads Post

{
    "threadUrls": ["https://www.threads.net/@zuck/post/ABC123"]
}

Output

The Threads scraper outputs two types of records to the default dataset:

Profile Data

{
    "type": "profile",
    "username": "zuck",
    "displayName": "Mark Zuckerberg",
    "bio": "Building the future of social connection.",
    "followerCount": 12500000,
    "followingCount": 450,
    "profilePicUrl": "https://...",
    "isVerified": true,
    "linkInBio": "https://about.meta.com",
    "profileUrl": "https://www.threads.net/@zuck",
    "scrapedAt": "2026-03-12T10:00:00.000Z"
}

Post Data

{
    "type": "post",
    "username": "zuck",
    "postText": "Excited about the future of AI and open source.",
    "postUrl": "https://www.threads.net/@zuck/post/ABC123",
    "postedAt": "2026-03-11T15:30:00.000Z",
    "likeCount": 45000,
    "replyCount": 2300,
    "repostCount": 1200,
    "mediaUrls": ["https://..."],
    "mediaType": "image",
    "hashtags": ["#AI"],
    "mentions": ["@meta"],
    "quotedPost": null,
    "isReply": false,
    "isRepost": false,
    "scrapedAt": "2026-03-12T10:00:00.000Z"
}

Output Fields Reference

Field	Type	Description
type	String	Either "profile" or "post"
username	String	Threads username
displayName	String	Display name (profile only)
bio	String	Profile bio (profile only)
followerCount	Number	Follower count (profile only)
followingCount	Number	Following count (profile only)
profilePicUrl	String	Profile picture URL (profile only)
isVerified	Boolean	Whether the account has a verified badge (profile only)
linkInBio	String	Link in bio (profile only)
postText	String	Full text content of the post
postUrl	String	Direct URL to the post
postedAt	String	ISO 8601 timestamp of when the post was created
likeCount	Number	Number of likes
replyCount	Number	Number of replies
repostCount	Number	Number of reposts/shares
mediaUrls	Array	URLs of attached images or videos
mediaType	String	Type of media: "text", "image", "video", or "carousel"
hashtags	Array	Hashtags found in the post text
mentions	Array	@mentions found in the post text
quotedPost	Object	Info about a quoted post (if any)
isReply	Boolean	Whether this post is a reply
isRepost	Boolean	Whether this post is a repost
scrapedAt	String	ISO 8601 timestamp of when the data was scraped

How It Works - Step by Step

1. Page rendering - Uses Puppeteer to render Threads pages (the React app requires JavaScript execution)
2. GraphQL interception - Captures Threads' internal Barcelona/GraphQL API responses via Chrome DevTools Protocol for reliable, structured data
3. DOM fallback - Falls back to DOM extraction if API interception doesn't capture sufficient data
4. Pagination - Automatically scrolls to load more posts via infinite scroll
5. Rate limiting - Randomized delays (3-6 seconds) between requests to avoid detection and respect Threads' servers

Pricing

This Threads scraper uses pay-per-event pricing:

• $0.004 per post scraped (profile data is included free with each username)
• No charge for failed or skipped requests
• Try it free on the Apify platform

Integrations

Connect this Threads data extraction tool with your existing workflow:

• Google Sheets - Export Threads posts and profiles directly to a spreadsheet
• Slack / Discord - Set up notifications for new Threads posts from monitored profiles
• Zapier / Make - Connect to 1000+ apps for automated Threads monitoring workflows
• REST API - Access results programmatically via the Apify API
• Webhooks - Get notified when a scraping run completes
• Python / Node.js - Use the Apify client libraries to integrate Threads data into your application

Limitations

• Public profiles only - Private Threads profiles are detected and skipped with a warning
• No login required - This means the scraper can only access publicly available Threads data
• Rate limits - Threads may temporarily block requests if too many are made; the actor uses residential proxies and randomized delays to minimize this
• Search - Threads search functionality may return limited results compared to direct profile scraping

Tips for Best Results

1. Start small - Test with a single username and 10-20 posts before scaling up
2. Use residential proxies - The default configuration uses Apify residential proxies for best reliability
3. Respect rate limits - Avoid scraping the same Threads profile too frequently
4. Filter by type - Use includeReplies and includeReposts to get exactly the data you need
5. Schedule runs - Set up recurring runs for ongoing Threads monitoring and analytics
6. Export to Sheets - Use the Google Sheets integration for quick Threads engagement data analysis

FAQ

Is a Threads account or Meta Threads API key required?

No. This Threads scraper works without any login, cookies, or API key. It only accesses publicly available data on threads.net.

Can I scrape private Threads profiles?

No. The scraper only extracts data from public Threads profiles. Private profiles are automatically detected and skipped.

How much does it cost to scrape Threads?

The Threads scraper charges $0.004 per post scraped. Profile data is included free. There is no charge for failed requests. For example, scraping 1,000 posts costs $4.00.

Can I use this for Threads monitoring and analytics?

Yes. Schedule recurring runs on Apify to continuously monitor Threads profiles and track engagement data over time. Export results to Google Sheets or your analytics platform via the API.

How does the scraper handle Threads' anti-bot measures?

The scraper uses residential proxies, randomized delays between requests, and realistic browser fingerprints. It renders pages with Puppeteer (a real Chromium browser) and intercepts data at the network level, making it difficult to distinguish from normal browsing.

What is the difference between GraphQL interception and DOM fallback?

GraphQL interception captures the raw API responses that Threads sends to the browser, providing the most accurate and complete data (exact like counts, timestamps, media URLs). DOM fallback parses the rendered HTML directly, which works when API interception is unavailable but may yield less precise engagement counts.

Can I scrape Threads search results?

Yes. Use the searchQuery input field to search for posts containing specific keywords across all of Threads. Results include the same post data fields as profile scraping.

How many Threads posts can I scrape at once?

You can scrape up to 1,000 posts per profile in a single run. For large-scale Threads data extraction, run the scraper across multiple profiles.

Does this work as a Meta Threads API alternative?

Yes. Since Meta does not offer a public Threads API for data extraction, this scraper serves as a reliable alternative for accessing Threads post data, profile information, and engagement metrics programmatically.

Related Tools

If you need scrapers for other platforms, check out these tools by the same developer:

• Google Scholar Scraper - Scrape academic papers, citations, and author profiles from Google Scholar
• Telegram Channel Scraper - Extract messages, media, and metadata from public Telegram channels

Browse all scrapers by george.the.developer on Apify.