# TikTok Creator Finder — Influencer Discovery ✅ (`nexascout/hermes-tiktok-creator-finder`) Actor

Find TikTok creators by niche and build influencer shortlists with follower counts, activity, topic relevance and engagement metrics from discovered videos.

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

## Pricing

from $9.00 / 1,000 creator profiles

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

## TikTok Creator Finder — Influencer Discovery

Find TikTok creators in your niche and turn keyword searches into a ranked influencer shortlist. Compare public profile details, follower counts, topic relevance, posting activity and engagement from the videos discovered in each run.

Built for influencer discovery, brand partnerships, creator outreach research and niche analysis. No TikTok login or TikTok API key is required.

### What you get

One dataset row per creator, deduplicated by creator ID. Creators are ranked by topic relevance, then the age of their newest discovered video, then followers.

- **Profile:** username, display name, bio, verification status, avatar and available public counters.
- **Activity:** age of the newest discovered video and an activity tier.
- **Performance:** average video views, average view-based engagement and average views relative to followers.
- **Relevance:** a 0–100 keyword-based score, matched terms and the strongest matching query.
- **Evidence:** discovered videos with public metrics and the creator's matching `sourceQueries`. If one video appears under multiple queries, those queries are retained while the video is counted once.

### Quick start

1. Enter 1–10 niche keywords, such as `skincare routine` and `makeup tutorial`.
2. Select search localization and optional follower, activity, language or relevance filters.
3. Choose a creator limit and run the Actor.
4. Review the dataset and export it as JSON, CSV or Excel.

Start broadly, then tighten filters. `maxCreators` is an upper limit; discovery depth, availability and filters can produce fewer results.

#### Example input

```json
{
  "searchQueries": ["skincare routine", "makeup tutorial"],
  "region": "US",
  "minFollowers": 1000,
  "maxFollowers": 100000,
  "maxInactiveDays": 90,
  "activityMatch": "strict",
  "language": "en",
  "languageMatch": "strict",
  "minRelevance": 20,
  "maxCreators": 25,
  "maxCandidatesPerQuery": 30,
  "maxPagesPerQuery": 2,
  "maxRunSeconds": 180,
  "includeRecentVideos": true
}
```

This example targets a focused shortlist. Remove filters if your initial search is too narrow.

### Input guide

| Setting | Default | How to use it |
| --- | --- | --- |
| `searchQueries` | `["hiking"]` in Console | 1–10 nonempty keyword phrases; required when supplying your own input. |
| `region` | `US` | Uppercase two-letter search-localization code. This is not a creator or audience country filter. The default proxy country is configured separately as US. |
| `minFollowers`, `maxFollowers` | `0`, `0` | Set follower bounds; 0 disables that bound. Unknown follower counts remain eligible. |
| `verifiedOnly` | `false` | Include only profiles marked verified when enabled. |
| `maxInactiveDays` | `0` | Maximum age of the newest discovered video; 0 disables the filter. |
| `activityMatch` | `lenient` | When the activity filter is enabled, `strict` excludes unknown activity; `lenient` keeps it. |
| `minRelevance` | `0` | Minimum keyword-based relevance score from 0 to 100. |
| `language` | `any` | Use `any` or a lowercase two-letter language code, such as `en`. |
| `languageMatch` | `lenient` | With a language filter, `strict` excludes undetected language. Both modes exclude a different detected language. |
| `maxCreators` | `25` | Maximum creator rows, from 1 to 200. |
| `maxCandidatesPerQuery` | `30` | Videos requested per search page, from 1 to 100. |
| `maxPagesPerQuery` | `2` | Search pages per keyword, from 1 to 5. |
| `maxRunSeconds` | `180` | Soft collection budget, from 30 to 240 seconds. |
| `includeRecentVideos` | `true` | Include discovered video objects. When false, `recentVideos` contains an integer count instead. |
| `proxyConfiguration` | Apify residential proxy, US | Residential proxies are the default. Keep proxy country aligned with your intended search localization. |

Increasing search depth requests more candidates; it does not guarantee more eligible creators.

### Output fields and metric definitions

| Fields | Meaning |
| --- | --- |
| `authorId`, `uniqueId`, `nickname`, `bio`, `verified`, `avatarUrl` | Creator identity and available public profile details. |
| `followers`, `heartCount`, `videoCount`, `followingCount` | Available profile counters. A missing value is `null`, not zero. |
| `lastUploadDaysAgo`, `activityTier` | Age of the newest discovered video. Tiers: very active ≤30 days, active ≤90, dormant ≤365, inactive >365, or unknown. |
| `avgViewsPerVideo` | Arithmetic mean of available views across discovered videos. |
| `engagementRatePct` | Mean of each eligible video's `100 × (likes + comments + shares) / views`. Missing interaction components are treated as zero when at least one is available. |
| `avgReachMultiple` | Mean video views divided by the available creator follower count, where both are positive. |
| `topicConfirmation` | Keyword-based relevance score, confidence, matched terms and strongest matching query. |
| `language`, `languageConfidence`, `languageOrigin` | Estimated language from bio and video-description text; undetected language is `null`. |
| `discoveredVideos`, `recentVideos` | Number of discovered videos and their details, or a count in compact mode. |
| `sourceQueries` | Search queries that led to this creator, including cross-query video matches. |

Performance metrics describe the discovered sample. They do not measure the creator's whole catalog or audience demographics. Engagement is view-based, not follower-based.

### API and integrations

Run through the Apify API using the Actor ID `jrji0RKG4kmshtyHH`:

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

Send an input JSON object like the example above, then retrieve items from the run's default dataset. You can also save your input as an Apify Task for repeated research and connect dataset exports to your own analysis workflow.

### Result quality and troubleshooting

- **Fewer rows than requested:** broaden keywords, relax filters or increase search depth within the input limits. Empty results can be valid when no discovered creators pass your filters.
- **Unknown language or activity:** use the lenient policy to retain unknowns, or strict to exclude them.
- **No matches for a niche:** try natural phrases used in video captions and a few related keywords.
- **Collection failures:** check the run log and run summary. Search availability, blocking and upstream changes can affect results; a completed run can still contain partial or empty output.

This is a bounded search sample, not a complete directory of TikTok accounts. Search ranking favors discoverable videos. The newest discovered video may be older than the creator's actual latest upload, so activity is an upper bound on inactivity.

Language detection uses text heuristics and can misclassify multilingual or short text; it does not analyze spoken audio. Relevance is a keyword signal, not an independently verified niche label. Public counters may be unavailable, rounded or updated in batches. No verified contact-email enrichment, audience-country verification or private-account content is provided.

### Pricing

Pay per event: **$0.05 per run start + $0.009 per creator profile written to the dataset**.

| Creator profiles returned | Event charges |
| --- | --- |
| 0 | $0.05 |
| 25 | $0.275 |
| 100 | $0.95 |

The start fee applies once with the supported 512 MB–1 GB memory allocation, including runs with no matching creators. Each unique creator written in a run is charged once, even if several queries discover that creator. Returning the same creator on a later run is charged again. Including discovered video details does not add per-video charges.

Set a maximum charge for each run to control spending. The minimum allowed run budget is $0.06. If the remaining budget cannot cover another creator, the Actor stops output and reports a partial result. With a $0.07 limit, for example, the start fee and up to two creator profiles fit within the budget.

Current event prices are shown in the Pricing tab.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to search on organic TikTok (up to 10).

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

Two-letter region for search localization + residential proxy country.

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

Minimum follower count (0 = no filter).

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

Maximum follower count (0 = no filter).

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

Only include verified creators.

## `maxInactiveDays` (type: `integer`):

Exclude creators whose most recent discovered video is older than this (0 = no filter).

## `activityMatch` (type: `string`):

How to treat creators with unknown activity: lenient (include) or strict (exclude).

## `minRelevance` (type: `integer`):

Minimum topic relevance score (0-100) to include.

## `language` (type: `string`):

Filter by detected language (2-letter code) or 'any'.

## `languageMatch` (type: `string`):

How to treat creators with undetectable language: lenient (include) or strict (exclude).

## `maxCreators` (type: `integer`):

Maximum creators to emit.

## `maxCandidatesPerQuery` (type: `integer`):

Videos to request per search page.

## `maxPagesPerQuery` (type: `integer`):

Search pages to fetch per keyword.

## `maxRunSeconds` (type: `integer`):

Soft collection time budget.

## `includeRecentVideos` (type: `boolean`):

Emit each creator's discovered videos (else just the count).

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

Residential proxy for the TikTok API requests.

## Actor input object example

```json
{
  "searchQueries": [
    "hiking"
  ],
  "region": "US",
  "minFollowers": 0,
  "maxFollowers": 0,
  "verifiedOnly": false,
  "maxInactiveDays": 0,
  "activityMatch": "lenient",
  "minRelevance": 0,
  "language": "any",
  "languageMatch": "lenient",
  "maxCreators": 25,
  "maxCandidatesPerQuery": 30,
  "maxPagesPerQuery": 2,
  "maxRunSeconds": 180,
  "includeRecentVideos": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

Ranked unique creator profiles with available public metrics and discovered-video evidence.

## `summary` (type: `string`):

Returned creator count, applied filters, coverage and any collection or budget limit.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("nexascout/hermes-tiktok-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 = {}

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

```

## MCP server setup

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