# Instagram Following Scraper (`goat255/instagram-following-scraper`) Actor

Scrape the full list of accounts any public Instagram account follows, without a login. Give a list of usernames and get back every followed account as a clean row: username, full name, id, private and verified flags, and profile picture. Paginated automatically to your chosen limit.

- **URL**: https://apify.com/goat255/instagram-following-scraper.md
- **Developed by:** [Goutam Soni](https://apify.com/goat255) (community)
- **Categories:** Social media, Marketing, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 following scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Following Scraper - Export the Accounts Any Profile Follows

Scrape the full list of accounts any public Instagram profile follows. Get every followed account's username, display name, numeric user ID, private and verified flags, and profile picture URL, without an Instagram API key, login, or cookies.

### What this Instagram following scraper does

Pass a list of Instagram usernames (plain handles, @handles, or profile URLs, mixed freely) and the actor returns one clean JSON row per followed account. Pagination is walked automatically page after page until it hits the cap you set or the list runs out, so a request for 5,000 accounts really does walk deep into the list rather than stopping at the first page.

A following list is a stated interest graph: it is what an account chose to pay attention to. That makes it a sharper research signal than a follower list for **niche mapping, competitor discovery, interest profiling, and partnership research**.

### Why use this Instagram following scraper

- **No API key, no login, no cookies.** Works on any public Instagram account. You never hand over an Instagram account or a password.
- **Deep pagination.** Ask for 100 accounts or 200,000 and the scraper keeps fetching until your cap is reached.
- **Verified and private flags on every row**, so you can separate the notable accounts from the personal ones instantly.
- **Numeric user IDs included**, which stay stable even when someone changes their handle, so repeat runs stay comparable.
- **Bulk by username.** Several accounts processed in parallel in a single run, each row tagged with the account it came from.
- **Residential proxies** built in with rotating IPs.
- **Clean, flat JSON.** Every field is always present, with `null` where a value genuinely does not exist, so CSV exports never shift columns.

### What data you get per followed account

| Field | Type | Description |
|---|---|---|
| `type` | string | Record type, always `"following"` |
| `queryUsername` | string | The account whose following list you asked for |
| `username` | string | Handle of the followed account |
| `fullName` | string | Display name of the followed account |
| `id` | string | Numeric Instagram user ID of the followed account |
| `isPrivate` | boolean | Whether the followed account is private |
| `isVerified` | boolean | Whether the followed account has a verified badge |
| `profilePicUrl` | string | Profile picture URL of the followed account |
| `scrapedAt` | string | When the row was scraped (ISO 8601 UTC) |

### How to use the Instagram Following Scraper

1. Click **Try for free** on the actor page.
2. Enter Instagram **usernames** in the `usernames` input. Plain usernames, @handles, and profile URLs all work and are deduplicated.
3. Set `maxFollowingPerUser` (default 1,000, up to 200,000) to cap how many accounts come back per profile.
4. Tune `concurrency` (default 3, up to 10) for your speed and safety tradeoff.
5. Click **Save & start**. Download in JSON, CSV, Excel, XML or HTML, or stream via API.

#### Example input

```json
{
  "usernames": ["example_brand", "example_user"],
  "maxFollowingPerUser": 5000,
  "concurrency": 3
}
```

#### Example output

```json
{
  "type": "following",
  "queryUsername": "example_brand",
  "username": "example_user",
  "fullName": "Jane Doe",
  "id": "100000001",
  "isPrivate": false,
  "isVerified": true,
  "profilePicUrl": "https://example.com/avatar.jpg",
  "scrapedAt": "2026-07-21T09:00:00.000Z"
}
```

### Top use cases

- **Niche mapping.** Scrape the following lists of several key accounts in a category and the repeat names are that niche's centre of gravity.
- **Competitor discovery.** The accounts a brand follows often include its partners, suppliers, agencies and rivals.
- **Interest profiling.** Build a picture of what a target account actually cares about from what it chose to follow.
- **Partnership and sponsorship research.** Spot which creators and brands an account already engages with before pitching.
- **Influencer vetting.** An account following tens of thousands of profiles behaves very differently from a curated one.
- **Lead qualification.** Check whether a prospect already follows accounts in your category.
- **Interest-graph building.** Combine several following lists to rank the most-followed accounts across a segment.

### Integrations

#### Apify API

```bash
curl "https://api.apify.com/v2/datasets/{DATASET_ID}/items?format=json"
```

#### Python

```python
from apify_client import ApifyClient
from collections import Counter

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("goat255/instagram-following-scraper").call(run_input={
    "usernames": ["example_brand", "example_user"],
    "maxFollowingPerUser": 5000,
})

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())

## Accounts followed by more than one of your targets: the niche's core.
shared = Counter(r["username"] for r in rows if r.get("username"))
for username, count in shared.most_common(20):
    if count > 1:
        print(f"@{username}: followed by {count} of your targets")
```

#### JavaScript / Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('goat255/instagram-following-scraper').call({
    usernames: ['example_brand'],
    maxFollowingPerUser: 5000,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const verified = items.filter((r) => r.isVerified);
console.log(`Follows ${items.length} accounts, ${verified.length} of them verified`);
```

#### No-code integrations

Stream results to Google Sheets, Slack, Zapier, Make, Amazon S3, HubSpot, or any webhook via [Apify Integrations](https://docs.apify.com/platform/integrations).

### Pricing

Pay per result. No subscription. No per-run start fee. You only pay for the rows you actually receive.

| Event | Price |
|---|---|
| Following scraped (primary) | $0.0025 |

Apify's $5 platform free credit applies on first use, which is roughly 2,000 free rows to start.

### FAQ

#### Do I need an Instagram account or API key?

No. The scraper works on any public Instagram account without a login, cookies, or the Instagram Graph API.

#### Can it scrape the following list of a private account?

No. Private accounts do not expose their following list. A private target returns a single row with `ok: false` and `error: "private_account"`, so you can tell it apart from an account that follows nobody.

#### What is the difference between this and the followers scraper?

This actor returns the accounts a profile **follows**. The [Instagram Followers Scraper](https://apify.com/goat255/instagram-followers-scraper) returns the accounts that follow **it**. Following lists tend to be smaller, more deliberate and better for interest research. Follower lists are better for audience sizing.

#### How many accounts can I get per profile?

Up to 200,000 per profile per run. Pagination is walked automatically, so setting `maxFollowingPerUser` to 5,000 returns 5,000 rows if the profile follows that many, not just the first page.

#### Why did I get fewer rows than I asked for?

The list ran out. Ask for 5,000 on a profile following 300 accounts and you get 300 real rows rather than 5,000 padded ones. The run log states the count per account.

#### In what order does the list come back?

In the order Instagram serves it, which is roughly most recently followed first. It is not a stable ranking, so match rows by `id` rather than by position when comparing runs.

#### Can I export to CSV, Google Sheets or Excel?

Yes. JSON, CSV, Excel, XML and HTML are all supported, plus direct integrations to Google Sheets, Zapier, Make, Slack and S3.

#### What happens if an account cannot be reached?

The run does not fail. The actor emits a row with `ok: false` and a generic reason for that account, then carries on with the rest of your list.

### Related Apify actors

- 👥 [Instagram Followers Scraper](https://apify.com/goat255/instagram-followers-scraper) - the accounts that follow a profile, same clean row format.
- 👤 [Instagram Profile Scraper](https://apify.com/goat255/instagram-profile-scraper) - bios, follower counts, public emails, phone numbers, business info.
- 📝 [Instagram Posts Scraper](https://apify.com/goat255/instagram-posts-scraper) - bulk export posts, captions, likes, comments, media.
- 🔎 [Instagram Hashtag Scraper](https://apify.com/goat255/instagram-hashtag-scraper) - top and recent posts for any tag.

### Support

Found a bug or a missing field? Open an issue on the actor page. Reviews are read and replied to.

### Privacy

To improve our actors we collect anonymized usage telemetry (run stats and input patterns). No personal account data is collected.

# Actor input Schema

## `usernames` (type: `array`):

Instagram accounts whose following list you want. Handles, @handles, or profile links all work. Examples: example\_brand, @example\_user, https://www.instagram.com/example\_brand/. The account must be public.

## `maxFollowingPerUser` (type: `integer`):

Cap on followed accounts returned per account. Pagination is walked across multiple pages until this is reached or the list runs out.

## `concurrency` (type: `integer`):

How many accounts to process in parallel.

## Actor input object example

```json
{
  "usernames": [
    "acmecompany"
  ],
  "maxFollowingPerUser": 1000,
  "concurrency": 3
}
```

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

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

# Run the Actor and wait for it to finish
run = client.actor("goat255/instagram-following-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 '{
  "usernames": [
    "acmecompany"
  ]
}' |
apify call goat255/instagram-following-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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