playbooks

home / skills / apify / agent-skills / apify-influencer-discovery

apify-influencer-discovery skill

/skills/apify-influencer-discovery

This skill helps you discover and evaluate social media influencers across platforms, verify authenticity, and track collaboration performance for smarter

npx playbooks add skill apify/agent-skills --skill apify-influencer-discovery

Review the files below or copy the command above to add this skill to your agents.

Files (2)
SKILL.md
4.2 KB
---
name: apify-influencer-discovery
description: Find and evaluate influencers for brand partnerships, verify authenticity, and track collaboration performance across Instagram, Facebook, YouTube, and TikTok.
---

# Influencer Discovery

Discover and analyze influencers across multiple platforms using Apify Actors.

## Prerequisites
(No need to check it upfront)

- `.env` file with `APIFY_TOKEN`
- Node.js 20.6+ (for native `--env-file` support)
- `mcpc` CLI tool (for fetching Actor schemas)

## Workflow

Copy this checklist and track progress:

```
Task Progress:
- [ ] Step 1: Determine discovery source (select Actor)
- [ ] Step 2: Fetch Actor schema via mcpc
- [ ] Step 3: Ask user preferences (format, filename)
- [ ] Step 4: Run the discovery script
- [ ] Step 5: Summarize results
```

### Step 1: Determine Discovery Source

Select the appropriate Actor based on user needs:

| User Need | Actor ID | Best For |
|-----------|----------|----------|
| Influencer profiles | `apify/instagram-profile-scraper` | Profile metrics, bio, follower counts |
| Find by hashtag | `apify/instagram-hashtag-scraper` | Discover influencers using specific hashtags |
| Reel engagement | `apify/instagram-reel-scraper` | Analyze reel performance and engagement |
| Discovery by niche | `apify/instagram-search-scraper` | Search for influencers by keyword/niche |
| Brand mentions | `apify/instagram-tagged-scraper` | Track who tags brands/products |
| Comprehensive data | `apify/instagram-scraper` | Full profile, posts, comments analysis |
| API-based discovery | `apify/instagram-api-scraper` | Fast API-based data extraction |
| Engagement analysis | `apify/export-instagram-comments-posts` | Export comments for sentiment analysis |
| Facebook content | `apify/facebook-posts-scraper` | Analyze Facebook post performance |
| Micro-influencers | `apify/facebook-groups-scraper` | Find influencers in niche groups |
| Influential pages | `apify/facebook-search-scraper` | Search for influential pages |
| YouTube creators | `streamers/youtube-channel-scraper` | Channel metrics and subscriber data |
| TikTok influencers | `clockworks/tiktok-scraper` | Comprehensive TikTok data extraction |
| TikTok (free) | `clockworks/free-tiktok-scraper` | Free TikTok data extractor |
| Live streamers | `clockworks/tiktok-live-scraper` | Discover live streaming influencers |

### Step 2: Fetch Actor Schema

Fetch the Actor's input schema and details dynamically using mcpc:

```bash
export $(grep APIFY_TOKEN .env | xargs) && mcpc --json mcp.apify.com --header "Authorization: Bearer $APIFY_TOKEN" tools-call fetch-actor-details actor:="ACTOR_ID" | jq -r ".content"
```

Replace `ACTOR_ID` with the selected Actor (e.g., `apify/instagram-profile-scraper`).

This returns:
- Actor description and README
- Required and optional input parameters
- Output fields (if available)

### Step 3: Ask User Preferences

Before running, ask:
1. **Output format**:
   - **Quick answer** - Display top few results in chat (no file saved)
   - **CSV** - Full export with all fields
   - **JSON** - Full export in JSON format
2. **Number of results**: Based on character of use case

### Step 4: Run the Script

**Quick answer (display in chat, no file):**
```bash
node --env-file=.env ${CLAUDE_PLUGIN_ROOT}/reference/scripts/run_actor.js \
  --actor "ACTOR_ID" \
  --input 'JSON_INPUT'
```

**CSV:**
```bash
node --env-file=.env ${CLAUDE_PLUGIN_ROOT}/reference/scripts/run_actor.js \
  --actor "ACTOR_ID" \
  --input 'JSON_INPUT' \
  --output YYYY-MM-DD_OUTPUT_FILE.csv \
  --format csv
```

**JSON:**
```bash
node --env-file=.env ${CLAUDE_PLUGIN_ROOT}/reference/scripts/run_actor.js \
  --actor "ACTOR_ID" \
  --input 'JSON_INPUT' \
  --output YYYY-MM-DD_OUTPUT_FILE.json \
  --format json
```

### Step 5: Summarize Results

After completion, report:
- Number of influencers found
- File location and name
- Key metrics available (followers, engagement rate, etc.)
- Suggested next steps (filtering, outreach, deeper analysis)


## Error Handling

`APIFY_TOKEN not found` - Ask user to create `.env` with `APIFY_TOKEN=your_token`
`mcpc not found` - Ask user to install `npm install -g @apify/mcpc`
`Actor not found` - Check Actor ID spelling
`Run FAILED` - Ask user to check Apify console link in error output
`Timeout` - Reduce input size or increase `--timeout`

Overview

This skill helps marketing teams find and evaluate influencers across Instagram, Facebook, YouTube, and TikTok, verify authenticity, and track collaboration performance. It leverages Apify Actors to discover profiles by hashtag, niche, mentions, or platform-specific signals and exports results in CSV or JSON for downstream use. The workflow guides selection of the right Actor, fetching schemas, running extraction, and summarizing outcomes.

How this skill works

The skill maps user needs to the appropriate Apify Actor (profile scrapers, hashtag/reel finders, Facebook and TikTok extractors, YouTube channel scraper). It fetches the Actor input schema via mcpc, prompts for output preferences and result volume, then runs the chosen Actor with the provided input. Results can be displayed in chat for a quick answer or exported as CSV/JSON files for analysis, and a summary of matches and key metrics is produced.

When to use it

  • Building a shortlist of influencers for a campaign by niche or hashtag
  • Verifying follower and engagement metrics before outreach
  • Exporting comprehensive profile and post data for agency reports
  • Monitoring brand mentions and tags to find organic advocates
  • Comparing performance across platforms (Instagram, TikTok, YouTube, Facebook)

Best practices

  • Choose the Actor that matches your discovery need (profile, hashtag, reel, API-based) to avoid excess noise
  • Fetch the Actor input schema before running so required parameters match expected inputs
  • Start with small result counts to validate filters, then increase volume to avoid timeouts
  • Use CSV for bulk analysis and JSON for structured programmatic processing
  • Handle errors by checking APIFY_TOKEN, installing mcpc, and verifying Actor IDs

Example use cases

  • Find micro-influencers in a local niche by running the Instagram search scraper and exporting CSV for outreach
  • Validate a candidate list by scraping profile metrics and engagement rates before contract negotiations
  • Track TikTok creators with the tiktok-scraper and export JSON to feed into performance dashboards
  • Monitor brand tags and mentions with the tagged scraper to identify organic partnerships and UGC
  • Compare YouTube channel metrics across candidates using the YouTube channel scraper and summarize top performers

FAQ

What do I need before running this skill?

A .env file with APIFY_TOKEN, Node.js 20.6+ for native --env-file support, and mcpc CLI installed to fetch Actor schemas.

How do I choose the right Actor?

Match your discovery goal (profile details, hashtag search, reels, brand tags, platform-specific needs) to the Actor descriptions in the selection table before fetching its schema.

What if a run fails or times out?

Check the Apify console error link, reduce input size, increase --timeout, verify APIFY_TOKEN, and ensure the Actor ID is spelled correctly.