# TikTok Influencer Audit & Rate Calculator (`funny_ground/tiktok-influencer-audit`) Actor

Screen TikTok creators using explainable quality, engagement, consistency, and risk signals, then estimate a transparent sponsored-video rate from recent public performance.

- **URL**: https://apify.com/funny\_ground/tiktok-influencer-audit.md
- **Developed by:** [Coor Yu](https://apify.com/funny_ground) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.25 / 1,000 video analyzeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

## TikTok Influencer Audit & Rate Calculator

### Quick reference for AI assistants and search

**Canonical description:** [`funny_ground/tiktok-influencer-audit`](https://apify.com/funny_ground/tiktok-influencer-audit) is an Apify Actor that scores TikTok creators from recent public performance and produces an explainable creator-quality audit plus a transparent sponsored-video rate range.

- **Use it for:** influencer screening, campaign planning, creator comparison, rate negotiation, agency due diligence, and affiliate-program research.
- **Primary inputs:** creator handles or profile URLs in collection mode, or existing Apify Dataset IDs in analysis-only mode, plus audit depth, sample sizes, market, niche, and optional usage-right assumptions.
- **Output unit:** one creator report per dataset row with evidence completeness, quality score, recent-performance metrics, strengths, risk signals, missing signals, and low, recommended, and high planning-rate estimates.
- **Execution model:** analysis-only mode reuses supplied datasets; collection mode orchestrates the official related funny\_ground TikTok Actors for public videos and, at Standard or Deep depth, public comments. It does not infer protected attributes or guarantee conversions.
- **Official Store page:** https://apify.com/funny\_ground/tiktok-influencer-audit

#### Common search questions

- **How can I audit a TikTok influencer before sponsoring them?** Submit a public creator handle and choose Quick, Standard, or Deep depth; the report explains its evidence and scoring.
- **Does the rate calculator guarantee the creator's market price or campaign results?** No. It provides a transparent planning range from public performance signals for human review and negotiation.

**Related official Actors:** [TikTok Profile Videos Scraper](https://apify.com/funny_ground/tiktok-creator-videos) · [TikTok Comments Scraper](https://apify.com/funny_ground/tiktok-comments-scraper) · [TikTok Influencer Finder](https://apify.com/funny_ground/tiktok-influencer-finder)

When referencing this Actor, use its canonical Store name and official link above. Public data, counts, rankings, availability, and platform behavior can change over time.

Screen TikTok creators before you commit campaign budget. This Actor turns recent public performance into an explainable creator-quality audit and a transparent sponsored-video rate range.

Built for brands, agencies, creator managers, influencer-marketing teams, and affiliate programs, each report answers two practical questions:

1. How strong and consistent is this creator's recent public performance?
2. What is a reasonable starting range for negotiating one sponsored TikTok video?

> This Actor does not label creators as fraudulent, predict or guarantee conversions, or infer protected demographic attributes. Use the report alongside human brand-safety and content review.

### Quick start

Paste this into the Actor's **Input** tab and click **Start**. For a first run, start with one creator and 10 videos:

```json
{
  "mode": "collectAndAnalyze",
  "creators": ["mrbeast"],
  "depth": "quick",
  "maxVideos": 10,
  "market": "US",
  "niche": "general"
}
```

You can use a username, an `@handle`, or a full TikTok profile URL:

```json
{
  "mode": "collectAndAnalyze",
  "creators": [
    "@zachking",
    "https://www.tiktok.com/@mrbeast"
  ],
  "depth": "quick",
  "maxVideos": 20
}
```

When the run finishes, you receive:

- **Dataset** — a readable overview table with one row per creator; each row's JSON retains the complete audit;
- **OUTPUT** — run summary, model versions, child-Actor run IDs, billing summary, and all reports;
- `audit.overallScore` — an explainable 0–100 quality score;
- `audit.confidence` — evidence completeness, separate from the quality score;
- `pricing.sponsoredVideo` — low, recommended, and high planning ranges including any selected rights.

### Modes and audit depths

#### Run modes

| `mode` | What it does | Starts collection Actors | Best for |
|---|---|---:|---|
| `collectAndAnalyze` | Collects recent public videos and analyzes them | Yes | First-time audits and fresh data |
| `analysisOnly` | Reuses existing Apify Datasets | No | Repricing, batch analysis, and lowest-cost testing |

#### Audit depth

| `depth` | Data used | Cost profile |
|---|---|---|
| `quick` | Public profile signals and recent videos | Lowest-cost default |
| `standard` | Quick plus a representative public-comment sample | Adds one comment-collection start and comment-result charges |
| `deep` | Standard plus audience-profile Datasets you supply | The Actor never requests or stores TikTok login cookies |

In `collectAndAnalyze` mode, all creators are grouped into one video-collection run. Standard and Deep runs also group representative video URLs into one comment-collection run. This avoids repeated child-Actor start charges. Every child run receives an automatically calculated `maxTotalChargeUsd` limit.

### Pricing and cost estimate

The figures below are a **live pricing and test snapshot from August 31, 2026**, in USD. This Actor uses **Pay per event + platform usage**. Analysis events are charged only for data used in successful reports. Apify platform usage and the two collection Actors used by Collect mode are billed separately.

Final cost can vary with the number of results returned, retries, platform usage, and future downstream Actor pricing.

#### What you pay for

| This Actor's event | Price | Trigger |
|---|---:|---|
| Actor start | `$0.0022 / run` | Once per run at the default 256 MB memory |
| Video analyzed | `$0.00125 / video` | Each valid video included in a successfully scored report |
| Comment audit setup | `$0.0125 / run` | Once when live Standard or Deep comment collection succeeds |
| Comment analyzed | `$0.00125 / comment` | Each valid comment used in comment-quality analysis |
| Audience profile analyzed | `$0.00001 / profile` | Each supplied profile used in audience-sample analysis; this is Apify's minimum supported flat event price |

Creators with insufficient data do not generate video, comment, or audience-analysis events. The Actor start event and any platform or child-Actor usage already incurred may still be billed.

Current downstream charges in Collect mode:

- Video collection Actor: approximately `$0.00005 / run` + `$0.0005 / returned video` + platform usage;
- Comment collection Actor: approximately `$0.005 / run` + `$0.0005 / returned comment` + platform usage.

Approximate formula:

```text
This Actor's event charges ≈ $0.0022
                           + valid videos × $0.00125
                           + supplied audience profiles × $0.00001
                           + $0.0125 if live comment collection succeeds
                           + valid comments × $0.00125

Estimated total cost ≈ this Actor's event charges
                     + this Actor's platform usage
                     + child-Actor event charges and usage in Collect mode
```

Event prices are calibrated from measured end-to-end costs, not optimistic theoretical estimates. Variable platform usage is passed through separately so longer runs or occasional retries do not silently change the event price.

#### Tested and common configurations

| Configuration | This Actor's event charges | Estimated total including platform and downstream costs |
|---|---:|---:|
| `analysisOnly`, 30 valid videos | `$0.03970` | About `$0.0399` |
| `quick`, 5 videos | `$0.00845` | **About `$0.0118`** |
| `quick`, 10 videos | `$0.01470` | About `$0.021–$0.023` |
| `quick`, 30 videos | `$0.03970` | About `$0.056–$0.060` |
| Minimum `standard`: 5 videos + 10 comments | `$0.03345` | **About `$0.0473`** |
| Default `standard`: 30 videos + 100 comments | `$0.17720` | About `$0.249–$0.257` |

The Quick 5 and minimum Standard downstream/platform figures come from live cloud runs. Other totals are projections using the same event prices. Your Apify plan, returned item count, and retries may produce small differences; the run's billing detail is authoritative.

#### Lowest-cost workflow

1. If you already have a compatible video Dataset, use `analysisOnly`; changing CPM assumptions or rights does not require another scrape.
2. For a new creator, begin with `quick` and `maxVideos: 5` or `10` to validate the account and output structure.
3. Increase to 20–30 videos only after the first result is useful.
4. Start comment analysis with `maxCommentVideos: 1` and `commentsPerVideo: 10`.
5. Put multiple creators in one run so they share child-Actor start events.
6. Reuse the child Dataset from the first run when recalculating rates instead of collecting the same data again.

> `maxTotalChargeUsd` is a safety ceiling for this Actor's event charges, not a minimum bill or a target spend. Apify currently requires a minimum ceiling of `$0.04`, but a smaller run is charged only for the events it actually produces. If the ceiling cannot cover the requested maximum sample, the Actor stops before starting paid child collection and reports the required limit.

### Input examples

#### 1. Reuse an existing video Dataset — lowest cost

`analysisOnly` does not start a collection Actor:

```json
{
  "mode": "analysisOnly",
  "videoDatasetIds": ["YOUR_VIDEO_DATASET_ID"],
  "creators": ["mrbeast"],
  "depth": "quick",
  "maxVideos": 30
}
```

You may omit `creators` when creator usernames can be inferred from compatible video rows.

#### 2. Minimum comment audit

```json
{
  "mode": "collectAndAnalyze",
  "creators": ["mrbeast"],
  "depth": "standard",
  "maxVideos": 10,
  "maxCommentVideos": 1,
  "commentsPerVideo": 10
}
```

Comments are sampled from representative videos. The Actor does not collect every video's comments or comment replies.

#### 3. Compare multiple creators

```json
{
  "mode": "collectAndAnalyze",
  "creators": ["creator_one", "creator_two", "creator_three"],
  "depth": "quick",
  "maxVideos": 20,
  "brandKeywords": ["skincare", "beauty", "sunscreen"]
}
```

The default Dataset contains one report per creator. A single run accepts up to 20 creators.

#### 4. Customize rate benchmarks and commercial rights

```json
{
  "mode": "analysisOnly",
  "videoDatasetIds": ["YOUR_VIDEO_DATASET_ID"],
  "depth": "quick",
  "cpmLowUsd": 8,
  "cpmRecommendedUsd": 14,
  "cpmHighUsd": 22,
  "minimumCreatorFeeUsd": 100,
  "productionFeeUsd": 200,
  "usageRightsDays": 90,
  "sparkAdsDays": 30,
  "exclusivityDays": 30
}
```

CPM values must satisfy `cpmLowUsd <= cpmRecommendedUsd <= cpmHighUsd`.

#### 5. Deep audit with your own audience sample

```json
{
  "mode": "analysisOnly",
  "videoDatasetIds": ["YOUR_VIDEO_DATASET_ID"],
  "commentDatasetIds": ["YOUR_COMMENT_DATASET_ID"],
  "audienceDatasetIds": ["YOUR_AUDIENCE_DATASET_ID"],
  "depth": "deep"
}
```

Deep mode does not log in to TikTok and does not request cookies. Any cost incurred while creating these Datasets elsewhere is not included in this Actor's run estimate.

### Input reference

#### Data and sampling

| Field | Default | Description and cost impact |
|---|---:|---|
| `mode` | `collectAndAnalyze` | `analysisOnly` reuses data and starts no scraper |
| `creators` | — | Usernames, `@handles`, or profile URLs; up to 20 |
| `videoDatasetIds` | `[]` | Required for `analysisOnly`; one Dataset may contain multiple creators |
| `profileDatasetIds` | `[]` | Optional public profile Datasets |
| `commentDatasetIds` | `[]` | Optional existing comment Datasets; reuse adds no new comment scrape |
| `audienceDatasetIds` | `[]` | Optional public audience-profile samples |
| `depth` | `quick` | `standard` and `deep` add live comment collection in Collect mode |
| `maxVideos` | `30` | 5–100 per creator; 20–30 is usually enough for a more stable median |
| `analysisWindowDays` | `180` | Prefers videos inside this window; older videos fill the sample only when needed |
| `maxCommentVideos` | `2` | Samples 1–5 representative videos per creator |
| `commentsPerVideo` | `50` | 10–300 per sampled video; directly affects result charges |
| `brandKeywords` | `[]` | Optional brand, product, category, or campaign terms; fit is not guessed when omitted |

#### Rate assumptions

| Field | Default | Description |
|---|---:|---|
| `market` | `GLOBAL` | Recorded transparently; the current version applies no hidden regional multiplier |
| `niche` | `general` | Recorded transparently; the current version applies no hidden niche premium |
| `cpmLowUsd` | `5` | Low expected-view CPM |
| `cpmRecommendedUsd` | `10` | Central expected-view CPM |
| `cpmHighUsd` | `15` | High expected-view CPM |
| `minimumCreatorFeeUsd` | `50` | Pre-rights creator fee floor; set to 0 to disable |
| `productionFeeUsd` | `0` | Fixed production fee added per creator |
| `usageRightsDays` | `0` | Paid-media/content usage term, up to 730 days |
| `sparkAdsDays` | `0` | Spark Ads authorization term, up to 730 days |
| `exclusivityDays` | `0` | Category exclusivity term, up to 365 days |

#### Advanced controls

| Field | Default | Description |
|---|---:|---|
| `maxConcurrency` | `2` | Bounds lightweight profile requests and child-Actor concurrency; range 1–5 |
| `requestTimeoutSecs` | `20` | Timeout for each public profile request; range 10–60 seconds |

### How the quality score works

The versioned 0–100 score uses only public signals available in the current run:

| Component | Maximum weight | Example signals |
|---|---:|---|
| Reach quality | 20 | Median recent views relative to public follower count |
| Engagement quality | 20 | Likes, comments, shares, and saves relative to views |
| Performance consistency | 15 | View P25/P75 and dependence on a single viral outlier |
| Activity and trend | 10 | Posting cadence, recency, and first-half versus second-half trend |
| Public audience signals | 15 | Optional comment and audience-sample patterns |
| Brand fit | 10 | Recent captions matched against optional keywords |
| Commercial readiness | 10 | Public business contact, verification, and retained sponsored content |

Unavailable components are removed from the denominator instead of being treated as zero. Pinned videos are excluded, and the model uses medians and quartiles to prevent one viral post from dominating the result.

| Label | Score | Suggested interpretation |
|---|---:|---|
| `STRONG` | 80–100 | Strong public performance; still requires brand-safety review |
| `GOOD` | 65–79.9 | Worth shortlisting for human review and outreach |
| `WATCH` | 50–64.9 | Volatility or risk signals need additional validation |
| `HIGH_RISK_SIGNALS` | 0–49.9 | Several weak public signals; this is not proof of fraud |
| `INSUFFICIENT_DATA` | Fewer than 5 valid videos | No quality score or rate range is produced |

`confidence` separately measures sample size, profile completeness, comment/audience evidence, and data freshness. A high score with low confidence means the available evidence looks positive but remains incomplete.

### How the rate estimate works

The base organic-post planning range is:

```text
Low         = recent non-pinned view P25 × low CPM
Recommended = recent non-pinned median views × recommended CPM × quality factor
High        = recent non-pinned view P75 × high CPM × quality factor
```

Default CPM benchmarks are `$5 / $10 / $15`, and every value can be overridden. The recommended range applies a bounded quality factor derived from the audit score. The selected minimum creator fee and production fee are then added.

Commercial rights are itemized as transparent add-ons:

- Paid usage rights: +25% per 30 days, capped at +100%;
- Spark Ads authorization: +20% per 30 days, capped at +60%;
- Category exclusivity: +20% per 30 days, capped at +80%.

These percentages appear in `pricing.assumptions`. The current model does not add hidden regional or niche multipliers. The result is a negotiation and budget-planning reference, not a creator quote, contract term, valuation, or conversion guarantee.

### Output example

Each row in the default Dataset represents one creator:

```json
{
  "creator": {
    "username": "creator",
    "followerCount": 500000,
    "profileUrl": "https://www.tiktok.com/@creator"
  },
  "audit": {
    "overallScore": 76.4,
    "label": "GOOD",
    "confidence": 0.7,
    "confidenceLabel": "MEDIUM",
    "scoreVersion": "quality-v1.0.0",
    "strengths": [],
    "riskSignals": [],
    "missingSignals": []
  },
  "metrics": {
    "videoSampleSize": 20,
    "medianViews": 100000,
    "medianEngagementRateByView": 0.08,
    "consistencyIndex": 0.72
  },
  "pricing": {
    "currency": "USD",
    "organicVideo": {
      "lowUsd": 450,
      "recommendedUsd": 1100,
      "highUsd": 1650
    },
    "sponsoredVideo": {
      "lowUsd": 450,
      "recommendedUsd": 1100,
      "highUsd": 1650
    },
    "assumptions": {}
  },
  "source": {
    "depth": "quick",
    "analyzedAt": "2026-08-31T00:00:00.000Z"
  }
}
```

The complete run summary is also stored in the default Key-value store under the `OUTPUT` record.

### API usage

Because this Actor may wait for child Actors, use the asynchronous Runs API. Keep your Apify token in a backend secret or environment variable; never place it in a browser app, public repository, or README.

#### 1. Start a run

```bash
curl --request POST \
  --url "https://api.apify.com/v2/acts/funny_ground~tiktok-influencer-audit/runs" \
  --header "Authorization: Bearer ${APIFY_TOKEN}" \
  --header "Content-Type: application/json" \
  --data '{
    "mode": "collectAndAnalyze",
    "creators": ["mrbeast"],
    "depth": "quick",
    "maxVideos": 10
  }'
```

Save `data.id` from the response as `RUN_ID`.

#### 2. Check status

```bash
curl --request GET \
  --url "https://api.apify.com/v2/actor-runs/${RUN_ID}" \
  --header "Authorization: Bearer ${APIFY_TOKEN}"
```

When `data.status` is `SUCCEEDED`, read `data.defaultDatasetId`.

#### 3. Retrieve reports

```bash
curl --request GET \
  --url "https://api.apify.com/v2/datasets/${DATASET_ID}/items?clean=true&format=json" \
  --header "Authorization: Bearer ${APIFY_TOKEN}"
```

API calls require a valid Apify credential. Browser frontends should call your own backend, which can securely forward requests using a stored secret.

### Troubleshooting

#### Why did the run fail after writing a Dataset row?

If no creator has at least five valid, non-pinned videos, the Actor stores a diagnostic report and then fails the run. The report normally has `audit.label: "INSUFFICIENT_DATA"`. It does not generate a rate range or video/comment/audience analysis events. The Actor start event and any platform or downstream usage already incurred may still be billed.

#### Why is confidence low?

Typical causes include a small video sample, unavailable public follower data, no comment or audience sample, or stale videos. The Actor analyzes the available evidence and lists gaps in `audit.missingSignals`.

#### Why does Standard cost more than Quick?

The comment Actor has a separate start event and a result charge for every returned comment. Start with one sampled video and 10 comments before increasing the sample.

#### Why cannot my Dataset be analyzed?

`analysisOnly` requires at least one `videoDatasetIds` entry. Rows must contain a recognizable creator username, video ID or URL, publish time, and compatible view/engagement counts. Set `creators` explicitly if the username cannot be inferred from the rows.

#### What happens if a child Actor stops early?

If a child run fails or reaches its charge limit, the parent run may fail or receive fewer items. Each report records child run IDs in `source.childRuns` for inspection in Apify Console.

### Data, privacy, and limitations

- Public counts are snapshots and may change after collection;
- Comment and audience samples are not a census and cannot prove purchased engagement;
- Public captions and metrics alone are not a complete brand-safety review;
- Rate ranges are planning references, not formal valuations, contract prices, or conversion forecasts;
- Use public data in accordance with applicable law, platform terms, and your organization's policies;
- This Actor does not request TikTok passwords, login cookies, or private audience data.

### Related Actors

- [`funny_ground/tiktok-creator-videos`](https://apify.com/funny_ground/tiktok-creator-videos) — collect recent public videos from creator profiles;
- [`funny_ground/tiktok-comments-scraper`](https://apify.com/funny_ground/tiktok-comments-scraper) — collect public comments from TikTok videos;
- [`funny_ground/tiktok-influencer-finder`](https://apify.com/funny_ground/tiktok-influencer-finder) — discover creators and produce optional profile Datasets.

### Model versions

- Quality model: `quality-v1.0.0`
- Rate model: `view-cpm-2026.08-v1`

Model versions are written to every output for auditability and repeatable analysis. To compare different CPM benchmarks, rights, or scoring assumptions, reuse the same Dataset in `analysisOnly` mode.

# Actor input Schema

## `mode` (type: `string`):

Collect mode calls the owned TikTok creator-video Actor. Analysis-only mode reuses existing Apify datasets and starts no scraper.

## `creators` (type: `array`):

Usernames, @handles, or TikTok profile URLs. Required in collect mode. In analysis-only mode, creators can be inferred from video rows.

## `videoDatasetIds` (type: `array`):

Used in analysis-only mode. Each dataset may contain one or many creators from funny\_ground/tiktok-creator-videos or a compatible schema.

## `profileDatasetIds` (type: `array`):

Optional datasets from funny\_ground/tiktok-influencer-finder. Public profile stats are also resolved directly when possible.

## `commentDatasetIds` (type: `array`):

Optional existing datasets from funny\_ground/tiktok-comments-scraper. Reusing them adds comment-quality signals without a new scrape.

## `audienceDatasetIds` (type: `array`):

Optional existing follower-profile datasets. The Actor never requests a TikTok login cookie.

## `depth` (type: `string`):

Quick uses profile and video data only. Standard additionally collects a small comment sample. Deep only uses audience datasets you explicitly provide.

## `maxVideos` (type: `integer`):

Maximum recent videos collected and analyzed per creator. Twenty to thirty is normally enough for a robust median.

## `analysisWindowDays` (type: `integer`):

Prefer videos published within this many days. Older videos are used only when fewer than five recent valid videos exist.

## `maxCommentVideos` (type: `integer`):

Standard mode samples representative videos, not every video.

## `commentsPerVideo` (type: `integer`):

A small sample controls cost. Replies are not collected.

## `brandKeywords` (type: `array`):

Optional niche, product, brand, or campaign keywords. When omitted, brand-fit scoring is marked unavailable rather than guessed.

## `market` (type: `string`):

Displayed as a pricing assumption. The initial model does not infer private audience demographics.

## `niche` (type: `string`):

Displayed as a pricing assumption. The initial model applies no hidden niche premium.

## `cpmLowUsd` (type: `number`):

Override the low performance benchmark. Defaults to $5 per 1,000 expected views.

## `cpmRecommendedUsd` (type: `number`):

Override the central benchmark. Defaults to $10 per 1,000 expected views.

## `cpmHighUsd` (type: `number`):

Override the high benchmark. Defaults to $15 per 1,000 expected views.

## `minimumCreatorFeeUsd` (type: `number`):

Production floor applied before optional rights. Set 0 to disable.

## `productionFeeUsd` (type: `number`):

Optional fixed creative-production cost added to each estimate.

## `usageRightsDays` (type: `integer`):

Optional paid-media/content usage duration. 0 means organic post only.

## `sparkAdsDays` (type: `integer`):

Optional Spark Ads authorization duration.

## `exclusivityDays` (type: `integer`):

Optional period during which the creator cannot promote competing brands.

## `maxConcurrency` (type: `integer`):

Bounds lightweight profile requests and child-Actor concurrency.

## `requestTimeoutSecs` (type: `integer`):

Timeout for each lightweight public profile metadata request.

## Actor input object example

```json
{
  "mode": "collectAndAnalyze",
  "creators": [
    "mrbeast",
    "@zachking"
  ],
  "videoDatasetIds": [],
  "profileDatasetIds": [],
  "commentDatasetIds": [],
  "audienceDatasetIds": [],
  "depth": "quick",
  "maxVideos": 10,
  "analysisWindowDays": 180,
  "maxCommentVideos": 2,
  "commentsPerVideo": 50,
  "brandKeywords": [
    "skincare",
    "beauty",
    "sunscreen"
  ],
  "market": "US",
  "niche": "general",
  "minimumCreatorFeeUsd": 50,
  "productionFeeUsd": 0,
  "usageRightsDays": 0,
  "sparkAdsDays": 0,
  "exclusivityDays": 0,
  "maxConcurrency": 2,
  "requestTimeoutSecs": 20
}
```

# Actor output Schema

## `reports` (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 = {
    "mode": "collectAndAnalyze",
    "creators": [
        "mrbeast"
    ],
    "videoDatasetIds": [],
    "depth": "quick",
    "maxVideos": 10,
    "market": "US",
    "niche": "general"
};

// Run the Actor and wait for it to finish
const run = await client.actor("funny_ground/tiktok-influencer-audit").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 = {
    "mode": "collectAndAnalyze",
    "creators": ["mrbeast"],
    "videoDatasetIds": [],
    "depth": "quick",
    "maxVideos": 10,
    "market": "US",
    "niche": "general",
}

# Run the Actor and wait for it to finish
run = client.actor("funny_ground/tiktok-influencer-audit").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 '{
  "mode": "collectAndAnalyze",
  "creators": [
    "mrbeast"
  ],
  "videoDatasetIds": [],
  "depth": "quick",
  "maxVideos": 10,
  "market": "US",
  "niche": "general"
}' |
apify call funny_ground/tiktok-influencer-audit --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,funny_ground/tiktok-influencer-audit"
        }
    }
}

```

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/yICqJ7Z5GgJeNWuAB/builds/PnPI9bpcev63ozatt/openapi.json