# Threads Full Scraper - Posts, Profiles & Replies | No Login (`pro100chok/threads-scraper-usage`) Actor All-in-one Meta Threads.net scraper: search posts by keyword, extract user profiles with followers, and collect reply threads. Full engagement data, contact extraction, media URLs. 20 parallel workers, auto-retry, proxy rotation. No login. - **URL**: https://apify.com/pro100chok/threads-scraper-usage.md - **Developed by:** [Raven](https://apify.com/pro100chok) (community) - **Categories:** Social media, Lead generation, Automation - **Features:** Limited permissions, Single-tenant, Server interface - **Stats:** 1,137 total users, 273 monthly users, 100.0% runs succeeded, 11 bookmarks - **User rating**: 4.89 out of 5 stars ## Pricing from $2.00 / 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. 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 ## Threads Scraper — Extract Posts, Profiles, and Search Results from Threads.net Scrape Threads.net posts, user profiles, follower and following lists, and search results at scale. Collect post text, engagement metrics (likes, replies, reposts, shares), profile data with follower counts and linked Instagram accounts, media URLs, and contact information. Process up to 20 requests in parallel with automatic retries. ![Threads Scraper on Apify — every post every profile as structured JSON](https://raw.githubusercontent.com/PRO100CHOK/apify-readme-assets/main/threads-scraper-usage/hero.png)
Raven · Social-media suite   •  Instagram, TikTok, YouTube, X (Twitter), Threads, Pinterest
 Threads Scraper
➤ You are here 		 Instagram Scraper
Posts, followers, comments 		 X (Twitter) Scraper
Posts, followers, replies 		 Pinterest Scraper
Pins, profiles, boards
### Pricing **Pay per result: $2 per 1,000 results.** No monthly fee — you pay only for the data you get. ### Key Features - **Search posts by keyword** — find Threads posts matching any search query, with full engagement data, newest first or by relevance - **Search by date range** — collect older posts from a specific time window with `afterDate` / `beforeDate`, the same filter as Threads' `after_date` / `before_date` search URLs - **Scrape user profiles** — extract bio, follower count, verification status, profile links, and contact info - **Scrape followers and following lists** — paginate through a user's followers or the accounts they follow, each user as a separate dataset result (needs a logged-in session; ours is used by default) - **Linked Instagram account** — every profile and follower result includes the Instagram URL and ID of the same account - **Scrape user posts individually** — get each user's post as a separate dataset result with full pagination support - **Extract post with replies** — get a specific post with its first page of replies - **Scrape all post replies** — paginate through all replies on a post, each reply as a separate result - **Parallel processing** — up to 20 concurrent requests for maximum throughput - **Auto-retry** — 5 retry attempts per request for reliable results - **Contact extraction** — automatically finds emails and URLs in post text and user bios - **Multiple media types** — handles text posts, photos, videos, and carousels with full media URLs - **Flexible input formats** — accepts usernames, @usernames, or full profile/post URLs - **Real-time API (Standby mode)** — call the scraper over HTTP and get JSON back in the same response, no run to poll and no dataset to fetch ### What Data You Get #### Search and post data | Field | Description | |-------|-------------| | `post_id` | Unique post identifier | | `text` | Full post text | | `taken_at` | Unix timestamp | | `like_count` | Number of likes | | `reply_count` | Number of replies | | `repost_count` | Number of reposts | | `quote_count` | Number of quotes | | `reshare_count` | Number of shares | | `username` | Author username | | `full_name` | Author display name | | `is_verified` | Verified account flag | | `media_type` | Content type: text (19), photo (1), video (2), carousel (8) | | `images` | Array of image URLs with dimensions | | `video_versions` | Video URLs (if video post) | | `carousel_media` | Carousel items (if carousel post) | | `post_url` | Direct link to the post | | `emails_in_text` | Emails found in post text | | `urls_in_text` | URLs found in post text | | `reply_control` | Who can reply: `everyone`, `accounts_you_follow`, `mentioned_only` | | `is_reply` | Whether this is a reply to another post | #### Profile data | Field | Description | |-------|-------------| | `user_id` | Numeric user ID | | `username` | Username | | `full_name` | Display name | | `biography` | Bio text | | `bio_fragments` | Structured bio (mentions, hashtags, links) | | `bio_links` | Links from bio | | `profile_pic_url` | Avatar URL | | `hd_profile_pics` | HD avatar versions | | `follower_count` | Number of followers | | `is_verified` | Verified account flag | | `is_private` | Private account flag | | `profile_url` | Direct link to the Threads profile | | `instagram_url` | Linked Instagram account URL | | `instagram_user_id` | Numeric ID of the linked Instagram account | | `recent_views_count` | Recent profile views shown on the profile header (may be `null`) | | `emails_in_bio` | Emails found in bio | | `urls_in_bio` | URLs found in bio | #### Followers / following data Returned by `user_followers` and `user_following` — one dataset result per user. > **How many users you get.** For small and mid-size accounts Threads pages through the whole list, so you get everything up to `maxItems`. For large accounts Threads caps the list: it returns a single slice of roughly 50 users and stops offering a next page, no matter what `maxItems` you set. That is a Threads-side limit — the list simply cannot be paged deeper, by this Actor or any other tool. | Field | Description | |-------|-------------| | `user_id` | Numeric user ID | | `username` | Username | | `full_name` | Display name | | `profile_pic_url` | Avatar URL | | `is_verified` | Verified account flag | | `is_private` | Private account flag | | `has_onboarded` | Whether the account is active on Threads | | `fbid` | Meta-internal account ID | | `profile_url` | Direct link to the Threads profile | | `instagram_url` | Linked Instagram account URL | | `instagram_user_id` | Numeric ID of the linked Instagram account | #### Post detail fields (additional) | Field | Description | |-------|-------------| | `replies` | Array of replies to this post (same data structure) | | `quoted_post` | Quoted post data | | `reposted_post` | Reposted post data | | `link_preview` | Link preview attachment | | `text_fragments` | Structured text with mentions, hashtags, and links | | `is_paid_partnership` | Paid partnership flag | | `is_pinned_to_profile` | Pinned to profile flag | ### Use Cases - **Social media monitoring** — track brand mentions, trending topics, and audience sentiment on Threads in real time - **Influencer research** — find and evaluate Threads creators by follower count, engagement rate, and posting frequency for partnership decisions - **Content analysis** — analyze post performance, identify top-performing content formats, and track engagement patterns across keywords - **Lead generation** — extract contact information (emails, URLs) from Threads profiles and posts for outreach campaigns - **Market research** — monitor competitor activity, product discussions, and industry trends on Meta's text-based platform ### How It Works 1. **Choose an action** — `search` (find posts by keyword), `profile` (scrape user data), `post` (get specific posts with first page of replies), `user_posts` (get posts from user profiles as individual results), `post_replies` (get all replies to a post as individual results), `user_followers` (get a user's followers as individual results), or `user_following` (get the accounts a user follows as individual results) 2. **Provide inputs** — keywords for search, usernames for profiles, or post URLs 3. **Actor processes in parallel** — up to 20 concurrent requests 4. **Download results** — structured JSON, CSV, or Excel from the Apify dataset ### Input Parameters | Parameter | Type | Required | Description | |-----------|------|----------|-------------| | `action` | String | Yes | `search`, `profile`, `post`, `user_posts`, `post_replies`, `user_followers`, or `user_following` | | `targets` | String\[] | Yes | What to scrape — one list for every mode. Its meaning follows `action`: search keywords for `search`; usernames, `@username` or profile URLs for `profile`/`user_posts`/`user_followers`/`user_following`; post URLs for `post`/`post_replies` (short `threads.com/share/...` links work too) | | `serp_type` | String | No | `default` (posts) or `accounts` (search for accounts) | | `searchSort` | String | No | Post search order: `recent` (newest first, default) or `top` (most relevant) | | `afterDate` | String | No | Post search only: posts published on or after this date, `YYYY-MM-DD` (00:00 UTC) | | `beforeDate` | String | No | Post search only: posts published before this date, `YYYY-MM-DD` — the day itself is not included | | `useOurAccounts` | Boolean | No | Authenticate using our own Threads accounts (default: `true`). No cookies needed from you | | `threadsCookies` | String | No | JSON cookies from EditThisCookie extension — use your own session instead of ours | | `maxItems` | Integer | No | Max results per query/username/post (default: 100, 0 = unlimited). For `user_posts` — max posts per user. For `post_replies` — max replies per post. For `user_followers`/`user_following` — max users per profile. | #### Authentication A logged-in Threads session enables **pagination for user posts** (`user_posts`), returns more detailed data, and is **required** for `user_followers` and `user_following` — Threads serves follower and following lists only to logged-in sessions. Replies (`post_replies`) paginate either way: the whole thread is public, and the Actor walks it with or without a session. You have two ways to get one: **1. Use our accounts (default, nothing to do).** `useOurAccounts` is on by default: the run borrows a logged-in Threads session from our own pool, uses it, and returns it when the run finishes. Each account is leased to a single run at a time, so runs never share a session. If every account is busy, the run continues unauthenticated and says so in the log. Available on paid runs of the pay-per-usage Actor. **2. Use your own cookies.** Paste them into `threadsCookies`. Your cookies always take priority over our pool — when the field is filled, our accounts are not touched at all. **How to get cookies:** 1. Install the [EditThisCookie v3](https://chromewebstore.google.com/detail/editthiscookie-v3/ojfebgpkimhlhcblbalbfjblapadhbol) Chrome extension. 2. Log into [threads.net](https://www.threads.net) in your browser. 3. Click the EditThisCookie icon and export cookies (the 5th button at the top of the cookie editor). 4. Paste the exported JSON into the `threadsCookies` input field of this Actor. **Cookie expiry note:** Threads cookies typically expire after a few days to weeks. If the scraper reports invalid authentication after a previous successful run, simply re-export fresh cookies from your browser. #### Input examples One field holds what you want scraped — `targets` — and `action` decides how it is read. **Search posts:** ```json { "action": "search", "targets": ["python programming", "javascript", "AI tools"] } ``` **Search posts from a date range** (same as `https://www.threads.com/search?q=UITM&after_date=2023-07-01&before_date=2023-10-01`): ```json { "action": "search", "targets": ["UITM"], "afterDate": "2023-07-01", "beforeDate": "2023-10-01", "maxItems": 200 } ``` **Scrape profiles:** ```json { "action": "profile", "targets": ["zuck", "@mosseri", "https://www.threads.com/@instagram"] } ``` **Get posts from user profiles (each post = separate result):** ```json { "action": "user_posts", "targets": ["zuck", "@mosseri"], "maxItems": 50 } ``` **Get a user's followers (each follower = separate result):** ```json { "action": "user_followers", "targets": ["zuck"], "maxItems": 100 } ``` **Get the accounts a user follows (each account = separate result):** ```json { "action": "user_following", "targets": ["zuck"], "maxItems": 100 } ``` **Scrape specific posts (with first page of replies):** ```json { "action": "post", "targets": [ "https://www.threads.com/@zuck/post/DVrwsE5EdSz", "https://www.threads.com/share/BAdEynLVnr/" ] } ``` **Get all replies to a post (each reply = separate result):** ```json { "action": "post_replies", "targets": [ "https://www.threads.com/@zuck/post/DVrwsE5EdSz" ], "maxItems": 200 } ``` The old `queries`, `usernames` and `posts` fields are still accepted, so saved tasks and integrations written before this change keep running unchanged. ### Real-time API (Standby mode) Besides the usual "start a run, collect the dataset" flow, this Actor can run in **Standby mode** — it stays warm and answers HTTP requests, returning the scraped items directly in the response body. Handy when you need one profile or one search on demand instead of a batch job. Open the **Standby** tab in Apify Console to get your endpoint URL and try the requests interactively — the tab is generated from the Actor's OpenAPI schema, so every parameter is documented and clickable there. Pick the endpoint by what you already have — a keyword, a username, or a post URL. | You have | Endpoint | What comes back | | --- | --- | --- | | A keyword | `GET /search?query=threads` | Posts matching the keyword, one item each (`serp_type=accounts` returns Threads accounts instead) | | A username | `GET /profile?username=zuck` | One profile record per user: bio, followers, verification, linked Instagram | | A username | `GET /user-posts?username=zuck` | That user's posts, one item each | | A username | `GET /user-followers?username=zuck` | The users following that profile (needs a logged-in session) | | A username | `GET /user-following?username=zuck` | The accounts that profile follows (needs a logged-in session) | | A post URL | `GET /post?url=` | The post itself with the replies shown on its page | | A post URL | `GET /post-replies?url=` | Every reply under that post, one item each | | Anything | `GET /?action=&targets=<...>` | Any mode, chosen by the `action` parameter | Usernames accept `zuck`, `@zuck` or a profile URL; post URLs accept short `https://www.threads.com/share/...` links too. The full, clickable reference lives in the **Endpoints** tab of this Actor in Apify Console. ```bash curl "https:///search?query=threads&maxItems=50&token=" ``` Every endpoint also accepts `POST` with a JSON body using the same field names as the input above: ```bash curl -X POST "https:///profile?token=" -H "Content-Type: application/json" -d '{"targets": ["zuck", "mosseri"]}' ``` Notes: - The response is a JSON array of the same items the Actor writes to its dataset — and they are stored in the dataset too, so nothing is lost if a request times out. - Target parameters can be repeated (`?username=zuck&username=mosseri`) or comma-separated (`?username=zuck,mosseri`). - `maxItems`, `searchSort`, `afterDate`, `beforeDate`, `useOurAccounts` and `threadsCookies` work exactly as in the input schema (`after_date` / `before_date` are accepted too, e.g. `/search?query=UITM&after_date=2023-07-01&before_date=2023-10-01`). Pass long cookie JSON in a `POST` body rather than the query string. - `targets` is accepted as a synonym for `query` / `username` / `url` on every endpoint. - Errors come back as `{"error": "..."}` with a `4xx`/`5xx` status. ### Output Example #### Search result ```json { "post_id": "3578921456789012345", "code": "DVp9LrHAjHq", "text": "Just launched our new Python library for data processing...", "taken_at": 1710000000, "media_type": 19, "like_count": 245, "reply_count": 32, "repost_count": 18, "quote_count": 5, "reshare_count": 12, "username": "techdev", "full_name": "Tech Developer", "is_verified": true, "is_reply": false, "images": [], "post_url": "https://www.threads.net/@techdev/post/DVp9LrHAjHq", "emails_in_text": ["hello@techdev.com"], "urls_in_text": ["https://github.com/techdev/library"] } ``` #### Profile result ```json { "user_id": 12345678901, "username": "zuck", "full_name": "Mark Zuckerberg", "biography": "Building the future of connection.", "profile_pic_url": "https://...", "follower_count": 12500000, "is_verified": true, "is_private": false, "bio_links": [{ "url": "https://meta.com" }], "emails_in_bio": [], "urls_in_bio": ["https://meta.com"], "profile_url": "https://www.threads.net/@zuck", "instagram_url": "https://www.instagram.com/zuck", "instagram_user_id": "314216", "recent_views_count": 3520 } ``` #### Follower / following result ```json { "user_id": "63043102001", "username": "zencodez", "full_name": "Godwin Bamisaye", "profile_pic_url": "https://...", "is_verified": false, "is_private": false, "has_onboarded": true, "fbid": "17841475166358863", "profile_url": "https://www.threads.net/@zencodez", "instagram_url": "https://www.instagram.com/zencodez", "instagram_user_id": "63043102001" } ``` ### FAQ **What data can I extract from Threads.net?** Posts (text, likes, replies, reposts, media), user profiles (bio, followers, verification), and full reply threads. The scraper also extracts emails and URLs found in text and bios. **How many posts or profiles can I scrape per run?** There is no hard limit. The Actor processes up to 20 requests concurrently, with 5 retry attempts per request. A typical run can process hundreds of search results or profiles. **Does the Threads scraper handle private accounts?** No. Only publicly visible data from public profiles and posts is collected. **Can I scrape older posts from a specific period?** Yes. Set `afterDate` and/or `beforeDate` (format `YYYY-MM-DD`) on a keyword search — for example `"afterDate": "2023-07-01", "beforeDate": "2023-10-01"` returns posts from July, August and September 2023, newest first. Either date can be used alone. Dates are in UTC; `afterDate` is included, `beforeDate` is not (the window ends at 00:00 on that day). Threads filters the posts on its side and the Actor double-checks every post's date, so nothing outside the window ends up in your dataset. Threads started on 5 July 2023, so there is nothing to find before that. Notes: - Paging beyond the first page (about 10–20 posts) needs a logged-in session — our accounts on paid runs, or your own `threadsCookies`. Without one you get the first page of the window. - If a window has no posts, the run stops after a single request and says so in the log (`0 posts for 'UITM' between …`) — an empty window costs almost nothing. - Date filters apply to post search only; account search (`serp_type: accounts`) and the other actions ignore them. **Can I search for accounts instead of posts?** Yes. Set `serp_type` to `accounts` to search for Threads user profiles matching your keywords instead of posts. **How do I scrape user posts?** Use `action: "user_posts"` with a list of usernames. Each post is returned as a separate dataset result. Provide cookies via `threadsCookies` to enable pagination beyond the first page. **How do I scrape followers or following lists?** Use `action: "user_followers"` or `action: "user_following"` with a list of usernames, and set `maxItems` to how many users you want per profile. Each user is returned as a separate dataset result with their Threads and Instagram profile links. These two actions need a logged-in session — Threads does not serve these lists to logged-out visitors. Leave `useOurAccounts` on and the run handles that itself; otherwise supply `threadsCookies`. **Why did a followers run return fewer users than the profile's follower count?** Because Threads caps how deep follower and following lists can be paged. Small and mid-size accounts page normally — you get everything up to `maxItems`. Large accounts return a single slice of roughly 50 users with no next-page cursor, so a profile with millions of followers still yields about 50. Occasionally Threads refuses a large list entirely; the Actor logs a warning and moves on. In every case the Actor collects everything Threads is willing to return and deduplicates users across pages. **How do I get the Instagram account behind a Threads profile?** Every profile, follower, and following result includes `instagram_url` and `instagram_user_id`. A Threads account is an Instagram account — it shares the same username and the same numeric ID. **My cookies stopped working** Re-export cookies from your browser. Threads cookies expire periodically. Just repeat the EditThisCookie export steps above. **Is my Threads account safe when using cookies?** The Actor only performs read-only operations (viewing profiles, posts, and search results). It does not post, like, follow, or modify anything on your account. Your cookies are never stored by the Actor. ### Having issues? Help me fix them faster If you experience any problems, please share your run data with me so I can debug and improve the Actor: 1. Go to [Apify Security Settings](https://console.apify.com/settings/security) 2. Find **"Share run data with developers"** 3. In the **"Manage list of Actors"** section, check this Actor (or **All Actors**) 4. Save This data is used **only for debugging** and helps me resolve issues much faster. Thank you! ### Support Questions, bug reports, or feature requests: **afrcanec@gmail.com** ### 🏷️ Tags Threads Scraper, Threads.net Scraper, Threads Data Extractor, Threads API, Social Media Scraper, Threads Posts Scraper, Threads Profile Scraper, Threads Search Scraper, Threads Followers Scraper, Threads Following Scraper, Follower List Extractor, Meta Threads, Instagram Threads Data, Engagement Metrics Extractor, Follower Count Tracker, Social Media Monitoring, Brand Mentions Tracker, Influencer Research Tool, Content Analysis Threads, Threads Reply Scraper, Social Media Lead Generation, Email Extractor Social Media, How to Scrape Threads, Extract Threads Data, Social Media Analytics, Trending Topics Tracker, Audience Analysis, Social Listening Tool, Social Media Data Mining, Competitor Monitoring Social, User Profile Extractor, Threads Engagement Analytics, Threads Media Scraper # Changelog This Actor's version history is a separate document: https://apify.com/pro100chok/threads-scraper-usage/changelog.md # Actor input Schema ## `action` (type: `string`): What to scrape. This also decides what goes into the list below. - **Search posts by keyword** — posts matching a keyword - **Get user profiles** — one profile record per user - **Get specific posts** — a post with the replies shown on its page - **Get posts from user profile** — posts published by a user - **Get post replies** — every reply under a post - **Get user followers** — the users following a profile (needs a logged-in session) - **Get user following** — the accounts a profile follows (needs a logged-in session) ## `targets` (type: `array`): One list for every mode — what you put in it depends on the Action above: - **Search posts by keyword** → keywords, e.g. `threads`, `nike running` - **Get user profiles**, **Get posts from user profile**, **Get user followers**, **Get user following** → usernames or profile URLs, e.g. `zuck`, `@mosseri`, `https://www.threads.com/@instagram` - **Get specific posts**, **Get post replies** → post URLs, e.g. `https://www.threads.com/@zuck/post/DVp9LrHAjHq`. Short share links like `https://www.threads.com/share/BAdEynLVnr/` work too — they are resolved to the real post automatically. ## `serp_type` (type: `string`): Whether a keyword search returns posts or Threads accounts. Only used by 'Search posts by keyword'. ## `searchSort` (type: `string`): Order of posts in a keyword search. **Recent** (default) returns the newest posts first, like the Recent tab on Threads; **Top** returns the posts Threads ranks as most relevant. Only used by 'Search posts by keyword'. ## `afterDate` (type: `string`): Only return posts published on or after this date (from 00:00 UTC), format YYYY-MM-DD, e.g. `2023-07-01`. Same as `after_date` in a Threads search URL. Leave empty for no lower limit. Works for 'Search posts by keyword' with Search type = Posts; ignored for account search and other actions. ## `beforeDate` (type: `string`): Only return posts published before this date (up to 00:00 UTC of that day — the day itself is not included), format YYYY-MM-DD, e.g. `2023-10-01`. Same as `before_date` in a Threads search URL. Leave empty for no upper limit. You can set either date alone or both. ## `maxItems` (type: `integer`): Maximum number of results per entry in the list above — per keyword, per profile or per post. Set 0 for unlimited. Going past the first page requires a logged-in session. ## `useOurAccounts` (type: `boolean`): Authenticate the run with a logged-in Threads session from our own account pool — no cookies needed from you. Each account is leased to one run at a time and returned to the pool afterwards. Your own cookies below always take priority. Available on paid runs. ## `threadsCookies` (type: `string`): Optional — only needed if you prefer your own session over ours (it takes priority when set). JSON cookies from the EditThisCookie browser extension for a logged-in Threads.net session. Format: JSON array of cookie objects. ## Actor input object example ```json { "action": "search", "targets": [ "threads" ], "serp_type": "default", "searchSort": "recent", "maxItems": 100, "useOurAccounts": true } ``` # Actor output Schema ## `results` (type: `string`): No description # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "targets": [ "threads" ] }; // Run the Actor and wait for it to finish const run = await client.actor("pro100chok/threads-scraper-usage").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "targets": ["threads"] } # Run the Actor and wait for it to finish run = client.actor("pro100chok/threads-scraper-usage").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 '{ "targets": [ "threads" ] }' | apify call pro100chok/threads-scraper-usage --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,pro100chok/threads-scraper-usage" } } } ``` 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 ` 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/ghOKnIbTDC0SWZw8d/builds/Vq92FUGK6NRO0Yz5S/openapi.json