# Instagram Related Profiles Scraper — Similar Accounts & Leads (`toolzerhub/instagram-related-profiles-scraper`) Actor

Turn one Instagram handle into a qualified list of the accounts around it. Reads Instagram's own Suggested for You graph, fetches each discovered account's full profile, and returns email, phone, website, category and followers. Filter by contact details, category or follower band. No login needed.

- **URL**: https://apify.com/toolzerhub/instagram-related-profiles-scraper.md
- **Developed by:** [ToolzerHub](https://apify.com/toolzerhub) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 1 total users, 1 monthly users, 12.5% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.53 / 1,000 profile analyzeds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Instagram Related Profiles Scraper — Similar Accounts, Already Qualified

Give it one Instagram handle. Get back the accounts around it, each with an email, a phone number, a website, a category and a follower count — already filtered down to the ones worth contacting.

Instagram builds its "Suggested for You" list from who follows whom. That makes it the best free map of a niche there is: one competitor's handle is usually enough to find the rest of the market. This Actor reads that map, then does the part that actually takes time — fetching every discovered account's full profile and throwing away the ones that don't fit.

No login, no cookie, no session.

### Quick start

```json
{
  "profiles": ["nasa"],
  "searchDepth": "1",
  "maxProfiles": 200,
  "requireContact": "email"
}
```

That returns up to 200 accounts Instagram suggests alongside `nasa`, keeping only the ones that publish an email address. At $0.008 per analyzed account, a full 200-profile run costs $1.60.

### What you get

One row per account, 23 columns. The ones people actually use:

| Column | What it holds |
|---|---|
| `username`, `full_name` | Who it is |
| `business_email` | Public contact email, when the account publishes one |
| `business_phone_number` | Public contact phone, when published |
| `external_url` | The link in the bio |
| `business_category_name` | Instagram's own category — Photographer, Restaurant, Public Figure… |
| `follower_count`, `following_count`, `media_count` | Size and activity |
| `biography` | Bio text, as written |
| `is_business_account`, `is_verified`, `is_private` | Account type and status |
| `discovered_from`, `depth`, `chain_path` | Which account led here, and how far out |
| `matched_by` | Which filter kept this row |

```json
{
  "username": "esa",
  "full_name": "European Space Agency",
  "business_email": "contact@esa.int",
  "external_url": "https://esa.int",
  "business_category_name": "Science Museum",
  "follower_count": 5000000,
  "is_business_account": true,
  "is_verified": true,
  "discovered_from": "nasa",
  "depth": 1,
  "matched_by": "keyword:space"
}
```

`discovered_from` is what keeps a wide run readable: every row says which account led to it, so you can always trace a lead back to the handle you started from.

### Pricing, and what filters do to your bill

**$0.008 per profile analyzed.** One event. No Actor start fee, no per-row add-on, no separate charge for the email.

A profile is "analyzed" when it has been discovered, fetched in full, and checked against your filters. **It is charged whether or not a filter then keeps it** — by the time the filter can run, the profile has already been fetched, and that fetch is the cost.

That matters most when you set a narrow filter:

| Run | Analyzed | Kept | Cost |
|---|---|---|---|
| 200 profiles, no filters | 200 | 200 | $1.60 |
| 200 profiles, `requireContact: email` | 200 | ~60 | $1.60 |
| 200 profiles, follower band 10k–100k | 200 | ~40 | $1.60 |

So set `maxProfiles` to your budget: **budget ÷ 0.008**. $8 is 1000 profiles. It is a hard ceiling — the run stops there.

**Two filters are free.** `verifiedOnly` and `skipPrivate` read fields that are already on the discovery record, so accounts they reject are never fetched and never billed. Use them first when they fit.

### Going wider

`searchDepth: "1"` asks about the handles you entered and returns the accounts Instagram suggests for them. That's the shortlist.

`searchDepth: "2"` also asks about each account it found, one level further out. This is how a single handle becomes a whole niche — and it multiplies the bill, because every account it reaches is an analyzed profile. `maxPerLevel` controls how many accounts each one carries into the next level (10 by default), and `maxProfiles` is still the hard ceiling.

Accounts already seen in the run are never analyzed twice, so the same profile is never billed twice.

### Filter recipes

**Brands with a funnel, in your niche**

```json
{ "profiles": ["allbirds"], "searchDepth": "2", "accountType": "business",
  "hasWebsite": true, "requireContact": "email", "maxProfiles": 500 }
```

**Mid-tier creators, not mega-accounts**

```json
{ "profiles": ["natgeo"], "accountType": "personal",
  "minFollowers": 10000, "maxFollowers": 250000, "maxProfiles": 300 }
```

**One specific trade**

```json
{ "profiles": ["thephotographyinstitute"], "businessCategory": "Photographer",
  "requireContact": "email_or_phone", "maxProfiles": 300 }
```

**Anyone mentioning a topic in their bio**

```json
{ "profiles": ["shopify"], "keywords": ["skincare", "beauty"],
  "keywordSearchIn": "bio", "maxProfiles": 400 }
```

### When a run comes back empty

Almost always a filter that's too narrow. In order of likelihood:

1. A tight `minFollowers`/`maxFollowers` band. Widen it — run once with no band, look at the counts you actually get back, then set one.
2. `businessCategory` is an **exact** match. "Photographer" works; "Photo" matches nothing.
3. `requireContact: "email"` on a niche where most accounts are personal. Try `email_or_phone`, or drop to `any` and filter the spreadsheet afterwards.
4. `verifiedOnly` — this excludes the vast majority of accounts by design.

The run log tells you how many accounts were analyzed and how many survived, so you can see which end the problem is at.

### FAQ

**How many accounts come back per handle?**
Whatever Instagram suggests for it — usually a few dozen at depth 1, not an exhaustive index. Depth 2 is where the volume comes from.

**Does the seed account have to be public?**
Yes. Private accounts have no suggestion list to read. Private accounts can still appear in results; `skipPrivate` drops them for free.

**Are the emails scraped from anywhere shady?**
No. They're the public contact details a business account chooses to publish on its own profile — the same ones the Contact button shows any visitor.

**Why is `business_email` empty on some rows?**
Either the account publishes no email, or the row has `is_partial: true`. Instagram's full-profile source rejects a minority of accounts, and the fallback that answers instead carries no bio link, media count or category. On those rows those columns are *unknown*, not empty — `partial_reason` says which case it was.

**What happens if a long run gets interrupted?**
It picks up where it stopped. The Actor checkpoints every account it has analyzed, so when the platform migrates a run to another server it skips those accounts entirely — they are not fetched again, not charged again, and not written to the dataset twice. This matters most on a large depth-2 run, which is exactly the kind that gets migrated.

**Is a login or cookie needed?**
No. Everything here is public data, fetched without an Instagram session.

### Support

Questions, bugs, or a filter you wish existed: **contact@toolzerhub.com**.
More Instagram Actors: **https://apify.com/toolzerhub**

# Actor input Schema

## `profiles` (type: `array`):

Instagram accounts to pull the list from

## `searchDepth` (type: `string`):

How far to follow Instagram's suggestions. 1 stays on the accounts suggested for the handles you entered. 2 also asks about each account it found, which turns a shortlist into a whole niche and costs proportionally more.

## `maxProfiles` (type: `integer`):

Hard ceiling on how many accounts this run will analyze, and therefore what it can cost — every analyzed account is one billed event. 0 means no ceiling. A budget of $8 is roughly 1000 profiles.

## `maxPerLevel` (type: `integer`):

How many accounts to keep from each account asked about, and carry into the next level. Only used at Search Depth 2.

## `minFollowers` (type: `integer`):

Drop accounts below this follower count. 0 disables it.

## `maxFollowers` (type: `integer`):

Drop accounts above this follower count. 0 disables it. A narrow band is the quickest way to an empty run — widen it before assuming something is broken.

## `requireContact` (type: `string`):

Keep only accounts that publish a way to reach them. Checked against what the account actually exposes, so it is independent of which columns you keep.

## `accountType` (type: `string`):

Business accounts carry a category and often a contact button; personal ones do not. Most outreach lists want business, influencer discovery usually wants personal.

## `businessCategory` (type: `string`):

Keep only accounts whose Instagram business category matches this exactly — for example Photographer, Restaurant, Beauty Salon, Public Figure. Leave empty to skip.

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

Keep only accounts whose text contains one of these terms. Case-insensitive, and any one match is enough. Leave empty to skip.

## `keywordSearchIn` (type: `string`):

Which part of the account the keyword filter reads.

## `hasWebsite` (type: `boolean`):

Keep only accounts with a link in their bio — usually the sign of a brand or a creator running their own funnel.

## `verifiedOnly` (type: `boolean`):

Keep only accounts carrying the blue badge. This excludes the large majority of accounts.

## `skipPrivate` (type: `boolean`):

Drop private accounts.

## Actor input object example

```json
{
  "profiles": [
    "cristiano"
  ],
  "searchDepth": "1",
  "maxProfiles": 200,
  "maxPerLevel": 10,
  "minFollowers": 0,
  "maxFollowers": 0,
  "requireContact": "any",
  "accountType": "any",
  "businessCategory": "",
  "keywords": [],
  "keywordSearchIn": "bio_or_name",
  "hasWebsite": false,
  "verifiedOnly": false,
  "skipPrivate": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

Every record collected during this run

# 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 = {
    "profiles": [
        "cristiano"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("toolzerhub/instagram-related-profiles-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 = { "profiles": ["cristiano"] }

# Run the Actor and wait for it to finish
run = client.actor("toolzerhub/instagram-related-profiles-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "profiles": [
    "cristiano"
  ]
}' |
apify call toolzerhub/instagram-related-profiles-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,toolzerhub/instagram-related-profiles-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Wk0YslkpimHFogUtg/builds/a5BgiByFFhQr1SQiU/openapi.json