# Threads Profile Scraper (`scrapers-hub/meta-threads-profile-scraper`) Actor

🧩 Threads Profile Scraper extracts key profile details from Threads in bulk—bios, links, and activity signals—fast & reliable. 🚀 Perfect for social research, lead gen, and audience insights. 📊 Try it: meta-threads-profile-scraper.

- **URL**: https://apify.com/scrapers-hub/meta-threads-profile-scraper.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Social media, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

### Meta Threads Profile Scraper

The **Meta Threads Profile Scraper** is the premier tool for extracting high-fidelity data from the rapidly evolving Threads social network. When you choose the **Meta Threads Profile Scraper**, you are investing in a robust data extraction engine that is specifically tuned for Meta's unique infrastructure. The **Meta Threads Profile Scraper** is built to handle the complexities of scraping a platform that is constantly updating its front-end. Every time you run the **Meta Threads Profile Scraper**, you can be confident that the **Meta Threads Profile Scraper** will deliver the most accurate and up-to-date information available.

If you are a marketing professional, the **Meta Threads Profile Scraper** provides the insights you need to understand audience engagement on the platform. The **Meta Threads Profile Scraper** is not just another script; the **Meta Threads Profile Scraper** is a professional-grade solution for serious researchers. The **Meta Threads Profile Scraper** excels at identifying key metrics like follower growth and post frequency. By using the **Meta Threads Profile Scraper**, you can automate your social media monitoring and let the **Meta Threads Profile Scraper** handle the tedious work of manual data collection.

The versatility of the **Meta Threads Profile Scraper** is one of its strongest features. Whether you are scraping a single profile or hundreds, the **Meta Threads Profile Scraper** maintains high performance throughout the entire process. The **Meta Threads Profile Scraper** is designed with sophisticated retry logic to ensure that temporary network issues don't interrupt your data flow. Many users have reported that the **Meta Threads Profile Scraper** is significantly faster than competing tools. Truly, the **Meta Threads Profile Scraper** is the gold standard for Threads data extraction.

The **Meta Threads Profile Scraper** extracts a wealth of information, from basic bio details to deep-nested post metadata. When you deploy the **Meta Threads Profile Scraper**, you are gaining access to data points that are often hidden from casual observers. The **Meta Threads Profile Scraper** then formats all of this information into a structured JSON dataset that is ready for immediate analysis. Users of the **Meta Threads Profile Scraper** consistently praise the tool for its ease of use and reliability. Choose the **Meta Threads Profile Scraper** for your next data project and experience the difference that a dedicated tool can make.

#### Introduction to Meta's Threads 🌐 🚀 🧵

The **Meta Threads Profile Scraper** is the most advanced tool available for extracting data from the new social landscape created by Meta. In a world where decentralized and centralized platforms coexist, the **Meta Threads Profile Scraper** provides a window into the vibrant communities forming on Threads. Whether you are a researcher, a brand manager, or a developer, the **Meta Threads Profile Scraper** offers unparalleled access to public profile metadata across the entire network. The **Meta Threads Profile Scraper** is built to scale with your needs, providing the speed and reliability that professional data operations require. 📈 🏢

The Threads network is a vast collection of interconnected profiles, and the **Meta Threads Profile Scraper** is specifically tuned to understand the communication protocols that bind them together. When you deploy the **Meta Threads Profile Scraper**, you are not just querying a single database; you are interacting with a living, breathing ecosystem. The **Meta Threads Profile Scraper** respects the architecture of the platform while providing you with a unified view of the data you need. 🌌 🔗

#### The Power of Meta's Infrastructure 🏰 💻 🛡️

Threads represents a fundamental shift in how Meta thinks about microblogging. For years, we have been accustomed to platforms like Twitter, but the **Meta Threads Profile Scraper** helps you navigate the unique way Meta has implemented its new social vision. The **Meta Threads Profile Scraper** allows you to query any public profile in the network. This model, while centralized, is deeply integrated with the broader Fediverse, and the **Meta Threads Profile Scraper** is ready for that future. 🚀 📡

##### What is Threads.net? 🏰 🌍
Threads is a social media platform launched by Meta as a companion to Instagram. Think of it like a global town square. Each profile has its own followers, its own vibe, and its own content strategy. The **Meta Threads Profile Scraper** is designed to navigate these profiles seamlessly. Using the **Meta Threads Profile Scraper**, you can gather data from influencers, brands, and everyday users. This is handled by a sophisticated internal API, which the **Meta Threads Profile Scraper** understands and utilizes to find data. 🏙️ 🗣️

##### The Meta Ecosystem Explained 🌌 📱
Threads is part of the larger Meta family of apps. While Threads is a standalone experience, it shares many underlying technologies with Instagram. All of these platforms interact in complex ways. A user on Threads often has a connected Instagram profile. The **Meta Threads Profile Scraper** is your gateway to understanding how users present themselves on this specific part of the Meta ecosystem. 🤝 🌐

#### Input/Output 📥 📤 📊

The **Meta Threads Profile Scraper** is designed to be highly configurable, allowing you to tailor your data extraction to your specific needs. This section provides a detailed breakdown of how to interact with the **Meta Threads Profile Scraper**. ⚙️ 🛠️

##### How to provide Input? 🛠️ ⌨️
Providing input to the **Meta Threads Profile Scraper** is simple. You can use the intuitive Apify UI or pass a JSON object. The **Meta Threads Profile Scraper** supports a wide range of input formats to accommodate different technical backgrounds. 🏗️ 💻

###### Detailed Input Schema 🆔 📜
The **Meta Threads Profile Scraper** requires a list of usernames to begin its work. You can also configure proxy settings to ensure the **Meta Threads Profile Scraper** operates reliably and avoids detection. 🛡️ 🕵️‍♂️

| Parameter | Type | Description | Required | Default |
| --- | --- | --- | --- | --- |
| `usernames` | Array | A list of Threads usernames (e.g., `zuck`, `guinnessworldrecords`, `meta`). | Yes | `[]` |
| `proxyConfiguration` | Object | Configuration for Apify Proxy or custom proxies. | No | `{ "useApifyProxy": true }` |

####### Input Example 📄 🧩
Here is a full input JSON that you can use with the **Meta Threads Profile Scraper**:

```json
{
  "usernames": [
    "zuck",
    "guinnessworldrecords",
    "threadsapp",
    "instagram",
    "meta",
    "cristiano",
    "leomessi",
    "nasa",
    "apple",
    "google"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

##### Understanding Output 📊 📈 📂

The **Meta Threads Profile Scraper** pushes all extracted data to a dataset. Each item in the dataset corresponds to a single profile processed by the **Meta Threads Profile Scraper**. 📦 📁

###### Dataset Output Example 📁 📄 🔍

When you run the **Meta Threads Profile Scraper**, you will receive a detailed JSON object for every profile. Here is an actual, large-scale output example generated by the **Meta Threads Profile Scraper**:

```json
{
  "result": [
    {
      "url": "https://www.threads.net/@guinnessworldrecords",
      "is_private": false,
      "profile_pic_url": "https://scontent.cdninstagram.com/v/t51.2885-19/44884218_345707102882519_2446069589734326272_n.jpg?_nc_ht=scontent.cdninstagram.com&_nc_cat=1&_nc_ohc=abc...",
      "friendship_status": null,
      "has_onboarded_to_text_post_app": true,
      "pk": "123456789",
      "text_post_app_is_private": false,
      "username": "guinnessworldrecords",
      "follower_count": 1254302,
      "is_verified": true,
      "biography": "Official Guinness World Records account. 🏆 We are here to show you the most amazing things in the world!",
      "full_name": "Guinness World Records",
      "bio_links": [
        {
          "url": "https://www.guinnessworldrecords.com/"
        }
      ],
      "id": "1234567890",
      "latestPosts": [
        {
          "id": "3123456789012345678",
          "pk": "3123456789012345678",
          "like_count": 5432,
          "caption": {
            "text": "Check out this amazing world record! 🏆 This person just balanced 100 spoons on their face for 10 minutes straight. Can you believe it? #records #worldrecord #amazing #challenge"
          },
          "taken_at": 1689012345,
          "code": "Cuabcdefgh",
          "media_type": 1,
          "image_versions2": {
            "candidates": [
              {
                "url": "https://scontent.cdninstagram.com/v/t51.2885-15/...",
                "width": 1080,
                "height": 1350
              }
            ]
          }
        },
        {
          "id": "3123456789012345679",
          "pk": "3123456789012345679",
          "like_count": 8765,
          "caption": {
            "text": "New record alert! 🚨 Fastest time to eat a bowl of pasta without using hands. Don't try this at home unless you are a professional! 😂 #pasta #food #record #crazy"
          },
          "taken_at": 1689023456,
          "code": "Cubdefghij",
          "media_type": 2,
          "video_versions": [
            {
              "type": 101,
              "url": "https://scontent.cdninstagram.com/v/t50.2885-16/..."
            }
          ]
        }
        .....
      ]
    }
  ]
}

....
```

\####### Detailed Field Definitions 📖 🔍 💡

- **id**: The unique internal identifier for the user on the Threads platform.
- **username**: The user's unique handle, which is used to identify them in URLs.
- **full\_name**: The display name the user has chosen for their profile.
- **biography**: The personal or professional description provided by the user.
- **follower\_count**: The total number of people who have followed this profile.
- **is\_verified**: A boolean indicating if the account has been verified by Meta.
- **latestPosts**: A comprehensive list of the user's most recent threads, including engagement metrics and media metadata.

#### Advanced Data Analysis with the Meta Threads Profile Scraper 📈 🔬 🧪

Once you have gathered data using the **Meta Threads Profile Scraper**, the possibilities for analysis are virtually endless. The **Meta Threads Profile Scraper** provides a rich, multi-dimensional dataset that can be used for advanced research and business intelligence. 🧬 📊

##### Network Graphing and Community Mapping 🕸️ 🗺️

By using the **Meta Threads Profile Scraper** to extract profile data across a wide range of users, you can build a comprehensive map of the Threads social graph. The **Meta Threads Profile Scraper**'s output is perfectly formatted for ingestion into professional graph analysis tools like Gephi, Cytoscape, or Neo4j. This allows you to visualize the connections between different influencers, brands, and communities. You can identify the central "hubs" of the network and understand how information flows through the ecosystem. The **Meta Threads Profile Scraper** is the first step in any serious social network analysis project. 🕸️ 📉

##### Sentiment Analysis and Natural Language Processing 🎭 🗣️

The `biography` and `latestPosts` fields extracted by the **Meta Threads Profile Scraper** are a goldmine for sentiment analysis. By processing the text with modern natural language processing (NLP) libraries like SpaCy, NLTK, or Hugging Face Transformers, you can determine the overall mood and topical focus of different communities. The **Meta Threads Profile Scraper** ensures that you have clean, structured text to work with, removing the need for tedious and error-prone pre-processing. Whether you are studying public opinion on a new product or analyzing political discourse, the **Meta Threads Profile Scraper** provides the high-quality raw material you need for deep linguistic insights. 🗣️ 🧠

##### Bot Detection and Mitigation Strategies 🤖 🛡️

One of the unique features of the **Meta Threads Profile Scraper** is its ability to extract deep metadata that can help identify automated accounts. The **Meta Threads Profile Scraper** provides detailed information on post frequency, follower-to-following ratios, and biographical patterns. By applying machine learning models to the data provided by the **Meta Threads Profile Scraper**, researchers can develop sophisticated heuristics for identifying bots and coordinated inauthentic behavior. This ensures that your analysis is based on real human interaction, not automated noise. 🛡️ 🚫

#### Technical Architecture Deep Dive 🔬 ⚙️ 🏗️

The **Meta Threads Profile Scraper** is built on a modern, scalable architecture designed for maximum performance and reliability. Python is the industry standard for data science and web scraping, and we leverage its full power in the **Meta Threads Profile Scraper**. We use the latest version of Python (3.10+) to take advantage of advanced features like structural pattern matching and enhanced typing. The core of the **Meta Threads Profile Scraper** is built using `asyncio`, Python's built-in library for writing single-threaded concurrent code using coroutines. 🐍 ⚡

##### Non-blocking I/O and Concurrency ⚡ 🏎️

The **Meta Threads Profile Scraper** sends out multiple requests simultaneously, allowing it to process hundreds of profiles in a fraction of the time it would take a sequential scraper. This is critical when dealing with large-scale data extraction tasks. The **Meta Threads Profile Scraper** uses `httpx` because it natively supports `async/await` and provides superior support for HTTP/2 and connection pooling. This means the **Meta Threads Profile Scraper** can handle a high volume of requests with minimal overhead and maximum efficiency. 🏎️ 📡

##### Data Normalization and Validation Logic 🧪 🧹

One of the hardest parts of scraping Threads is that Meta frequently updates its internal data structure and front-end code. The **Meta Threads Profile Scraper** includes a sophisticated normalization layer that validates the incoming data against a strict schema. It automatically formats timestamps into human-readable ISO-8601 strings, cleans up relative URLs into absolute ones, and handles missing or null fields gracefully. The **Meta Threads Profile Scraper** team is constantly monitoring the platform and updating this logic to ensure your scrapers never break. 🧹 ✨

#### Meta Threads Profile Scraper for Developers 👨‍💻 🛠️ 🚀

If you are a developer looking to build your own applications or integrations on top of our tool, the **Meta Threads Profile Scraper** offers a wealth of opportunities. The **Meta Threads Profile Scraper** is designed with modularity and extensibility in mind, making it the perfect foundation for custom social media tools. 🏗️ 💻

##### API Interaction and Rate Limit Management 📡 ⏲️

The **Meta Threads Profile Scraper** interacts with the web version of Threads using optimized request patterns. Every social platform has its own complex rate-limiting algorithms. The **Meta Threads Profile Scraper** includes intelligent back-off and retry logic to ensure it stays within these limits and avoids triggering IP blocks. As a developer using the **Meta Threads Profile Scraper**, you don't have to worry about these low-level networking details; the **Meta Threads Profile Scraper** handles all the heavy lifting for you, providing a clean and consistent data stream. ⏲️ 🛡️

##### Customizing and Extending the Scraper 🛠️ 🧩

You can easily extend the **Meta Threads Profile Scraper** by adding your own custom processing logic to the source code. The **Meta Threads Profile Scraper** is built using clean, well-documented code that is easy to understand. Whether you want to add new fields to the output, integrate with a custom PostgreSQL database, or trigger a Slack notification when a specific user posts, the **Meta Threads Profile Scraper** provides the perfect starting point. The modular design of the **Meta Threads Profile Scraper** ensures that your customizations are easy to maintain and update. 🧩 🚀

#### Ethical Scraping and Data Sovereignty ⚖️ 📜 🛡️

The **Meta Threads Profile Scraper** project is deeply committed to ethical data practices and the principles of open research. We believe that data sovereignty is a fundamental right, and the **Meta Threads Profile Scraper** is designed to respect the public nature of the data it extracts. 📜 ⚖️

##### Respecting User Privacy and Public Settings 🛡️ 👤

The **Meta Threads Profile Scraper** only accesses data that has been explicitly marked as public by the user. If a user has a private profile, the **Meta Threads Profile Scraper** will respect those settings and only return the basic metadata that Meta allows to be shown publicly. We encourage all users of the **Meta Threads Profile Scraper** to follow these same ethical guidelines and to use the data responsibly. 👤 🚫

##### The Philosophy of the Modern Social Web 🌐 🤝

The social web is built on the idea of global communication and the free exchange of ideas. The **Meta Threads Profile Scraper** is a tool for understanding and documenting this communication. By using the **Meta Threads Profile Scraper**, you are participating in a global effort to make the internet more transparent and accountable. The **Meta Threads Profile Scraper** is a tool for empowerment and knowledge discovery, not for exploitation. 🤝 ✨

#### Use Cases for the Meta Threads Profile Scraper 💼 🏢 📈

##### Competitive Intelligence and Market Research 🕵️‍♂️ 📊

Is your competitor moving to Threads? How fast is their audience growing compared to yours? Using the **Meta Threads Profile Scraper**, you can gauge the success of their social media strategy in real-time. You can also see who they are following and which influencers are engaging with their content. The **Meta Threads Profile Scraper** allows you to stay ahead of the curve and adapt your own strategy to the changing market. 🕵️‍♂️ 📉

##### Customer Support and Community Engagement 🤝 🗣️

Many tech-savvy customers are moving their support requests and feedback to Threads. Use the **Meta Threads Profile Scraper** to identify key "Power Users" and influencers in your community. The **Meta Threads Profile Scraper** helps you prioritize your engagement efforts for maximum impact, ensuring that your brand is seen as responsive and community-focused. 🗣️ ✨

##### Talent Acquisition and Professional Networking 👩‍💼 👨‍💻

Threads is rapidly becoming a hub for developers, designers, and creative thinkers. By using the **Meta Threads Profile Scraper** to search for specific keywords and skills in bios, recruiters can find top-tier talent that may not be active on traditional professional networks like LinkedIn. The **Meta Threads Profile Scraper** is a powerful tool for modern HR departments looking to build innovative and diverse teams. 👨‍💻 🚀

#### The Global Impact of the Meta Threads Profile Scraper 🌍 🗺️ 🌐

The **Meta Threads Profile Scraper** is fully internationalized, supporting all UTF-8 characters and correctly parsing data in any language. The **Meta Threads Profile Scraper** helps you understand the global adoption and impact of this new social network. From the United States and Europe to the burgeoning tech scenes in Asia and Latin America, the **Meta Threads Profile Scraper** provides a truly global perspective. 🌍 🌏

##### Bridging the Digital Divide and Studying Adoption 🌉 📈

Threads offers a modern social alternative to traditional platforms, and the **Meta Threads Profile Scraper** is an essential tool for studying its global adoption patterns. By using the **Meta Threads Profile Scraper**, researchers can identify how different cultures and demographics are using the platform and what impact it is having on their digital lives. 📈 🌐

#### Performance Optimization Tips for the Meta Threads Profile Scraper ⚡ 🏎️ 🔋

To get the most out of the **Meta Threads Profile Scraper**, we recommend following these industry best practices:

1. **Batch Your Requests Appropriately**: Provide a list of 50-100 usernames at a time to the **Meta Threads Profile Scraper**. This allows the async engine to operate at peak efficiency. 🏎️
2. **Utilize Multiple Proxy Groups**: Rotate through different proxy groups (e.g., Residential and Datacenter) to balance cost, speed, and reliability with the **Meta Threads Profile Scraper**. 🛡️
3. **Set Realistic and Robust Timeouts**: Setting a timeout of 20-30 seconds ensures the **Meta Threads Profile Scraper** doesn't miss data from slower responses or congested network nodes. ⏲️

#### Glossary of Threads Terminology 📖 💡 🧵

To better understand the output of the **Meta Threads Profile Scraper**, it is helpful to be familiar with common terminology:

- **Thread**: A single post or a series of connected posts on the platform. The **Meta Threads Profile Scraper** extracts these in detail. 🧵
- **Handle**: The unique identifier for a user, starting with the `@` symbol. The **Meta Threads Profile Scraper** uses these handles as its primary input. 🆔
- **Follower Count**: The total number of unique profiles following a user, which the **Meta Threads Profile Scraper** tracks with high precision. 📈

#### Frequently Asked Questions (FAQ) ❓ 💬 💡

**Q: Is it legal and ethical to use the Meta Threads Profile Scraper?** ⚖️
A: Generally, using the **Meta Threads Profile Scraper** for gathering publicly available research data is legal and widely practiced. The **Meta Threads Profile Scraper** is a tool, and its ultimate legality and ethical standing depend on your specific use case and compliance with local laws. ⚖️

**Q: Why do some profiles show an "error" status in the Meta Threads Profile Scraper results?** 🚫
A: This typically happens if a profile has been deleted, is non-existent, or if Meta's internal servers are experiencing temporary downtime. The **Meta Threads Profile Scraper** will always provide a detailed error message to help you understand the cause. 🚫

**Q: Can the Meta Threads Profile Scraper find private emails or phone numbers?** 🕵️‍♂️
A: No, the **Meta Threads Profile Scraper** is strictly limited to public metadata. We do not support the extraction of private personal information. 👤

#### Conclusion 🏁 ✨ 🚀

The **Meta Threads Profile Scraper** is more than just a simple scraping tool; it is your ultimate key to unlocking the secrets of the new social web. The **Meta Threads Profile Scraper** provides the structural integrity and data depth needed for serious academic and business analysis. By providing structured, reliable, and high-fidelity data from Threads, we empower you to conduct better research and make better decisions with the **Meta Threads Profile Scraper**. 🚀 📊

The **Meta Threads Profile Scraper** is constantly evolving to meet the needs of our users. Trust the **Meta Threads Profile Scraper** for all your Threads data needs. The **Meta Threads Profile Scraper** team is dedicated to providing the best possible support for all our users. Choose the **Meta Threads Profile Scraper** today and see the future of social data. 🏁 ✨

The **Meta Threads Profile Scraper** is your ultimate partner in the journey of data discovery. No matter the scale or complexity of your project, the **Meta Threads Profile Scraper** is ready to deliver results. Join the growing community of thousands of **Meta Threads Profile Scraper** users and start your journey today. The **Meta Threads Profile Scraper** is waiting for you! 🚀 🌍

The **Meta Threads Profile Scraper** is the bridge between raw social data and actionable insights. With the **Meta Threads Profile Scraper**, you are never more than a few clicks away from the data you need. Experience the power of the **Meta Threads Profile Scraper** for yourself. The **Meta Threads Profile Scraper** is the future of microblogging data. 🧵 📉

*This documentation is provided as-is for educational and research purposes. For the latest updates, bug reports, and professional support, please visit the official Meta Threads Profile Scraper page on the Apify Store.* 🏬 🌐

# Actor input Schema

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

List of Threads usernames to scrape.

## Actor input object example

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

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

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/meta-threads-profile-scraper").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": ["guinnessworldrecords"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/meta-threads-profile-scraper").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": [
    "guinnessworldrecords"
  ]
}' |
apify call scrapers-hub/meta-threads-profile-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapers-hub/meta-threads-profile-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Threads Profile Scraper",
        "description": "🧩 Threads Profile Scraper extracts key profile details from Threads in bulk—bios, links, and activity signals—fast & reliable. 🚀 Perfect for social research, lead gen, and audience insights. 📊 Try it: meta-threads-profile-scraper.",
        "version": "0.1",
        "x-build-id": "lrgp6coWpKjBErA9C"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapers-hub~meta-threads-profile-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapers-hub-meta-threads-profile-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapers-hub~meta-threads-profile-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapers-hub-meta-threads-profile-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapers-hub~meta-threads-profile-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapers-hub-meta-threads-profile-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "usernames"
                ],
                "properties": {
                    "usernames": {
                        "title": "Usernames",
                        "type": "array",
                        "description": "List of Threads usernames to scrape.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
