# Instagram Post Likers Scraper · No Login (`memo23/instagram-likers-scraper`) Actor

Scrape the likers of any public Instagram post or reel — username, full name, verified & private flags, profile pic and URL. No login, no cookies, zero account risk. Great for engagement audits and lead generation. Multiple posts per run. JSON, CSV, or Excel.

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

## Pricing

from $0.70 / 1,000 liker scrapeds

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 Post Likers Scraper

<p align="center">
  <img src="https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/instagram-likers-logo.png" alt="Instagram Post Likers Scraper" width="240" />
</p>

**Scrape the likers of any public Instagram post or reel — no login, no cookies, zero risk to your account.** Paste post or reel URLs and get back every account that liked them, with username, full name, verification status, privacy flag, profile picture, and profile URL. Export as JSON, CSV, or Excel.

| Input | What you get |
|---|---|
| A post/reel URL (e.g. `.../p/CODE/`) | Every account that liked it, one row each |
| Multiple URLs | Likers for all of them in one run, tagged by `sourcePostUrl` |

> Pure HTTP. No browser, no CAPTCHA solver, no cookies.

### Why Use This Scraper?

- **Zero account risk** — no login, no cookies, no session handover.
- **Engagement audits & lead gen** — see exactly who engages with a post, then filter by verified, private, or name.
- **Clean, flat output** — one row per liker, ready for CRM import, lookalike building, or influencer analysis.
- **Break the per-call liker cap (opt-in)** — Instagram exposes only a ranked slice (typically a few hundred) per call. Every run adds the likers it sees to a permanent archive, so turning on `includeHistorical` returns likers accumulated across earlier runs too — **more likers than any single call can return**. Re-run a post over time and its coverage keeps growing.
- **Multiple posts per run** — pass a list of URLs; every row is tagged with its source post.
- **Fast** — pure HTTP.

### How It Works

<p align="center">
  <img src="https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-instagram-likers.png" alt="How the Instagram Post Likers Scraper works" width="900" />
</p>

1. **Resolve** — each post/reel URL is looked up to its Instagram media.
2. **Fetch** — the post's likers are pulled (Instagram returns a ranked list, typically a few hundred).
3. **Emit** — every liker is pushed to the dataset as its own row, tagged with `sourcePostUrl`.

### Input

| Field | Type | Required | Notes |
|---|---|---|---|
| `postUrls` | array of strings | Yes | Public post/reel URLs (`.../p/CODE/`, `.../reel/CODE/`) or bare shortcodes. |
| `maxLikersPerPost` | integer | No | Cap likers per post. Omit for all available. |
| `includeHistorical` | boolean | No | Also return likers of this post captured on earlier runs that aren't in the current call — exceeding Instagram's per-call cap. Tagged `source:"archive"`. Charged at the premium historical rate. Default: `false`. |

#### Example input

```json
{
    "postUrls": ["https://www.instagram.com/p/CxxznqSufDh/"],
    "maxLikersPerPost": 100
}
```

### Output Schema

One dataset row per liker.

```jsonc
{
    "sourcePostUrl": "https://www.instagram.com/reel/CxxznqSufDh/",
    "sourceShortCode": "CxxznqSufDh",
    "sourceMediaPk": "3202567835880124641",
    "userId": "2000252276",
    "username": "daniela.hadbavna",
    "fullName": "Daniela Hadbavná",
    "isVerified": false,
    "isPrivate": true,
    "profilePicUrl": "https://scontent.cdninstagram.com/v/…",
    "profileUrl": "https://www.instagram.com/daniela.hadbavna/"
}
```

When `includeHistorical` is on, archived likers carry three extra fields: `source: "archive"`, `firstSeenAt`, and `lastSeenAt` (ISO timestamps for when that liker was first and last seen on this post). Live likers have no `source` field.

### Pricing

Pay-per-event — you're charged only for the likers you collect. Rates decrease with your Apify plan tier.

| Event | When it's charged | Rate (Free → Gold+) |
|---|---|---|
| Liker scraped | Once per liker row returned from the live call | $0.0010 → $0.0007 |
| Historical liker | Once per archived liker returned, only with `includeHistorical` | $0.0020 → $0.0014 |

Historical likers are priced higher because they're data a single live call cannot return — accumulated past Instagram's per-call cap. No subscription, no per-run start fee. Posts that are private, deleted, or have hidden likes return an error item and are **not** charged.

### Use Cases

| Audience | How they use it |
|---|---|
| Sales / lead gen | Build lead lists from accounts engaging with a competitor's post |
| Growth teams | Create lookalike audiences from a viral post's likers |
| Influencer analysts | Audit real engagement on sponsored posts |
| Researchers | Map interest networks from public engagement |

### FAQ

**Do I need to log in or provide cookies?**
No. It never asks for a login, password, or session.

**Which posts work?**
Public posts and reels. Private accounts, deleted posts, and posts with hidden like counts return an error item and continue with your other URLs.

**How many likers do I get per post?**
Instagram returns a ranked likers list — typically up to a few hundred per post, not necessarily every like.

**Can I get more likers than that cap?**
Yes, over time. Every run stores the likers it sees in a permanent archive, so enabling `includeHistorical` also returns likers captured on earlier runs that today's call didn't include. Re-running a post periodically accumulates a larger set than any single call can return. Archived likers are tagged `source:"archive"` and billed at the premium historical rate.

### Notes & Limitations

- Instagram caps the likers list it exposes; very high-like posts return the ranked top, not the full count.
- Posts with "hide like counts" enabled may not expose likers.
- `includeHistorical` returns only likers already in the archive (captured on earlier runs). A post never scraped before has no history yet and returns nothing extra.

### 🤖 For AI Agents & LLM Apps

**Purpose:** Return the likers of public Instagram posts/reels with profile info.

**Minimal tested input:**

```json
{ "postUrls": ["https://www.instagram.com/p/CxxznqSufDh/"], "maxLikersPerPost": 50 }
```

**Optional flags:** `includeHistorical: true` also returns likers of the post captured on earlier runs (exceeding Instagram's per-call cap), tagged `source:"archive"` with `firstSeenAt`/`lastSeenAt`.

**Output:** array of flat objects, one per liker. Fields: `sourcePostUrl`, `sourceShortCode`, `sourceMediaPk`, `userId`, `username`, `fullName`, `isVerified`, `isPrivate`, `profilePicUrl`, `profileUrl`. Archived rows (with `includeHistorical`) add `source: "archive"`, `firstSeenAt`, `lastSeenAt`. Private/deleted/hidden-like posts yield one error item (`{sourcePostUrl, error, message}`).

**Behavior & billing:** Pay-per-event, tiered — `liker-scraped` ($0.0010→$0.0007 per live liker) and `historical-liker` ($0.0020→$0.0014 per archived liker, only with `includeHistorical`). No login or cookies required.

### Support

Found a bug or need a field added? Open an issue on the Actor's **Issues** tab in Apify Console, or email <muhamed.didovic@gmail.com>.

### ⚠️ Disclaimer

This Actor scrapes only publicly available data and does not log into any Instagram account. Use it in compliance with Instagram's Terms of Use, applicable laws, and data-protection regulations (such as GDPR and CCPA). You are responsible for how you collect and use the data, including obtaining any consent required for personal data.

### SEO Keywords

instagram likers scraper, instagram post likers, who liked instagram post, instagram likes scraper, instagram engagement scraper, instagram lead generation, instagram lookalike audience, scrape instagram likes, instagram post engagement, no login instagram scraper, instagram likers export, apify instagram likers

# Actor input Schema

## `postUrls` (type: `array`):

URLs of public Instagram posts or reels whose likers (the accounts that liked them) you want to scrape. Accepts full URLs (https://www.instagram.com/p/CODE/, /reel/CODE/) or bare shortcodes, one per line. Posts with hidden likes or from private accounts return an error item. Example: \["https://www.instagram.com/p/CxxznqSufDh/"].

## `maxLikersPerPost` (type: `integer`):

Maximum number of likers to collect per post. Instagram caps the ranked likers list (typically a few hundred). Leave empty to collect all available. Example: 100.

## `includeHistorical` (type: `boolean`):

Also return likers of this post captured on earlier runs that aren't in the current call — Instagram caps a single likers call at ~200, so re-running over time accumulates a larger set than any one call can return. Historical rows are tagged source:"archive" with firstSeenAt/lastSeenAt and charged at the normal per-liker rate. Off by default.

## Actor input object example

```json
{
  "postUrls": [
    "https://www.instagram.com/p/CxxznqSufDh/"
  ],
  "includeHistorical": false
}
```

# 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 = {
    "postUrls": [
        "https://www.instagram.com/p/CxxznqSufDh/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/instagram-likers-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 = { "postUrls": ["https://www.instagram.com/p/CxxznqSufDh/"] }

# Run the Actor and wait for it to finish
run = client.actor("memo23/instagram-likers-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 '{
  "postUrls": [
    "https://www.instagram.com/p/CxxznqSufDh/"
  ]
}' |
apify call memo23/instagram-likers-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/uStstncuFsmRzRF4f/builds/pIEjKh68EDpDr06D8/openapi.json
