# Threads Scraper - Scrape threads.net Posts, No Login (`logiover/threads-scraper`) Actor
No-login Threads scraper & unofficial API alternative. Export public Threads posts, replies, profiles & engagement to CSV, JSON or Excel.
- **URL**: https://apify.com/logiover/threads-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Social media, Marketing, Business
- **Features:** Limited permissions
- **Stats:** 116 total users, 17 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $3.50 / 1,000 results
This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.
Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event
## What's an Apify Actor?
An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.
## How to integrate an Actor?
If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.
For examples already wired to this Actor's own input schema, see the [API](#api) section below.
Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).
# README
## Threads Scraper — Posts, Profiles, Replies & Engagement (No Login, No API Key)
    
Scrape **Threads (threads.com / threads.net)** — Meta's text-based social network — by **username, post URL, or keyword/#tag**. Pull public posts with full engagement — **likes, replies, reposts and quotes** — plus text, hashtags, mentions, media (images & videos), language, author and date. It needs **no login, no cookies and no API key** — it reads only public data through residential proxies, so there's **zero risk to any Threads or Instagram account**.
> ### 🏆 Why this Threads scraper?
>
> **3 input modes (username · post URL · keyword/#tag)** · full engagement metrics · reply-thread expansion (turns ~25 into **300–700 posts per profile**) · media, hashtags & author context · no login, no cookies, 0% ban risk · export to JSON / CSV / Excel. The unofficial **Threads API alternative** for content analysis, social listening and post datasets.
***
### ✨ What this Actor does / Key features
- 🧵 **3 input modes** — scrape by username, by post URL, or by keyword / #tag; mix them in one run.
- 📦 **Recent public posts** — collects each target's most recent public posts (login-free window).
- 📊 **Full engagement** — likes, replies, reposts & quotes for every post.
- 🔁 **Reply-thread expansion** — opens each post's page to also collect its visible reply thread (~25–30 posts), the main volume multiplier.
- 🖼️ **Media included** — image and video URLs, including carousels.
- 🏷️ **Rich post data** — hashtags, mentions, language, reply flag and paid-partnership flag.
- 👤 **Author context** — username, full name, verified status and avatar per post.
- 🛡️ **Login-free & safe** — public-page access over residential proxies; no account, no ban risk.
- 🔑 **No API key** — reads only public data; only an Apify account required.
### 🚀 Quick start (3 steps)
1. **Configure** — provide at least one of `usernames`, `postUrls` or `searchTerms`. Keep reply expansion on for maximum volume.
2. **Run** — click **Start**. The Actor walks timelines/searches, expands reply threads, de-duplicates by post id and streams posts into your dataset.
3. **Get your data** — open the **Output** tab and export to **JSON, CSV, Excel or HTML**, or pull it via the Apify API.
### 📥 Input
Provide **at least one** of `usernames`, `postUrls` or `searchTerms`. Everything else is optional.
#### Example — profiles + a hashtag (max volume)
```json
{
"usernames": ["zuck", "https://www.threads.com/@mosseri"],
"searchTerms": ["#ai"],
"maxResults": 0,
"includeReplies": true,
"proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "US" }
}
```
#### Example — a single post + its reply thread
```json
{
"postUrls": ["https://www.threads.com/@zuck/post/DY11ZLWG_eY"],
"maxRepliesPerPost": 100
}
```
#### Example — keyword social listening
```json
{
"searchTerms": ["startup", "#travel", "ai"],
"expandFromSearch": true,
"maxResults": 0
}
```
| Field | Type | Description | Default |
|---|---|---|---|
| `usernames` | array | Threads @handles or profile URLs (e.g. `["zuck", "@mosseri"]`). | – |
| `postUrls` | array | Threads post URLs (post + visible replies). | – |
| `searchTerms` | array | Keywords or #tags to search (e.g. `["ai", "#travel"]`). | – |
| `maxResults` | integer | Max posts per target (timeline + expanded replies). 0 = unlimited (recommended). | `0` |
| `includeReplies` | boolean | Expand each target post's reply thread (~25–30 posts each). **Main volume multiplier.** | `true` |
| `expandFromProfiles` | boolean | Expand reply threads of posts collected from profiles. | `true` |
| `expandFromSearch` | boolean | Expand reply threads of posts returned by searches/tags. | `false` |
| `maxExpandPerTarget` | integer | How many of a target's posts to open for expansion. | `30` |
| `maxRepliesPerPost` | integer | Cap on replies kept per expanded post. | `50` |
| `proxyConfiguration` | object | Residential proxy (Threads blocks datacenter IPs). | RESIDENTIAL · US |
> **Tip:** breadth wins — add many handles, tags and post URLs in one run; they aggregate and de-duplicate automatically. Keep the RESIDENTIAL default. Prefix with `#` for tags, or use plain keywords for full-text search.
### 📤 Output
Each item is one Threads post — exportable to JSON, CSV, Excel or HTML. Here is a trimmed sample record:
```json
{
"postId": "3906263078447871896",
"code": "DY11ZLWG_eY",
"url": "https://www.threads.com/@zuck/post/DY11ZLWG_eY",
"text": "Today Biohub is sharing a major scientific advance...",
"createdAt": "2026-05-27T14:02:00.000Z",
"lang": "en",
"likeCount": 1948,
"replyCount": 385,
"repostCount": 124,
"quoteCount": 25,
"isReply": false,
"isPaidPartnership": false,
"hashtags": [],
"mentions": [],
"media": [{ "type": "image", "url": "https://scontent.cdninstagram.com/..." }],
"author": {
"id": "63055343223",
"username": "zuck",
"fullName": "Mark Zuckerberg",
"isVerified": true,
"profilePicUrl": "https://scontent.cdninstagram.com/..."
},
"fromSource": "zuck",
"scrapedAt": "2026-07-06T12:00:00.000Z"
}
```
📋 Full field reference (click to expand)
| Field | Description |
|---|---|
| `postId` / `code` / `url` | Post identifiers and canonical link |
| `text` | Full post text |
| `createdAt` | ISO 8601 timestamp |
| `lang` | Detected post language |
| `likeCount` / `replyCount` / `repostCount` / `quoteCount` | Engagement metrics |
| `isReply` / `isPaidPartnership` | Post flags |
| `hashtags` / `mentions` | Parsed from the text |
| `media` | Array of `{ type, url }` for images and videos |
| `author` | Username, full name, verified status, avatar |
| `fromSource` | The username, post URL or search term this post came from |
| `scrapedAt` | Scrape timestamp (ISO 8601) |
### 📈 Volume & limits (honest numbers)
Threads gates logged-out visitors. Here is what each mode actually returns, measured live:
| Mode | Raw public window | With reply expansion |
|---|---|---|
| **Profile** (`usernames`) | ~25 posts (1 timeline page, then login wall) | **~300–700 posts** per profile |
| **Post URL** (`postUrls`) | post + full visible reply thread (~30 posts) | already includes the thread |
| **Search / tag** (`searchTerms`) | ~20 posts (no guest pagination) | ~20 × replies if `expandFromSearch` on |
**How the multiplier works:** a profile timeline gives ~25 posts before the login wall. The Actor then opens each post's page, and each page also embeds its **reply thread** (~25–30 more posts). Aggregating and de-duplicating those turns ~25 into several hundred. **Realistic max per run = (number of seeds) × (per-seed yield)** — e.g. 10 profiles → roughly 3,000–6,000 posts. Every post is deduped by id across the run.
**The hard cap that remains:** the profile timeline itself is capped at ~25 posts for logged-out access — Meta does not paginate a profile or search deeper without a login, and this Actor uses no login (zero ban risk). You cannot get a profile's *full historical* post list; what you *can* do is multiply rows via reply threads and scale breadth across many seeds.
### 💡 Use cases
- **Content & competitor analysis** — see which Threads posts and formats win in your niche.
- **Brand & creator monitoring** — archive an account's output with engagement over time.
- **Social listening** — track keywords and #tags across public Threads conversations.
- **Data science & ML** — build labelled post datasets for NLP, sentiment and trend analysis.
### 👥 Who uses it
Social-media marketers & agencies · brand and competitor analysts · social-listening and PR teams · creators and community managers · data scientists building social datasets · researchers studying online discourse.
### 💰 Pricing
This Actor runs on a simple **pay-per-result** model — you pay for the posts you extract, with no separate Apify platform fees to calculate. Try it on the **free tier** first, then scale up. See the **Pricing** tab on this page for the current rate.
### ❓ Frequently Asked Questions
**Is this a Threads API alternative?**
Yes. It scrapes public Threads posts without any official Threads / Meta API, developer account or app keys — just give it usernames, post URLs or keywords and run. There is no public Threads data API, so this is the practical way to export post data.
**Does it need a Threads or Instagram login?**
No. It reads public pages only — no login, no cookies you provide, no account. There's no account involved at all, so there's zero ban risk.
**Can it scrape a Threads profile without an API key?**
Yes. Point it at any @handle to scrape a public Threads profile's recent posts and engagement — no API key, no developer account and no login required.
**How many posts can I get per profile?**
The profile timeline is capped at ~25 posts for logged-out access, but with reply expansion (on by default) the Actor also pulls each post's reply thread, so a single profile usually yields **300–700 posts**. Run many profiles/tags in one go to reach several thousand.
**How do I scrape all posts from a Threads profile without logging in?**
Add the @handle to `usernames` and keep reply expansion on — the Actor walks the profile timeline and expands each post's reply thread, turning about 25 posts into several hundred.
**Can it scrape replies to a Threads post?**
Yes — pass the post URL and it returns the post plus its visible reply thread (~30 posts). This is also what powers the profile volume multiplier.
**How do I search Threads posts by hashtag or keyword?**
Put keywords or #tags in `searchTerms` and the Actor pulls matching public posts with full engagement — likes, replies, reposts and quotes — no account needed.
**Which domains work — threads.com or threads.net?**
Both. `threads.com` and `threads.net` handles and URLs are accepted interchangeably.
**How do I export Threads data to CSV or JSON?**
Run the Actor, then download the dataset from the run's **Storage** tab or pull it via the Apify API. Threads posts export to CSV, JSON, Excel or HTML.
### 🔗 More social-media scrapers by logiover
Building a cross-platform social dataset? Pair Threads with these:
| Actor | What it does |
|---|---|
| [Instagram Media Downloader](https://apify.com/logiover/instagram-media-downloader) | Download Instagram photos & videos |
| [TikTok Hashtag Video Scraper](https://apify.com/logiover/tiktok-hashtag-video-scraper) | Videos & metrics by hashtag |
| [Reddit Search Scraper](https://apify.com/logiover/reddit-search-scraper) | Posts & comments by keyword |
| [Reddit Subreddit Scraper](https://apify.com/logiover/reddit-search-scraper) | Full subreddit feeds |
| [YouTube Search Scraper](https://apify.com/logiover/youtube-search-scraper) | Videos & channels by keyword |
| [Bluesky-style discovery via Hacker News Search](https://apify.com/logiover/hacker-news-historical-archive-scraper) | Tech discussion by keyword |
| [Substack Newsletter Scraper](https://apify.com/logiover/substack-newsletter-scraper) | Newsletter posts & authors |
| [LinkedIn Top Content Scraper](https://apify.com/logiover/linkedin-top-content-scraper) | Top posts by keyword/creator |
👉 Browse all **[logiover scrapers on Apify Store](https://apify.com/logiover)** — 180+ actors across real estate, jobs, crypto, social media & B2B data.
### ⏰ Scheduling & integration
Schedule this Actor on Apify to track handles, tags and conversations daily or weekly. Export results to JSON, CSV or Excel, sync to Google Sheets, or push to your database, BI tools and webhooks through the Apify API. Connect it to **Make, n8n or Zapier** to build automated social-listening pipelines.
### ⭐ Support & feedback
Found a bug or need an extra field? Open an issue on the **Issues** tab — response is usually fast. If this Actor saves you time, a **★★★★★ review** on the Store page genuinely helps and is hugely appreciated. 🙏
### ⚖️ Legal
This Actor collects only publicly available Threads data and accesses no private or login-gated content. You are responsible for using the data in line with Threads' / Meta's Terms, applicable laws (including GDPR/CCPA) and privacy regulations. Do not use scraped personal data for spam or unlawful purposes.
***
This Actor is an independent tool. It is not affiliated with, endorsed by, or sponsored by Threads; Threads and all other trademarks mentioned here are the property of their respective owners.
### How much Threads data can you extract in one run?
A single run returned **25 posts** in 17 seconds on the example input. That example is deliberately narrow; the result limit and the input list are both yours to widen. That is roughly **88 posts a minute**.
There is no hard ceiling built into this Actor. What bounds a run is the result limit you set, the breadth of the input you give it, and how much Threads itself publishes. Because billing is per result, a wider run costs proportionally more and a narrow one costs almost nothing — so it is worth starting small and scaling once the output looks right.
### Threads scraping — frequently asked questions
#### Do I need a Threads API key, account or login?
No. This Actor reads publicly available pages and feeds, so there is nothing to register for and no credentials to manage.
#### How do I export Threads data to CSV, Excel, JSON or Google Sheets?
Open the **Storage** tab after a run and pick the format you want — CSV, Excel, JSON, XML or an HTML table. For Google Sheets, Airtable or a database, use the dataset URL or the Apify API so the sheet refreshes itself on every run.
#### Can I schedule this Threads scraper to run daily or hourly?
Yes. Use the **Schedules** tab and pick a cadence. Daily is enough for most tracking work; pick hourly only if the posts you care about really do change that fast.
#### How many posts can I get, and what does it cost?
See the volume section above for a measured figure. Billing is per result, so you pay for the rows you actually receive and a run that finds nothing costs nothing.
#### Is scraping Threads legal?
This Actor collects only information that Threads publishes publicly. It does not log in, does not defeat access controls and does not touch private data. You remain responsible for how you use the output, including under GDPR and similar rules where personal data is involved.
#### What happens if Threads blocks the run or changes its layout?
A refused exit IP is swapped for a fresh one within a quarter of a second and retried, and rate limiting is waited out rather than fought. If nothing gets through, the run **fails with the reason** instead of reporting success with zero rows — so an empty result always means "no matches", never "the source would not answer".
#### Can I use this with an AI agent, LangChain or an MCP client?
Yes. The Actor is callable over the Apify API and through Apify's MCP server, so an agent can run it and read the dataset back as a tool call.
### 📝 Changelog
#### 2026-11-01
- Monthly health check (2026-11-01): a live run on the current build completed successfully and returned data. Input options, output fields and pricing are unchanged.
- README refreshed: 2 links to renamed Actors updated, 2 links to retired Actors removed; independence disclaimer added.
#### 2026-10-15
- Every request now has a hard time limit, so a proxy connection that stalls can no longer hold up the run or push it past its timeout.
- A run that reaches its maximum cost per run now stops cleanly with its results saved and a status message, instead of ending as aborted.
- A proxy group your account cannot use no longer stops the run at start-up; it falls back to the default Apify Proxy.
- Runs with a short timeout (API and AI-agent calls) now finish inside it with what they collected, instead of being cut off.
- Memory is managed within the run's own limit, which removes a rare out-of-memory crash on large pages.
#### 2026-09-23
- Fleet-wide quality audit. Verified end to end against live data and re-checked the input schema, the output columns and the run configuration.
- Output verified on a live run: 18 columns returned, 77.6% of cells populated.
- Run reliability reviewed: 99.5% of public runs succeeded in the last 30 days.
- Input schema, output schema and pricing configuration reviewed.
- Noted that 2 column(s) came back empty in this sample (`lang`, `hashtags`); these are under review.
#### 2026-09-01
- Fleet-wide health check. Verified against this Actor's real run history: 30-day success rate, output row counts, per-field fill rates, and peak memory against the configured memory limit.
- Reviewed for the failure patterns that have cost this fleet runs — unguarded proxy setup, retry loops that can outlast the run's own time budget, and full-page HTML parsing that can exhaust a small container.
- No change to input, output fields or scraping logic.
#### 2026-08-12
- Runs are now roughly 250x cheaper. Measured on identical input: $0.6011 → $0.0024.
- Switched the default proxy from the RESIDENTIAL group to datacenter. Threads does
not block datacenter IPs — verified side by side, both tiers return the same posts
and datacenter is faster. A proxy is still required; direct requests get an
interstitial. Residential remains available and is used automatically if datacenter
ever fails to return a usable page.
- Profile pages are now read over plain HTTP first. The browser pass is kept only as a
fallback for when HTTP returns nothing, so most runs no longer launch Chromium at
all — faster, lighter, and without the intermittent proxy tunnel failures.
- Restored profile scroll depth and patience that had been cut to save bandwidth.
- More retries before changing proxy tier, so a single transient failure no longer
pulls an entire run onto the expensive path.
#### 2026-08-11
- Maintenance release: refreshed the build and dependencies.
- Re-verified live execution, non-empty structured output and dataset field/type integrity.
- Reviewed reliability (retries, pagination) and output quality as part of a full-fleet QA pass.
#### 2026-08-01
- Completed the August 2026 full health check: verified empty/programmatic default, Console UI default, and two source-informed alternative inputs on Apify.
- Confirmed successful live execution, non-empty structured output, dataset-field/type integrity, and logical sample quality within the 5-minute quality window.
- Declared 18 dataset fields from typed live cloud samples so the output contract is no longer an empty placeholder.
- Declared 18 nullable dataset fields from typed live cloud samples so the output contract is no longer an empty placeholder or brittle to sparse modes.
#### 2026-07-06
- ✨ README overhaul: standardized structure, richer output sample, three ready-to-run example scenarios, expanded social-media cross-links, and clearer quick-start.
#### 2026-07-01
- Maintenance pass: re-verified end-to-end on live data and confirmed successful runs within the 5-minute quality window on the default input.
- Sharpened Store metadata (SEO title & description) and expanded the FAQ with high-intent, long-tail questions for easier discovery in Google and Apify Store search.
- Added ready-to-run example tasks that cover common real-world use cases.
#### 2026-06-15
- Reliability pass: re-verified end-to-end on live data with real-world inputs. Routine maintenance build.
#### 2026-06-07
- Docs: added coverage for using the Actor as an unofficial Threads API alternative, exporting Threads data to CSV/JSON, and scraping a Threads profile without an API key.
#### 2026-06-05
- 🛡️ Reliability fix: results are no longer dropped by strict output validation — runs now complete cleanly even at high volume (thousands of results).
- ⚡ Stability & performance hardening; fresh rebuild.
***
\*Maintained: last verified 2026-11-01 — checked end-to-end against live run history (reliability, output fields and types, and time/memory budgets).
# Changelog
This Actor's version history is a separate document: https://apify.com/logiover/threads-scraper/changelog.md
# Actor input Schema
## `usernames` (type: `array`):
Threads @handles or profile URLs to scrape posts from. Examples: 'zuck', '@mosseri', 'https://www.threads.com/@natgeo'.
## `postUrls` (type: `array`):
Specific Threads post URLs to scrape (the post plus its visible reply thread). Example: 'https://www.threads.com/@zuck/post/DY11ZLWG_eY'.
## `searchTerms` (type: `array`):
Keywords or #tags to search public Threads posts for. Examples: 'ai', '#travel', 'startup'.
## `maxResults` (type: `integer`):
Maximum posts to collect per target (timeline + expanded reply threads). 0 = unlimited (recommended for max volume). With reply expansion on, a single profile can yield several hundred posts.
## `includeReplies` (type: `boolean`):
Open each target post's page to also collect its reply thread (~25-30 posts each). This is the main volume multiplier — it turns a ~26-post profile into several hundred posts. Uses cheap HTTP fetches, no extra browser.
## `expandFromProfiles` (type: `boolean`):
When 'Include reply threads' is on, also expand the reply thread of each post collected from a profile timeline.
## `expandFromSearch` (type: `boolean`):
When 'Include reply threads' is on, also expand the reply thread of each post returned by a search term / tag. Off by default (search posts come from many authors).
## `maxExpandPerTarget` (type: `integer`):
How many of a target's own posts to open for reply expansion. Higher = more rows but more HTTP requests. Default 30 covers a full profile timeline.
## `maxRepliesPerPost` (type: `integer`):
Cap on how many reply posts to keep from each expanded post page. Default 50.
## `proxyConfiguration` (type: `object`):
A proxy is required — Threads serves an interstitial to direct requests. The datacenter default is enough and returns the same posts as residential, slightly faster. Only switch to the RESIDENTIAL group if you start seeing empty results.
## Actor input object example
```json
{
"usernames": [
"zuck",
"https://www.threads.com/@mosseri"
],
"postUrls": [
"https://www.threads.com/@zuck/post/DY11ZLWG_eY"
],
"searchTerms": [
"ai",
"#travel"
],
"maxResults": 220,
"includeReplies": true,
"expandFromProfiles": true,
"expandFromSearch": false,
"maxExpandPerTarget": 12,
"maxRepliesPerPost": 15,
"proxyConfiguration": {
"useApifyProxy": true,
"apifyProxyCountry": "US"
}
}
```
# Actor output Schema
## `results` (type: `string`):
All records extracted by this run. Open the Dataset tab to browse, filter, and export as CSV, JSON, or Excel.
# 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 = {
"usernames": [
"zuck"
],
"maxResults": 220,
"maxExpandPerTarget": 12,
"maxRepliesPerPost": 15,
"proxyConfiguration": {
"useApifyProxy": true,
"apifyProxyCountry": "US"
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("logiover/threads-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"usernames": ["zuck"],
"maxResults": 220,
"maxExpandPerTarget": 12,
"maxRepliesPerPost": 15,
"proxyConfiguration": {
"useApifyProxy": True,
"apifyProxyCountry": "US",
},
}
# Run the Actor and wait for it to finish
run = client.actor("logiover/threads-scraper").call(run_input=run_input)
# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
print(item)
# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start
```
## CLI example
```bash
echo '{
"usernames": [
"zuck"
],
"maxResults": 220,
"maxExpandPerTarget": 12,
"maxRepliesPerPost": 15,
"proxyConfiguration": {
"useApifyProxy": true,
"apifyProxyCountry": "US"
}
}' |
apify call logiover/threads-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,logiover/threads-scraper"
}
}
}
```
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/aJ3YkjI9lFva5zbFe/builds/xi6EqmqrVx4pMmakY/openapi.json