# Instagram Following Search (`datamagnet/instagram-search-user-following`) Actor

Find accounts from a target Instagram account's following list that match a search term.

- **URL**: https://apify.com/datamagnet/instagram-search-user-following.md
- **Developed by:** [Datamagnet](https://apify.com/datamagnet) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 2 total users, 1 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.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 Following Search Scraper

Instagram Following Search is a simple Instagram scraper and data collector that helps you find accounts a person or brand follows based on a keyword or phrase. It is ideal for marketers, researchers, agencies, and creators who want to quickly narrow down a target account’s following list without manually scrolling through profiles. Enter a username, user ID, or profile URL, add a search term, and get back the matching Instagram following records in a clean, usable format. If you need fast Instagram following extraction for audience research, competitor analysis, or lead discovery, this actor gives you exactly that.

### Key Features
- **Extract** matching accounts from an Instagram profile’s following list using a keyword or phrase.
- **Collect** raw profile records so you can review the exact matching results returned by the source.
- **Filter** a target account’s following list to quickly find relevant people, brands, or creators.
- **Save** useful profile details such as username, full name, verification status, privacy status, and profile picture link.
- **Support** multiple ways to identify the target account, including username, numeric user ID, or profile URL.
- **Speed up** research workflows by reducing manual searching and profile-by-profile checking.
- **Export** results in formats that are easy to share, analyze, and reuse in business workflows.

### Use Cases

#### Influencer Research
Marketing teams use this actor to see which accounts a creator or public figure follows and then match those accounts against a keyword. The returned fields like `username`, `full_name`, `is_verified`, and `is_private` help teams understand whether the matched accounts are creators, brands, or personal profiles. This is useful when building creator shortlists, checking audience overlap, or identifying potential collaboration targets.

#### Competitor Analysis
Brands can inspect a competitor’s following list to discover accounts that match a product category, niche, or campaign theme. By reviewing `username`, `full_name`, and `profile_pic_url`, analysts can quickly spot relevant accounts and compare them with their own outreach lists. This helps teams understand who a competitor pays attention to and where they may be building relationships.

#### Lead Discovery
Sales and partnership teams can search a target account’s following list for names that match a business category, location, or brand term. The output gives them the raw matching records, which makes it easier to identify prospects without manually browsing hundreds of profiles. Fields like `id` and `username` are especially helpful when organizing leads and avoiding duplicates.

#### Brand Monitoring
Agencies and brand managers can use this actor to check whether a public figure, partner, or competitor follows accounts related to a campaign or product line. The `is_verified` and `is_private` fields help them understand the type of account they found and whether it is a public brand, creator, or private user. This supports faster monitoring of relationship signals and audience alignment.

#### Audience and Community Research
Researchers and social media strategists can use the actor to study the kinds of accounts a target profile follows and what those matches reveal about interests or affiliations. The returned `full_name`, `username`, and `account_badges` fields provide context that helps users interpret the result set. This is valuable for understanding communities, niche interests, and brand associations.

### Input

| Field | Type | Required | Description | Example |
|---|---|---:|---|---|
| Search keyword | string | Yes | Enter the word or phrase you want to look for within the target account’s following list. | mrbeast |
| Username, user ID, or profile URL | string | Yes | Enter the Instagram account you want to inspect. You can use a username, numeric user ID, or a profile link. | mrbeast |

### Output

| Field | Type | Description |
|---|---|---|
| account_badges | array | Extra badges or labels attached to the account, which can help you understand the profile at a glance. |
| full_name | string | The display name shown on the Instagram profile, useful for identifying the person or brand. |
| id | string | The account’s unique identifier, helpful for matching records and keeping track of results. |
| is_private | boolean | Shows whether the account is private, so you know if the profile has restricted visibility. |
| is_verified | boolean | Shows whether the account is verified, which can help you judge authenticity or prominence. |
| profile_pic_url | string | A link to the profile picture, useful for visual identification and record review. |
| username | string | The Instagram handle of the matched account, which is often the easiest way to recognize it. |

### Sample Output

```json
{
  "account_badges": [],
  "full_name": "MrBeast Store",
  "id": "7529854796",
  "is_private": false,
  "is_verified": true,
  "profile_pic_url": "https://scontent-fml20-1.cdninstagram.com/v/t51.2885-19/358387931_3117679775207041_4365452660009336975_n.jpg?stp=dst-jpg_e0_s150x150_tt6&efg=eyJ2ZW5jb2RlX3RhZyI6InByb2ZpbGVfcGljLmRqYW5nby4xMDgwLmMyIn0&_nc_ht=scontent-fml20-1.cdninstagram.com&_nc_cat=101&_nc_oc=Q6cZ2gFLcGE0_s_jCuSB3PR5BNZr8gS_E-pvAMz...",
  "username": "mrbeaststore"
}
````

### How It Works

1. You enter a search keyword and the Instagram account you want to inspect.
2. The actor checks the target account’s following list for matches related to your keyword.
3. It gathers the matching profiles and keeps the original record details intact.
4. You receive the results in a format that is easy to review, sort, and export.
5. You can use the output immediately for research, outreach, or reporting.

### Getting Started

Getting started is easy and does not require coding knowledge. Click **Try for free**, enter your search keyword and the Instagram username, user ID, or profile URL, then click **Run**. The actor will do the rest and return the matching accounts automatically. Once finished, you can download the results as JSON, CSV, or Excel and use them in your workflow right away.

### Frequently Asked Questions

#### Do I need technical skills?

No. This actor is designed for business users, marketers, researchers, and agencies who want results without dealing with complicated setup. You only need to provide the search term and the target Instagram account.

#### How fast does it run?

Speed depends on the size of the target account’s following list and how many matches are found. In most cases, it is built for quick lookups so you can move from search to results without manual browsing.

#### What format is the output?

The results are available in easy-to-use formats such as JSON, CSV, and Excel. That makes it simple to review the matched accounts, share them with your team, or import them into your own spreadsheets.

#### Is this legal to use?

You should always use data responsibly and in line with applicable laws, platform rules, and your organization’s policies. This actor is intended for legitimate research, analysis, and business workflows, so make sure your use case is appropriate.

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

Yes, you can set it up to run on a schedule if you want regular checks on a target account’s following list. This is useful for ongoing monitoring, recurring research, or keeping a watchlist up to date.

# Actor input Schema

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

The word or phrase to look for in the target account's following list.

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

The Instagram account to check. You can enter a username, numeric user ID, or a profile URL.

## Actor input object example

```json
{
  "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 = {
    "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-search-user-following").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 = {
    "search_query": "mrbeast",
    "username_or_id_or_url": "mrbeast",
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Following Search",
        "description": "Find accounts from a target Instagram account's following list that match a search term.",
        "version": "0.0",
        "x-build-id": "2K3hjCcCedmoLx0JZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datamagnet~instagram-search-user-following/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datamagnet-instagram-search-user-following",
                "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-search-user-following/runs": {
            "post": {
                "operationId": "runs-sync-datamagnet-instagram-search-user-following",
                "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-search-user-following/run-sync": {
            "post": {
                "operationId": "run-sync-datamagnet-instagram-search-user-following",
                "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": {
                    "search_query": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "The word or phrase to look for in the target account's following list."
                    },
                    "username_or_id_or_url": {
                        "title": "Username, user ID, or profile URL",
                        "type": "string",
                        "description": "The Instagram account to check. You can enter a username, numeric user ID, or a 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```