# Instagram Followers & Following Scraper (`fetch_cat/instagram-scraper-followers-following-no-cookies-scraper`) Actor

Export follower and following identities from public Instagram profiles with IDs, usernames, names, profile URLs, privacy flags, pagination, and resumable limits.

- **URL**: https://apify.com/fetch\_cat/instagram-scraper-followers-following-no-cookies-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 relationship identity exporteds

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/actors/running/actors-in-store.md#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 Followers & Following Scraper

This Instagram followers scraper exports follower and following identities from public Instagram profiles to a structured dataset. Use it as an Instagram following scraper: enter one or more public usernames, choose a direction, and receive account IDs, usernames, display names, profile links, pictures, and public status flags. You can also export Instagram followers for downstream analysis.

No customer Instagram login, password, cookie, or browser session is accepted as input.

### Why use this Instagram scraper?

Use the Actor when you need relationship-level data rather than follower counts alone.

- Export followers of public Instagram profiles.
- Export accounts followed by public Instagram profiles.
- Process multiple source profiles in one run.
- Set a separate result limit for every source profile.
- Resume unfinished exports without duplicating earlier rows.
- Download results as JSON, CSV, Excel, XML, or RSS.
- Connect the dataset to Apify API, webhooks, Google Sheets, n8n, Zapier, or your own application.

### Example input

```json
{
  "usernames": ["nasa", "natgeo"],
  "dataToScrape": "followers",
  "resultsLimit": 100
}
```

The Actor exports up to 100 followers for each supplied profile. Change `dataToScrape` to `following` to export accounts each source follows.

### Example output

```json
{
  "sourceUsername": "nasa",
  "type": "FOLLOWER",
  "userId": "123456789",
  "username": "example_user",
  "fullName": "Example User",
  "profilePicUrl": "https://instagram.example/image.jpg",
  "profileUrl": "https://www.instagram.com/example_user/",
  "isPrivate": false,
  "isVerified": false
}
```

Each row is one relationship identity. `type` is relative to `sourceUsername`.

### Input settings

| Field | Type | Description |
| --- | --- | --- |
| `usernames` | string array | Public Instagram usernames or profile URLs. |
| `Account` | string array | Compatibility alias for `usernames`. Do not provide both fields. |
| `dataToScrape` | string | `followers` or `following`. Legacy capitalization is accepted. |
| `resultsLimit` | integer | Maximum additional identities exported per source in this run. |
| `continuationToken` | string | Optional token from an earlier run's OUTPUT for resuming unfinished work. |

The continuation token must be used by the same Apify account with the same normalized profiles, order, and direction. Tokens expire after seven days or when their backing storage is removed.

### Input recipes

#### Export followers from one profile

```json
{
  "usernames": ["nasa"],
  "dataToScrape": "followers",
  "resultsLimit": 50
}
```

#### Export followed accounts

```json
{
  "usernames": ["natgeo"],
  "dataToScrape": "following",
  "resultsLimit": 200
}
```

#### Process multiple profiles

```json
{
  "usernames": ["nasa", "natgeo"],
  "dataToScrape": "followers",
  "resultsLimit": 25
}
```

#### Resume an unfinished export

```json
{
  "usernames": ["nasa"],
  "dataToScrape": "followers",
  "resultsLimit": 100,
  "continuationToken": "TOKEN_FROM_PREVIOUS_OUTPUT"
}
```

### Dataset fields

| Field | Type | Meaning |
| --- | --- | --- |
| `sourceUsername` | string | Requested and resolved public source profile. |
| `type` | string | `FOLLOWER` or `FOLLOWING`, relative to the source. |
| `userId` | string | Stable decimal Instagram account ID. |
| `username` | string | Current returned Instagram username. |
| `fullName` | string | Public display name; it can be empty. |
| `profilePicUrl` | string | Public profile image URL; source URLs can expire. |
| `profileUrl` | string | Canonical Instagram profile URL. |
| `isPrivate` | boolean | Publicly returned privacy status. |
| `isVerified` | boolean | Publicly returned verification status. |

The Actor does not accept or export passwords, customer cookies, private-profile contents, email addresses, or contact enrichment.

### Pricing and limits

This Actor uses pay-per-event pricing:

- A `start` event is charged once when a valid run begins.
- An `item` event is charged for each relationship identity saved to the dataset.
- Exact current rates and plan discounts are shown on the [Actor Pricing tab](https://apify.com/fetch_cat/instagram-scraper-followers-following-no-cookies-scraper/pricing).
- Invalid input is rejected before result charges.
- The requested limit applies separately to each source profile.

Instagram can limit, reorder, or temporarily withhold relationship data. A requested limit is a maximum, not a promise that every source has that many accessible identities. Large lists can require continuation runs.

Always check the run OUTPUT status:

- `COMPLETE` means the available list was exhausted.
- `LIMIT_REACHED` means the requested cap was reached.
- `PARTIAL` means saved rows are usable but the export stopped early.
- `FAILED` means no complete result should be assumed; any already saved rows remain available.

### Who is it for?

This Actor is designed for social media analysts, creator partnerships teams, researchers, agencies, growth teams, and developers who need structured public relationship identities instead of counts alone.

### Common use cases

- **Audience research:** compare public follower communities across creators or brands.
- **Creator discovery:** collect public identities for later qualification in your own workflow.
- **Competitive analysis:** study which public accounts a brand follows.
- **Community sampling:** export a bounded sample for manual review or aggregate analysis.
- **CRM preparation:** create a structured source list before permitted enrichment elsewhere.
- **Data pipelines:** feed public relationship rows into a warehouse, spreadsheet, or automation.

### API usage

Replace `<APIFY_TOKEN>` with your Apify API token. The examples use the public Actor identifier `fetch_cat/instagram-scraper-followers-following-no-cookies-scraper`.

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/instagram-scraper-followers-following-no-cookies-scraper').call({
  usernames: ['nasa'],
  dataToScrape: 'followers',
  resultsLimit: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/instagram-scraper-followers-following-no-cookies-scraper').call(run_input={
    'usernames': ['nasa'],
    'dataToScrape': 'followers',
    'resultsLimit': 50,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/fetch_cat~instagram-scraper-followers-following-no-cookies-scraper/runs?token=<APIFY_TOKEN>' \
  -H 'Content-Type: application/json' \
  -d '{"usernames":["nasa"],"dataToScrape":"followers","resultsLimit":50}'
```

### MCP and automation

Use the Actor from an AI client through [Apify MCP](https://mcp.apify.com/?tools=fetch_cat/instagram-scraper-followers-following-no-cookies-scraper).

Add the server to Claude Code:

```bash
claude mcp add apify --transport http \
  'https://mcp.apify.com/?tools=fetch_cat/instagram-scraper-followers-following-no-cookies-scraper'
```

Generic MCP client configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/instagram-scraper-followers-following-no-cookies-scraper"
    }
  }
}
```

Example prompts:

- "Export 25 followers of the public Instagram profile nasa."
- "Get 50 accounts followed by natgeo and return usernames and profile URLs."
- "Run the Instagram followers scraper for these three public profiles and summarize the dataset."

You can also trigger runs from Apify schedules, connect completion webhooks, or read datasets from n8n and Zapier. For repeat workflows, keep limits bounded and inspect OUTPUT before treating a dataset as a complete relationship list. Continuation tokens resume traversal; they do not provide a chronological new-follower monitor.

### Tips for reliable exports

- Start with one public profile and a low result limit.
- Use usernames or canonical profile URLs, not post or reel URLs.
- Do not set both `usernames` and `Account`.
- Keep the same profile order and direction when resuming.
- Deduplicate downstream by `sourceUsername`, `type`, and `userId`.
- Store image URLs only as temporary references because they can expire.
- Treat display names as optional; some accounts intentionally leave them empty.

### FAQ

#### Can I export public Instagram following identities without providing a login?

Yes. Customer passwords, cookies, and sessions are not accepted as Actor inputs. Choose `following` to export public identities followed by a source profile.

#### Can it scrape private-profile followers?

No. The product is limited to relationship data available for public source profiles.

#### Why did I receive fewer rows than requested?

The profile may have fewer accessible relationships, Instagram may temporarily limit the list, or the run may have ended partially. Check OUTPUT for source-level status and continuation information.

#### Are follower results returned in chronological order?

No. Instagram controls ordering, and it can change between requests.

#### How can I export Instagram followers from a public profile?

Enter a public username, select `followers`, and set a result limit. The dataset contains the accessible public relationship identities returned during the run.

#### How can I resume a large Instagram follower export without duplicate rows?

Copy `continuationToken` from OUTPUT into a new run using the same Apify account, profiles, order, and direction. The Actor retains deduplication state for the unfinished traversal.

#### Does resuming return only newly gained followers?

No. Resume continues an unfinished traversal. It is not a follower-change monitoring feed.

#### Are duplicate rows possible?

The Actor deduplicates identities within its saved state. For long-term storage, use `sourceUsername`, `type`, and `userId` as a stable composite key.

### Related Instagram Actors

- [Instagram Profile Posts Scraper](https://apify.com/fetch_cat/instagram-profile-posts-scraper)
- [Instagram Comments Scraper](https://apify.com/fetch_cat/instagram-comments-scraper)
- [Instagram Likes Scraper](https://apify.com/fetch_cat/instagram-likes-scraper)
- [Instagram Hashtag Scraper](https://apify.com/fetch_cat/instagram-hashtag-scraper)
- [Instagram Search Scraper](https://apify.com/fetch_cat/instagram-search-scraper)
- [Instagram Stories & Highlights Scraper](https://apify.com/fetch_cat/instagram-stories-highlights-scraper)

### Support

If a run fails or returns unexpected data, open an issue from the Actor's Apify Store page. Include the public source username, selected direction, requested limit, and run ID. Never include passwords, cookies, tokens, or private account information.

# Actor input Schema

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

Public Instagram usernames or profile URLs. Must not be combined with Account.

## `Account` (type: `array`):

Alias for usernames used by the supplied competitor. Use only one of Account or usernames.

## `dataToScrape` (type: `string`):

Followers are accounts following the source; following are accounts the source follows. Legacy capitalization/plural accepted.

## `resultsLimit` (type: `integer`):

Per-source cap. This does not promise that the requested number is available.

## `continuationToken` (type: `string`):

Resume a previous OUTPUT token using the same Apify caller, normalized profiles and direction. resultsLimit is an additional per-source limit for this run. Tokens expire after seven days or if source storage is deleted.

## Actor input object example

```json
{
  "usernames": [
    "nasa"
  ],
  "dataToScrape": "followers",
  "resultsLimit": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `runStatus` (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 = {
    "usernames": [
        "nasa"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/instagram-scraper-followers-following-no-cookies-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": ["nasa"] }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fetch_cat/instagram-scraper-followers-following-no-cookies-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/o3ggw9A9b4bNbGNXH/builds/rbl0P44HHiKH4GlZR/openapi.json