# Influencer Discovery & Email Finder Tool (`receptional_blender/influencer-discovery`) Actor

Find Instagram, TikTok and YouTube creators by niche and turn them into enriched, contactable influencer leads with public emails and engagement signals.

- **URL**: https://apify.com/receptional\_blender/influencer-discovery.md
- **Developed by:** [Assia Fadli](https://apify.com/receptional_blender) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 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.

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

## Influencer Discovery

Find the creators worth reaching out to. **Influencer Discovery** searches
**Instagram**, **TikTok**, or **YouTube** by niche, visits each candidate
profile, and returns an enriched, contactable **influencer lead** — handle,
display name, follower/engagement signals, bio, external links, and any public
email the creator has published.

Point it at a topic (or a few seed profiles), set your follower band, and get a
clean list of leads ready for outreach, sponsorships, and campaign shortlists.

***

### What it does

1. **Search** — For each niche/keyword/hashtag, opens the platform's hashtag or
   search page and gathers candidate creator handles. You can also seed the run
   with specific profiles to expand from.
2. **Enrich** — Visits every candidate and pulls handle, display name, profile
   URL, followers, following, post count, bio, and external links.
3. **Find contact** — Extracts a public email from the bio and linked pages
   (`extractEmails`).
4. **Score & filter** — Estimates an engagement rate from publicly visible
   signals when available, then filters by follower band and minimum engagement.
5. **Dedupe & cap** — Removes duplicates by handle and stops at `maxItems`.

***

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `platform` | enum (`instagram`, `tiktok`, `youtube`) | `instagram` | Network to search. |
| `niches` | array of strings | – | Keywords/hashtags to discover creators (e.g. `fitness`, `#vegancooking`). The `#` is optional. |
| `seedProfiles` | array of strings | – | Optional profile URLs/handles to start from and expand (e.g. `@nike`). |
| `minFollowers` | integer | `1000` | Keep creators with at least this many followers. |
| `maxFollowers` | integer | `1000000` | Keep creators with at most this many followers. |
| `minEngagementRate` | number | `0` | Minimum estimated engagement rate (%). `0` disables the filter. |
| `maxItems` | integer | `100` | Maximum number of leads delivered to the dataset. |
| `extractEmails` | boolean | `true` | Parse public emails from bios/links. |
| `proxyConfig` | object | Residential | Proxy settings. Residential strongly recommended. |

At least one of `niches` or `seedProfiles` is required.

> **Aliases:** the original creator-finder field names are still accepted, so
> existing input configs keep working — `proxyConfiguration` maps to
> `proxyConfig`, `keywords` to `niches`, `seeds` to `seedProfiles`, and
> `limit` / `maxResults` to `maxItems`.

#### Example input

```json
{
    "platform": "instagram",
    "niches": ["fitness", "#homeworkout"],
    "seedProfiles": ["@gymshark"],
    "minFollowers": 5000,
    "maxFollowers": 250000,
    "minEngagementRate": 1.5,
    "maxItems": 100,
    "extractEmails": true,
    "proxyConfig": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
```

***

### Output

Each dataset item is one influencer lead:

```json
{
    "platform": "instagram",
    "handle": "janedoefit",
    "displayName": "Jane Doe | Home Fitness",
    "profileUrl": "https://www.instagram.com/janedoefit/",
    "followers": 84500,
    "following": 612,
    "postCount": 1340,
    "bio": "Home workouts & meal plans. Coaching inquiries: jane@janedoefit.com",
    "externalLinks": ["https://linktr.ee/janedoefit"],
    "email": "jane@janedoefit.com",
    "hasEmail": true,
    "engagementRate": 3.21,
    "niche": "fitness",
    "source": "discovery",
    "scrapedAt": "2026-07-21T12:00:00.000Z"
}
```

Fields that cannot be extracted are returned as `null` (never omitted), so
downstream schemas stay stable.

***

### Pricing — pay per event

This actor uses Apify's **pay-per-event** model. It charges a single event,
**`profile-scraped`**, once per influencer lead that is actually delivered to
the dataset. Discovery/search pages are never charged, and charging is
deliver-then-charge: the record is pushed first, then the event fires. When your
run's event budget is reached, the crawl stops gracefully — you are only billed
for leads you received.

Tip: set `extractEmails: true` and a realistic follower band to maximize the
share of contactable leads per run.

***

### Limitations & reality notes

- **Anti-bot**: Instagram and TikTok deploy aggressive bot detection, rate
  limiting, and login walls. Expect blocking without good **residential
  proxies**, and reduced yield on discovery pages that require authentication.
  YouTube is generally the most permissive.
- **Selectors drift**: these platforms change their DOM and embedded-JSON shapes
  often. All per-platform URL builders and selectors live in `src/platforms.ts`
  so they can be tuned in one place. Extraction is defensive — missing fields
  degrade to `null` instead of crashing.
- **Engagement rate is an estimate**: computed from publicly visible signals
  only when those signals are exposed; otherwise it is `null` and the engagement
  filter is skipped for that profile.
- **Emails are only public ones**: the actor extracts emails creators publish
  themselves in bios/links. It does not guess, verify deliverability, or bypass
  any access controls.

***

### Legal & compliance

Only public data is collected. You are responsible for using the output in
compliance with each platform's Terms of Service and applicable
data-protection / marketing laws (e.g. GDPR / CAN-SPAM) when contacting leads.

***

Author: **Assia Fadli** · License: **MIT**

# Actor input Schema

## `platform` (type: `string`):

Which social network to search for creators on.

## `niches` (type: `array`):

Topics used to discover creators — plain keywords or hashtags both work (e.g. "fitness", "#vegancooking", "travel"). The leading # is optional.

## `seedProfiles` (type: `array`):

Optional profile URLs or handles to start from and expand (e.g. "@nike", "https://www.instagram.com/nike/"). Use alongside, or instead of, niche search.

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

Keep only creators with at least this many followers.

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

Keep only creators with at most this many followers.

## `minEngagementRate` (type: `number`):

Keep only creators whose estimated engagement rate (avg interactions / followers, in percent) is at least this value. Set 0 to disable.

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

Maximum number of influencer leads to deliver to the dataset.

## `extractEmails` (type: `boolean`):

Parse public email addresses out of bios and linked pages. Leads that carry a contactable email are the high-value output.

## `proxyConfig` (type: `object`):

Proxy applied to every request. Residential proxies are strongly recommended to reduce blocking on Instagram and TikTok.

## Actor input object example

```json
{
  "platform": "instagram",
  "niches": [
    "fitness",
    "#vegancooking"
  ],
  "seedProfiles": [
    "@nike"
  ],
  "minFollowers": 1000,
  "maxFollowers": 1000000,
  "minEngagementRate": 0,
  "maxItems": 100,
  "extractEmails": true,
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "niches": [
        "fitness"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("receptional_blender/influencer-discovery").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 = { "niches": ["fitness"] }

# Run the Actor and wait for it to finish
run = client.actor("receptional_blender/influencer-discovery").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 '{
  "niches": [
    "fitness"
  ]
}' |
apify call receptional_blender/influencer-discovery --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=receptional_blender/influencer-discovery",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/XuMqpuH71rHJr11Ka/builds/LX69EWRYqtOURevc3/openapi.json