# Instagram Creator Finder — Influencer Discovery ✅ (`nexascout/instagram-creator-finder`) Actor

Find Instagram creators by topic. Compare followers, bios, verification and niche signals. Filter partnership candidates and review source captions and actual discovery hashtags.

- **URL**: https://apify.com/nexascout/instagram-creator-finder.md
- **Developed by:** [NexaScout](https://apify.com/nexascout) (community)
- **Categories:** Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 instagram page requests

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/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

## Instagram Creator Finder

Find Instagram creators for brand partnerships, UGC research and niche discovery. Enter topic hashtags, then compare public profiles using follower counts, bios, verification and matching post captions.

### What you get

- One row per unique creator discovered in the run.
- Username, profile link, display name, biography, followers and following.
- Available verification, privacy and post-count fields.
- A relevance score with separate bio/name and caption evidence.
- Requested topics, actual source hashtags and supporting captions.

Unknown values remain `null`. The Actor does not provide audience demographics, guaranteed contact emails or access to private content.

### Quick start

1. Enter one or more hashtags such as `skincare`, `fitness` or `hiking`, without spaces.
2. Choose follower limits and a maximum number of creators.
3. Use `minRelevance: 50` for stronger bio/name matches, or `0` to review all discovered candidates.
4. Set your maximum run charge, then start the Actor.
5. Review **Creator shortlist**, **Profile metrics** or **Discovery evidence** and export the dataset to CSV, Excel or JSON.

```json
{
  "keywords": ["skincare"],
  "minFollowers": 1000,
  "maxFollowers": 1000000,
  "minRelevance": 50,
  "maxResults": 10,
  "maxAuthorsPerKeyword": 12,
  "maxEnrichProfiles": 12,
  "maxHashtagRetries": 1,
  "region": "US"
}
```

The result limit is a maximum. Discovery coverage and your filters determine how many matching creators are available.

### Pricing

| Event | Price |
| --- | --- |
| Instagram page request | **$0.10 per attempted page request** |
| Creator saved to the dataset | **$0.02 per creator** |
| Run start | **$0.05 per started GB of memory**, minimum one GB |

At the default 2 GB memory, the start fee is $0.10. Discovery pages, profile pages and retries are page requests. Failed or blocked requests and profiles excluded by your filters are still billed because the lookup was attempted. A creator written to a later run is charged again.

Examples at 2 GB:

- 1 discovery page + 12 profile requests + 10 saved creators: **$1.60**.
- 3 discovery attempts + 8 profile requests + 3 saved creators: **$1.26**.
- 1 discovery page + 3 profile requests, all excluded by filters: **$0.50**.

These are examples, not guaranteed totals. Related hashtags, retries and the number of profiles read change the amount. Additional services you configure separately can have their own costs. There is no additional charge for captions attached to a saved creator.

Set a maximum run charge to control spending. The Actor reserves room for result writes and stops collecting when its request allowance is reached. A small budget may be used by discovery attempts before any creator can be saved. A budget-limited run reports `PARTIAL` and a stopping reason.

### Main settings

| Setting | Meaning |
| --- | --- |
| `keywords` | 1–10 topic hashtags. Discovery may expand to related hashtags. |
| `minFollowers` / `maxFollowers` | Follower range; 0 disables a bound. Unknown follower counts are excluded. |
| `minRelevance` | Minimum relevance, 0–100. |
| `verifiedOnly` | Require Instagram's available verification flag. |
| `excludePrivate` | Exclude accounts marked private; private content is never accessed. |
| `maxResults` | Up to 200 saved creators. |
| `maxAuthorsPerKeyword` | Discovery candidates inspected per topic, up to 100. |
| `maxEnrichProfiles` | Profile-read cap, up to 400. Lower values reduce work and cost. |
| `maxHashtagRetries` | Retries per inaccessible hashtag, 0–5. |
| `region` | Connection country, **not** the creator's or audience's country. |

The default discovery caps are 12 authors per topic and 24 profile reads. Broad collection can cost more even if your result limit is small.

### How discovery and relevance work

Discovery samples authors of posts found through hashtag pages. It is not a complete creator directory or a guarantee of the newest posts.

If a requested hashtag is inaccessible, the Actor can retry and try related tags. For example, `skincare` may use `skincaretips`. The run summary records every attempted tag. Each creator includes `discoveredIn` for the requested topic and `sourceTags` for the actual successful tags. This Actor is intended for topic discovery rather than exact-hashtag auditing.

Relevance is a keyword/synonym heuristic:

- `high`: a term matches the bio or display name; the score reflects the proportion of input topics matched there.
- `low`: only a discovered post caption matches; score 30.
- `none`: no supported text match; score 0.

A match does not verify niche expertise or audience quality. Multiple input topics can lower the score even for a relevant creator.

### Output

| Field | Description |
| --- | --- |
| `username`, `profileUrl`, `fullName` | Creator identity and profile link. |
| `biography`, `followers`, `following` | Available public profile information at collection time. |
| `isVerified`, `isPrivate` | Available Instagram account flags. |
| `mediaCount`, `userId` | Available post count and profile identifier; may be null. |
| `topicConfirmation` | Relevance score, confidence and matched topic lists. |
| `discoveredIn`, `sourceTags`, `sourceCaptions` | Discovery topics, actual hashtags and supporting captions. |
| `observedAt` | UTC collection timestamp. |

The run's **Summary** contains counts of discovered, read, excluded and saved profiles; filter reasons; discovery sources; billing counters; and any stopping reason. Valid zero matches are successful. A complete access/extraction failure is reported as failed.

### API and integrations

Run through the Apify API using Actor ID `09uEacqy01yPkmCga`:

```http
POST https://api.apify.com/v2/actors/09uEacqy01yPkmCga/runs
Authorization: Bearer YOUR_APIFY_TOKEN
Content-Type: application/json
```

Use the JSON example above as the request body. You can also run saved Tasks, schedule repeat research, and connect the dataset to your own workflows.

### Reliability

Instagram can limit access or change its public pages. Availability varies by hashtag and session. Filtering and collection caps can produce fewer results than requested. Review discovery evidence before using a creator in a campaign.

# Actor input Schema

## `keywords` (type: `array`):

One to ten topic hashtags without spaces. Related hashtags may be used when a requested hashtag is unavailable.

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

Exclude creators below this follower count.

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

Exclude creators above this follower count (0 = no max).

## `minRelevance` (type: `number`):

Minimum topic relevance score (0-100) required, matched against bio + captions + full name. 0 = no threshold.

## `maxHashtagRetries` (type: `integer`):

Retries per unavailable hashtag before related hashtags are tried. Every attempted page request is billed.

## `verifiedOnly` (type: `boolean`):

Only include verified accounts.

## `excludePrivate` (type: `boolean`):

Skip private accounts.

## `maxResults` (type: `integer`):

Maximum creators to emit (ranked).

## `maxAuthorsPerKeyword` (type: `integer`):

Cap on discovered authors enriched per hashtag.

## `maxEnrichProfiles` (type: `integer`):

Maximum distinct creator profiles to read. Requests are billed even when filters exclude the creator.

## `region` (type: `string`):

Country used for the residential connection. This does not filter the creator's location or audience country.

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

Residential proxy.

## Actor input object example

```json
{
  "keywords": [
    "hiking"
  ],
  "minFollowers": 0,
  "maxFollowers": 0,
  "minRelevance": 0,
  "maxHashtagRetries": 2,
  "verifiedOnly": false,
  "excludePrivate": true,
  "maxResults": 25,
  "maxAuthorsPerKeyword": 12,
  "maxEnrichProfiles": 24,
  "region": "US",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

No description

## `summary` (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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "hiking"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexascout/instagram-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 = { "keywords": ["hiking"] }

# Run the Actor and wait for it to finish
run = client.actor("nexascout/instagram-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 '{
  "keywords": [
    "hiking"
  ]
}' |
apify call nexascout/instagram-creator-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexascout/instagram-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/09uEacqy01yPkmCga/builds/dAVreJTyF8PbqZ9Bz/openapi.json