# Instagram Search User Followers ✅ (`datamagnet/instagram-followers-search`) Actor

Find Instagram followers that match a keyword for one target account. Enter a username, numeric ID, or profile URL and get the matching follower records back exactly as returned, making audience research, lead generation, and follower analysis faster and easier.

- **URL**: https://apify.com/datamagnet/instagram-followers-search.md
- **Developed by:** [Datamagnet](https://apify.com/datamagnet) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Search Scraper

Instagram Follower Search is a simple Instagram follower scraper and data collector that helps you find followers matching a specific keyword for one target account. It is ideal for marketers, creators, agencies, and researchers who want to quickly identify relevant Instagram followers without manually scrolling through profiles. Enter a search term and an account username, ID, or profile URL, and get back the matching follower records exactly as provided by the source. Use it to speed up Instagram audience research, lead discovery, and follower analysis with clean, ready-to-use results.

### Key Features
- **Extract** Instagram followers that match the keyword you provide.
- **Search** one target account using a username, numeric user ID, or profile URL.
- **Collect** follower records exactly as returned, so you can review the original details.
- **Filter** audience lists by names or phrases that matter to your campaign or research.
- **Export** results in formats that are easy to share, sort, and analyze.
- **Save** time by avoiding manual profile-by-profile checking.
- **Support** audience discovery for marketing, outreach, and competitor research workflows.

### Use Cases

#### Audience Research
Marketing teams use this Instagram follower search scraper to understand who follows a specific account and which followers match a chosen keyword. By reviewing fields like `username`, `full_name`, `is_verified`, and `is_private`, they can spot audience patterns and identify the kinds of people engaging with a brand or creator.

#### Lead Generation
Agencies and sales teams can search for followers that match a niche term, then review the returned usernames and profile details to find potential leads. The `id` and `profile_pic_url` fields help teams recognize and organize prospects while keeping the original follower record intact.

#### Influencer and Creator Analysis
Influencer marketers can compare follower matches across accounts to see what kind of audience a creator attracts. Details such as `full_name`, `username`, and `account_badges` help them judge audience quality, authenticity, and whether the account appears to have notable or branded followers.

#### Community Discovery
Community managers can use the tool to find followers connected to a topic, hobby, or brand keyword. The returned `is_private` and `is_verified` fields help them understand how open or established those followers are before deciding how to engage with them.

#### Competitive Research
Businesses can search followers of a competitor’s account to learn more about the audience around that brand. By looking at matching follower records, they can identify common naming patterns, public-facing profiles, and verified users that may be relevant to their own positioning.

### Input

| Field | Type | Required | Description | Example |
|---|---|---:|---|---|
| max_results | integer | No | The maximum number of matching followers you want returned. | 100 |
| search_query | string | Yes | The word or phrase you want to match against the account’s followers. | mrbeast |
| username_or_id_or_url | string | Yes | The target Instagram account entered as a username, numeric ID, or profile link. | mrbeast |

### Output

| Field | Type | Description |
|---|---|---|
| account_badges | array | Any badges attached to the follower account, which can help you spot special account types or recognition. |
| full_name | string | The follower’s display name, which is useful for identifying the person or brand behind the account. |
| id | string | The account’s unique identifier, helpful for matching records and keeping track of the same profile. |
| is_private | boolean | Shows whether the follower’s profile is private, which helps you understand how visible the account is. |
| is_verified | boolean | Shows whether the follower is verified, which can help you judge account authenticity or prominence. |
| profile_pic_url | string | A link to the follower’s profile picture, useful for quick visual recognition. |
| username | string | The follower’s Instagram handle, which is the easiest way to find or reference the account. |

### Sample Output

```json
{
  "account_badges": [],
  "full_name": "ふるた...",
  "id": "43729726003",
  "is_private": true,
  "is_verified": false,
  "profile_pic_url": "https://scontent-ord5-3.cdninstagram.com/v/t51.82787-19/731442379_18068244029462004_5413854762174697979_n.jpg?stp=dst-jpg_e0_s150x150_tt6&efg=eyJ2ZW5jb2RlX3RhZyI6InByb2ZpbGVfcGljLmRqYW5nby4zNjUuYzIifQ&_nc_ht=scontent-ord5-3.cdninstagram.com&_nc_cat=100&_nc_oc=Q6cZ2gG5YPgCg2WhEJdpr8hpHb5b1r5DXXmkGTJ5...",
  "username": "squirrel.3838154"
}
````

### How It Works

1. You enter a search keyword and choose the Instagram account you want to check.
2. The actor looks for followers that match your keyword.
3. It gathers the matching follower records and keeps the original details intact.
4. You review the results and use them for research, outreach, or reporting.
5. You can download or reuse the output in the format that fits your workflow.

### Getting Started

Getting started is easy and does not require coding knowledge. Click **Try for free**, fill in the search keyword and the target account, then click **Run**. In a short time, your matching follower results will be ready to review and download. You can work with the output in **JSON, CSV, or Excel** depending on how you prefer to analyze or share the data.

### Frequently Asked Questions

#### Do I need technical skills?

No. This tool is designed for business users, marketers, and researchers who want results without dealing with complicated setup. Just enter the keyword and the target account, then run it.

#### How fast does it run?

It usually runs quickly because it focuses on one account and one search term at a time. The exact time depends on how many matching followers are found and how large the account is.

#### What format is the output?

You can use the results in JSON, CSV, or Excel. That makes it easy to review the data yourself, share it with a team, or import it into your own reports.

#### Is this legal to use?

You should always use data responsibly and follow Instagram’s terms and any applicable laws in your region. This tool is best used for legitimate research, marketing, and internal analysis.

#### Can I schedule it to run automatically?

Yes, you can set it up to run on a schedule if you want regular updates. That is useful for ongoing audience monitoring, recurring research, or tracking changes over time.

# Actor input Schema

## `max_results` (type: `integer`):

Maximum number of results to return.

## `search_query` (type: `string`):

Enter the word or phrase you want to match against the account’s followers.

## `username_or_id_or_url` (type: `string`):

Enter the target account as a username, numeric user ID, or profile URL.

## Actor input object example

```json
{
  "max_results": 100,
  "search_query": "mrbeast",
  "username_or_id_or_url": "mrbeast"
}
```

# 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 = {
    "max_results": 100,
    "search_query": "mrbeast",
    "username_or_id_or_url": "mrbeast"
};

// Run the Actor and wait for it to finish
const run = await client.actor("datamagnet/instagram-followers-search").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 = {
    "max_results": 100,
    "search_query": "mrbeast",
    "username_or_id_or_url": "mrbeast",
}

# Run the Actor and wait for it to finish
run = client.actor("datamagnet/instagram-followers-search").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 '{
  "max_results": 100,
  "search_query": "mrbeast",
  "username_or_id_or_url": "mrbeast"
}' |
apify call datamagnet/instagram-followers-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Search User Followers ✅",
        "description": "Find Instagram followers that match a keyword for one target account. Enter a username, numeric ID, or profile URL and get the matching follower records back exactly as returned, making audience research, lead generation, and follower analysis faster and easier.",
        "version": "0.0",
        "x-build-id": "Rvg2b0nZFSKcwtjTd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datamagnet~instagram-followers-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datamagnet-instagram-followers-search",
                "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/datamagnet~instagram-followers-search/runs": {
            "post": {
                "operationId": "runs-sync-datamagnet-instagram-followers-search",
                "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/datamagnet~instagram-followers-search/run-sync": {
            "post": {
                "operationId": "run-sync-datamagnet-instagram-followers-search",
                "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": [
                    "search_query",
                    "username_or_id_or_url"
                ],
                "properties": {
                    "max_results": {
                        "title": "Max results",
                        "type": "integer",
                        "description": "Maximum number of results to return."
                    },
                    "search_query": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Enter the word or phrase you want to match against the account’s followers."
                    },
                    "username_or_id_or_url": {
                        "title": "Account username, ID, or URL",
                        "type": "string",
                        "description": "Enter the target account as a username, numeric user ID, or profile URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```