# Instagram Followers Bio Keyword Scraper (`scrapyspider/instagram-follower-scraper`) Actor

Scrape Instagram followers and filter them by bio keywords — no login or cookies required. Export matched profiles with follower data, business categories, matched keywords, and followed accounts.

- **URL**: https://apify.com/scrapyspider/instagram-follower-scraper.md
- **Developed by:** [ScrapySpider](https://apify.com/scrapyspider) (community)
- **Categories:** Social media, Lead generation, SEO tools
- **Stats:** 5 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

### Instagram Follower Bio Scraper

Scrapes followers of any Instagram account and filters them by bio keywords — no login or cookies required — returning structured JSON with full profile data, matched keywords, and which of your target accounts each user follows.

- Filter followers by any keyword in their Instagram bio (niche, industry, interests)
- Scrape multiple Instagram accounts in a single run
- Each result shows exactly which keywords matched and which accounts they follow
- Returns full profile data: bio, follower count, verification, business category, profile photo
- Outputs clean JSON/CSV ready for outreach tools, CRMs, or lead pipelines
- No Instagram account or cookies required to run

---

#### What data does it extract?

Each result contains:

**Identity:** `username`, `fullName`, `profilePicUrl`

**Profile details:** `biography`, `followersCount`, `followsCount`, `verified`, `isBusinessAccount`, `businessCategoryName`, `private`, `externalUrls`

**Filter metadata:** `matchedKeywords` (which bio keywords matched), `followedAccounts` (which of your input accounts they follow)

Output is available as JSON, CSV, or Excel via the Apify dataset export.

---

#### Use cases

- **Influencer discovery:** Find nano and micro-influencers in a specific niche who follow relevant accounts
- **Lead generation:** Build targeted prospect lists from followers of competitor or complementary brands
- **Market research:** Identify users in a niche by scanning bios of an account's audience
- **Audience analysis:** Understand who follows your competitors — job title, category, bio keywords
- **Recruitment:** Find professionals in a field by filtering followers of industry accounts by bio keywords
- **Brand monitoring:** Discover followers who mention your brand, product type, or industry in their bio

---

#### How to use

1. Click **Try for free** above
2. In the **Input** tab, paste one or more Instagram usernames or profile URLs
3. Enter the bio keywords you want to filter followers by (e.g. "fitness", "coach", "nutrition")
4. Set the **Followers Limit Per Account** (default: 100; increase for larger audiences)
5. Click **Start** and wait for the run to complete
6. Download your results as JSON, CSV, or Excel from the **Output** tab

> **Note:** This Actor calls two sub-Actors (`scraping_solutions/instagram-scraper-followers-following-no-cookies` and `apify/instagram-profile-scraper`). Both are free public Actors on Apify Store — their compute costs are billed to your Apify account separately per run.

---

#### Input parameters

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `accounts` | Array of strings | Yes | `["hudabeauty"]` | Instagram usernames or profile URLs. Example: `"cristiano"` or `"https://www.instagram.com/cristiano/"` |
| `keywords` | Array of strings | Yes | `["makeup","beauty","fitness"]` | Keywords to match against follower bios. A profile is included if its bio contains **any** of these keywords (case-insensitive). |
| `datalimit` | Integer | Yes | `100` | Max followers to scrape per account. Min: 1, Max: 10000. |

---

#### Output example

```json
{
  "username": "janefit_coach",
  "fullName": "Jane Martinez",
  "biography": "🏋️ Fitness coach & nutrition expert | DMs open for coaching",
  "followersCount": 12400,
  "followsCount": 843,
  "verified": false,
  "isBusinessAccount": true,
  "businessCategoryName": "Personal Coach",
  "private": false,
  "profilePicUrl": "https://scontent.cdninstagram.com/...",
  "externalUrls": ["https://janefit.com"],
  "matchedKeywords": ["fitness", "coach"],
  "followedAccounts": ["hudabeauty"]
}
````

***

#### Pricing

This Actor is **free to use** — you only pay for Apify platform compute time and the sub-Actor runs it triggers.

A typical run of 100 followers per account costs approximately **$0.10–$0.30** in Apify platform credits (including sub-Actor costs).

New Apify accounts receive **$5 in free credits** — enough for several hundred profile matches.

***

#### Technical notes

- **No account needed:** This Actor does not require an Instagram login, session cookies, or API credentials
- **Sub-Actor dependencies:** Results depend on `scraping_solutions/instagram-scraper-followers-following-no-cookies` (followers list) and `apify/instagram-profile-scraper` (full profile data) — both are free public Actors
- **Private profiles:** Followers with private Instagram accounts will be listed but bio data may be limited or unavailable
- **Rate limits:** Instagram applies rate limiting. For large runs (1,000+ followers), expect longer run times
- **Keyword matching:** Matching is case-insensitive and checks both `biography` and `businessCategoryName` fields

***

#### Support

Have questions or found a bug? Reach out:

- **Email:** ScrapySpider@protonmail.com
- **Website:** [ScrapySpider.com](https://ScrapySpider.com)
- **Apify:** Open a support issue on this Actor page
- **Response time:** Within 24–48 hours on weekdays

# Actor input Schema

## `accounts` (type: `array`):

List of Instagram usernames (e.g. "cristiano") or full profile URLs (e.g. "https://www.instagram.com/cristiano/"). Both formats are accepted and can be mixed.

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

Keywords to filter followers by their Instagram bio. Only followers whose bio contains at least one keyword will appear in the output. The output will also indicate which keywords matched and which account(s) they follow.

## `datalimit` (type: `integer`):

Maximum number of followers to scrape per account. Higher values result in longer run times and higher costs.

## Actor input object example

```json
{
  "accounts": [
    "hudabeauty"
  ],
  "keywords": [
    "makeup",
    "beauty",
    "skincare",
    "fashion",
    "fitness",
    "travel",
    "influencer"
  ],
  "datalimit": 100
}
```

# Actor output Schema

## `overview` (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 = {
    "accounts": [
        "hudabeauty"
    ],
    "keywords": [
        "makeup",
        "beauty",
        "skincare",
        "fashion",
        "fitness",
        "travel",
        "influencer"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapyspider/instagram-follower-scraper").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 = {
    "accounts": ["hudabeauty"],
    "keywords": [
        "makeup",
        "beauty",
        "skincare",
        "fashion",
        "fitness",
        "travel",
        "influencer",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapyspider/instagram-follower-scraper").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 '{
  "accounts": [
    "hudabeauty"
  ],
  "keywords": [
    "makeup",
    "beauty",
    "skincare",
    "fashion",
    "fitness",
    "travel",
    "influencer"
  ]
}' |
apify call scrapyspider/instagram-follower-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Followers Bio Keyword Scraper",
        "description": "Scrape Instagram followers and filter them by bio keywords — no login or cookies required. Export matched profiles with follower data, business categories, matched keywords, and followed accounts.",
        "version": "0.1",
        "x-build-id": "SFQkqbIVEk7OG86Vg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapyspider~instagram-follower-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapyspider-instagram-follower-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapyspider~instagram-follower-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapyspider-instagram-follower-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapyspider~instagram-follower-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapyspider-instagram-follower-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "accounts",
                    "keywords",
                    "datalimit"
                ],
                "properties": {
                    "accounts": {
                        "title": "Instagram Accounts",
                        "type": "array",
                        "description": "List of Instagram usernames (e.g. \"cristiano\") or full profile URLs (e.g. \"https://www.instagram.com/cristiano/\"). Both formats are accepted and can be mixed.",
                        "default": [
                            "hudabeauty"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Bio Filter Keywords",
                        "type": "array",
                        "description": "Keywords to filter followers by their Instagram bio. Only followers whose bio contains at least one keyword will appear in the output. The output will also indicate which keywords matched and which account(s) they follow.",
                        "default": [
                            "makeup",
                            "beauty",
                            "skincare",
                            "fashion",
                            "fitness",
                            "travel",
                            "influencer"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "datalimit": {
                        "title": "Followers Limit Per Account",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of followers to scrape per account. Higher values result in longer run times and higher costs.",
                        "default": 100
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
