# Threads Creator Finder — Find Influencers by Topic (`northbound-data/threads-creator-finder`) Actor

Find Threads (Meta) creators talking about any topic, enriched with follower counts, bios and bio links — plus how they actually perform on that topic (posts, likes, replies). Ranks by topic engagement, not raw follower count. No login, no cookies.

- **URL**: https://apify.com/northbound-data/threads-creator-finder.md
- **Developed by:** [Northbound Data](https://apify.com/northbound-data) (community)
- **Categories:** Social media, Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $14.00 / 1,000 creators

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Threads Creator Finder — Find Influencers by Topic

Give it a topic. Get back the **Threads (Meta) creators actually talking about it**, with follower counts, bios, bio links — and how each one really performs on that topic.

**No login. No cookies. No account of yours is ever used.**

***

### What makes this different

Most influencer tools rank creators by follower count. That tells you who is big. It does not tell you who is **relevant**.

This Actor ranks by **engagement earned on your topic**. Every record includes:

| Field | Why it matters |
|---|---|
| `likes_on_topic` | How much the audience actually responded when this creator posted about *your* topic |
| `posts_on_topic` | Whether this is a recurring theme for them or a one-off |
| `replies_on_topic` | Whether their topic posts start conversations |
| `latest_post_url` | Read the post yourself before you reach out |

A creator with 600 followers and 2,100 likes on your topic is often a better partner than one with 500,000 followers and 12. This Actor shows you both numbers so you can tell the difference.

### Built on deep search

Threads exposes five separate public search surfaces (`default`, `recent`, `top`, `users`, `tags`), each capped by Meta at ~20 results but each returning a *different* set. Tools that query only the default surface see roughly a third of what is there.

This Actor queries **all five and merges them**, then aggregates the authors. Measured: a single topic yields ~50 posts from **~39 distinct creators**, against ~20 posts from a single surface.

This is not a bypass — every surface is the same public endpoint the Threads website itself uses, read logged-out.

### Filters that save you money

| Filter | Effect |
|---|---|
| `minFollowers` | Skip creators below a follower threshold |
| `maxFollowers` | Skip creators above one — pair with `minFollowers` to isolate a band |
| `requireBioLink` | Keep only creators with an external link in their bio — usually the ones open to business contact |
| `maxCreatorsPerTopic` | Cap per topic, ranked by topic engagement |
| `enrichProfiles: false` | Skip profile enrichment for a much faster, cheaper run |

Filtered-out creators are **never pushed and never billed**. Creators appearing under several topics are deduplicated and billed once.

***

### Why residential proxy is the default

Meta serves **empty shell pages to datacenter IPs**. When that happens this Actor falls back to full browser rendering, which still returns correct data but is dramatically slower and more expensive.

Measured on the Apify platform, same target, same day (2026-08-19):

| Proxy | Mode used | Time per profile | Compute cost per run |
|---|---|---|---|
| Datacenter (Apify default) | browser rendering | **150 s** | $0.127 |
| Residential | direct fetch | **3.3 s** | $0.0086 |

That is 45x faster and 15x cheaper, for a residential transfer cost of roughly 7% of what the returned records are worth. So `RESIDENTIAL` ships as the default proxy group.

You can override it, but if you switch to datacenter expect slow runs — the Actor will still work, it just has to render every page.

***

### Input

```json
{
  "topics": ["ai agents", "sustainable fashion"],
  "maxCreatorsPerTopic": 40,
  "minFollowers": 1000,
  "maxFollowers": 20000,
  "requireBioLink": true,
  "enrichProfiles": true,
  "maxItems": 1000
}
```

| Field | Type | Notes |
|---|---|---|
| `topics` | array | Topics to find creators for. Each is searched across all five public search surfaces. |
| `maxCreatorsPerTopic` | integer | Default `10`. Creators per topic, ranked by engagement earned on that topic. |
| `minFollowers` | integer | Default `0`. Skip creators below this follower count. Filtered-out creators are never billed. |
| `maxFollowers` | integer | No upper limit by default. Skip creators above this count. Set both to target a band — `1000`–`20000` isolates micro-influencers. Creators whose follower count could not be read are kept, not silently dropped. |
| `requireBioLink` | boolean | Default `false`. Keep only creators with an external link in their bio — usually those open to business contact. |
| `enrichProfiles` | boolean | Default `true`. Fetch each creator's profile for follower count, bio and bio link. Set `false` for a much faster, cheaper run that returns topic-activity data only. |
| `maxItems` | integer | Hard cap on billed records. Your safety net. |
| `proxyConfiguration` | object | Defaults to `RESIDENTIAL`. See the section above — datacenter IPs get shell pages from Meta and force slow rendering. |

### Output

One record per creator:

```json
{
  "username": "alexandro_ai",
  "profile_url": "https://www.threads.com/@alexandro_ai",
  "full_name": "Alexandro",
  "is_verified": false,
  "follower_count": 8104,
  "biography": "Testing and showing how AI can…",
  "external_url": "https://example.com",
  "topic": "ai agents",
  "posts_on_topic": 1,
  "likes_on_topic": 801,
  "replies_on_topic": 12,
  "latest_post_url": "https://www.threads.com/@alexandro_ai/post/XXXX",
  "latest_post_at": "2026-08-14T09:12:00.000Z",
  "scraped_at": "2026-08-15T08:40:00.000Z"
}
```

Every run also writes a `RUN_SUMMARY` with `topics`, `creatorsDelivered`, `failedTopics` and `failureRate`, so you can audit reliability yourself.

### Honest limitations

- Meta caps each public search surface at ~20 results. Merging all five gives ~50 posts per topic, which is where the ~39 creators come from. **This finds the creators currently visible on a topic, not an exhaustive historical index.** Anything promising a complete creator database without an account is not telling you the truth.
- `follower_count` comes from the public profile page. A small number of profiles do not expose it; those records carry `null` rather than a guess.
- No email addresses. Threads does not publish them, and we do not invent or infer contact details.

### What it's used for

- **Influencer marketing and partnership scouting** — find topic-relevant Threads influencers,
  not just accounts with big follower counts
- **Micro-influencer sourcing** — the `minFollowers` / `maxFollowers` window is there precisely
  so you can isolate micro influencers, who often out-convert large accounts on a niche topic
- **Brand ambassador discovery** — surface people already posting about your product, unpaid,
  before you approach anyone
- **UGC creator search** — find Threads UGC creators making real content in your category
- **Niche community mapping** — see who actually drives a conversation in a small community
- **Audience research** — read a topic's active voices before you plan a campaign
- **Competitive monitoring** — track who is posting about a competitor
- **AI agents & RAG** — clean JSON in, no HTML parsing

#### Why "by topic" is the whole point

A creator with 200,000 followers who mentioned your category once is worth less to you than a
creator with 4,000 followers whose posts on that exact topic earn hundreds of likes. This Actor
ranks by **engagement earned on your topic**, not by follower count, which is why it is useful
for micro influencer and brand ambassador work where relevance beats reach.

**The official Threads API cannot do this at any permission level** — its insights cover your own
posts only, and there is no endpoint for another account's profile feed. Creator discovery is one
of the few things that genuinely requires reading public pages. See the
[API-vs-scraping comparison](https://zhanghengrui0308.github.io/threads-data-client/threads-api-vs-scraping/).

### Pricing

Pay per creator delivered. Filtered-out and duplicate creators are never billed. `maxItems` caps your spend.

### Related

- **Threads Scraper — Posts, Profiles, Replies & Search**
- **Threads Search Scraper — Keyword Search to JSON**

### The numbers behind this page

Everything this Actor claims about Threads' logged-out ceilings — the ~20 reply
cap, the five search surfaces, the four profile tabs, and the empty shell page
Meta serves to datacenter IPs as a valid HTTP 200 — is written up with the
measurements, dates and method here:

**[What Threads actually returns when you are not logged in](https://zhanghengrui0308.github.io/threads-data-client/)**

It is a reference, not a sales page. If you are evaluating any Threads scraper,
including someone else's, those are the limits to test them against.

***

### Open-source client

There is a small MIT-licensed JavaScript client for this Actor, so you do not
have to write the run-start / polling / dataset-pagination plumbing yourself:

**[github.com/zhanghengrui0308/threads-data-client](https://github.com/zhanghengrui0308/threads-data-client)** — zero dependencies, Node 18+.

```js
import { ThreadsClient } from 'threads-data-client';

const threads = new ThreadsClient(process.env.APIFY_TOKEN);

const creators = await threads.findCreators(['sustainable fashion'], { maxItems: 100 });
```

It also exposes `estimateCost(actor, records, tier)`, which tells you the exact
USD bill for a run before you start it, at your own plan tier.

You do not need it — the Actor works fine from the Apify Console, the API, or
any HTTP client. It is there if you would rather read the code than trust a
description of it.

***

### Legal & scope

Reads **public** Threads pages only. No login, no cookies, no CAPTCHA solving, no access-control circumvention. **On `robots.txt`, stated plainly:** `threads.com/robots.txt` runs an allowlist. Named crawlers
(Googlebot, Bingbot, GPTBot, ClaudeBot and others) are granted specific access; for every other user
agent the file says `Disallow: /`, and its opening notice states that automated collection requires
express written permission from Meta. **This Actor is not on that allowlist.** We say so because you
should decide with the real facts rather than a comfortable summary, and because you are the party
accountable for how the data is collected and used under Meta's terms and applicable law. Creator profiles are personal data — you are responsible for GDPR/CCPA compliance in how you use and store them.

# Actor input Schema

## `topics` (type: `array`):

Topics or keywords to find creators for. Each topic is searched across all five of Threads' public search surfaces, then the authors are aggregated and ranked by how much engagement they earned on that topic.

## `maxCreatorsPerTopic` (type: `integer`):

How many creators to return per topic, ranked by engagement on that topic.

## `minFollowers` (type: `integer`):

Skip creators below this follower count. Set 0 to keep everyone, including micro-creators.

## `maxFollowers` (type: `integer`):

Skip creators above this follower count. Use with Minimum followers to target a band — e.g. 1000–20000 isolates micro-influencers, who often out-convert large accounts on a niche topic. Leave empty for no upper limit.

## `requireBioLink` (type: `boolean`):

Keep only creators who have an external link in their bio — usually the ones open to business contact.

## `enrichProfiles` (type: `boolean`):

Fetch each creator's profile for follower count, bio and bio link. Turn off for a much faster, cheaper run that returns only topic-activity data.

## `maxItems` (type: `integer`):

Hard cap on billed records. Your safety net against unexpected charges. The default of 100 keeps a first trial run cheap; raise it for production runs.

## `proxyConfiguration` (type: `object`):

Proxy settings. RESIDENTIAL is the default and strongly recommended: Meta serves empty shell pages to datacenter IPs, which forces this Actor into slow browser rendering. Measured on 2026-08-19: datacenter took 150s per profile, residential took 3.3s — 45x faster and 15x cheaper in compute. Residential transfer is billed by Apify at ~7% of what these results are worth.

## Actor input object example

```json
{
  "topics": [
    "ai agents"
  ],
  "maxCreatorsPerTopic": 10,
  "minFollowers": 0,
  "requireBioLink": false,
  "enrichProfiles": true,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `creators` (type: `string`):

One record per creator: username, follower count, bio, bio link, and how they performed on the topic (posts, likes, replies).

## `runSummary` (type: `string`):

Reliability report: topics attempted, creators delivered, failed topics and failureRate.

# 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 = {
    "topics": [
        "ai agents"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("northbound-data/threads-creator-finder").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 = { "topics": ["ai agents"] }

# Run the Actor and wait for it to finish
run = client.actor("northbound-data/threads-creator-finder").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 '{
  "topics": [
    "ai agents"
  ]
}' |
apify call northbound-data/threads-creator-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,northbound-data/threads-creator-finder"
        }
    }
}

```

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 <APIFY_API_TOKEN>` 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/B4TWrq5C6iKFJEqX3/builds/vpYbTR4R37gogho7y/openapi.json