# Instagram Likers Scraper – Post & Reel Like (`lance_api/instagram-likers-scraper`) Actor

Scrape public Instagram liker profiles from Posts and Reels. Get usernames, user IDs, profile links, verification status, source media, and structured engagement data for audience research, creator analysis, campaigns, and automation.

- **URL**: https://apify.com/lance_api/instagram-likers-scraper.md
- **Developed by:** [LanceAPI](https://apify.com/lance_api) (community)
- **Features:** Limited permissions
- **Stats:** 16 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 liker 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Instagram Likers Scraper API

**See who liked public Instagram Posts and Reels—and turn the available liker profiles into clean, structured data.**

Give the Actor a public Instagram Post or Reel, and it returns the currently available public liker profiles for that media: username, full name, user ID, profile URL, and verification or privacy status when available. Every row also keeps the exact Post or Reel it came from, so a batch of media becomes one source-linked Dataset you can export to CSV or Excel, load into a database, or send to n8n, Make, or an AI/data workflow.

- **Research up to 200 Posts and Reels in one run**—collect campaign, creator, or competitor engagement data without starting a separate run for every media item.
- **Control the sample size for each media item**—set `resultsLimit` from 1 to 1,000 to match your research scope and budget.
- **Keep every liker connected to the right source**—compare engagement across content without rebuilding Post-to-liker relationships yourself.
- **Pay for unique work and delivered results**—repeated media and duplicate liker rows are deduplicated before the corresponding charges are created.

### ✨ Key features

#### 1. Find who liked Instagram Posts and Reels

Paste a public Post or Reel URL—or just the shortcode—and receive the public liker profiles currently available for that media. Regular `/p/` Posts and `/reel/` Reels are both supported, giving you a structured way to answer “who liked this Instagram Post or Reel?” without reviewing liker lists by hand.

#### 2. Get analysis-ready liker profiles

Each liker is returned as a clean row with the public profile fields available for that account:

- `username`
- `fullName`
- `userId`—a stable identifier normalized as a string
- `profileUrl`
- `profilePicUrl`
- `isVerified`
- `isPrivate`

Optional details may be unavailable for some profiles. They are returned as `null` rather than guessed, and placeholder or access-denied text is not passed through as a name. This gives your spreadsheet, database, or workflow consistent values to work with.

#### 3. Keep every liker connected to its source content

Every row carries `sourceUrl`, `sourceShortcode`, and `sourceType`, so a multi-post Dataset still shows exactly which Post or Reel each liker engaged with. Use these source-linked rows in your own tools to study cross-post audience overlap, repeat likers, or campaign and creator engagement.

#### 4. Research up to 200 Posts and Reels in one run

Submit an entire campaign, a creator's recent uploads, or a competitor content set together instead of starting a separate run for every media item. Duplicate references to the same supported media are recognized and processed once.

#### 5. Control result volume up to 1,000 likers per media

Set `resultsLimit` from 1 to 1,000 to match the size and budget of your research. It is an upper limit rather than a promised result count—see [How many likers can I get?](#how-many-likers-can-i-get).

#### 6. Keep result billing predictable

Liker result charges apply only to unique liker rows successfully saved to the Dataset. Within one media item, duplicate rows are removed before delivery, while invalid or repeated media rejected before processing do not create processing charges. See the Pricing section for the current rates and a worked example.

### 🚀 Quick start

1. Paste a public Instagram Post or Reel URL—or shortcode—into `posts`.
2. Click **Start**.
3. When the run finishes, open **Output → Likers** to browse, filter, and export the results.

```json
{
  "posts": ["https://www.instagram.com/p/DLm63qQpxvw/"],
  "resultsLimit": 200
}
```

For your first run, keep the default `resultsLimit: 200`. Increase it only when you need a larger sample of the publicly available liker profiles.

### Example result

Every Dataset row is one **liker × source media** relationship:

```json
{
  "profilePicUrl": "https://scontent.cdninstagram.com/.../profile.jpg",
  "username": "example_username",
  "fullName": "Example Name",
  "profileUrl": "https://www.instagram.com/example_username/",
  "userId": "1234567890",
  "isVerified": false,
  "isPrivate": false,
  "position": 1,
  "sourceUrl": "https://www.instagram.com/p/DLm63qQpxvw/",
  "sourceShortcode": "DLm63qQpxvw",
  "sourceType": "post",
  "reportedLikeCount": 12500,
  "availableLikerCount": 480,
  "scrapedAt": "2026-10-05T09:14:22.031Z"
}
```

This example shows the **row structure** of the Likers Dataset, using the media from the input example above. All profile fields and both count values are illustrative placeholders, not copied from a live run—real runs return the actual public values available at run time. See [Output field reference](#output-field-reference) for what each field means.

### Use cases

**Audience research**—use the returned public liker profiles to build structured datasets for analysis in your own tools.

**Creator and influencer research**—use source-linked results to study public engagement around a creator's content and compare liker overlap across Posts or Reels.

**Campaign research**—collect liker rows across campaign content, then measure public engagement patterns in your preferred spreadsheet, database, or analytics workflow.

**Competitor research**—use the returned data to compare public liker audiences across competitor content, product launches, or campaigns in your own analysis.

**Content engagement analysis**—use each row's source fields to compare individual Posts and Reels rather than relying only on aggregate like counts.

**Cross-post audience overlap**—collect several media items, then compare `userId` values to identify public liker profiles that appear across more than one source.

**Data and AI workflows**—send the Dataset to spreadsheets, databases, dashboards, n8n, Make, or downstream AI and data analysis.

The Actor collects and structures public liker data. Any comparison, segmentation, scoring, or other downstream analysis is performed in your own tools.

### How it works

1. Add supported Instagram Post URLs, Reel URLs, or bare shortcodes.
2. The Actor validates the input and recognizes duplicate forms of the same supported media, so that Post or Reel is processed once.
3. Each unique media item is handled independently, so one unavailable source does not stop the rest of the batch.
4. The Actor collects the currently available public liker profiles. Within each media item, the same liker is delivered once to keep the Dataset clean and avoid duplicate result charges.
5. Every delivered row is connected to its source Post or Reel and saved to the Dataset.
6. Per-source status, counts, and billing totals are saved in `RUN_SUMMARY`, helping you review or troubleshoot an individual media item.
7. Use the results in Apify Console, through the API, or in your downstream automation and analysis tools.

### Input

| Field | Type | Required | Default | Description |
|---|---|---:|---:|---|
| `posts` | `string[]` | Yes | — | 1 to 200 public Instagram Post or Reel URLs, or shortcodes. Duplicate media are processed once. |
| `resultsLimit` | `integer` | No | `200` | Maximum number of unique liker profiles to return **per media**, from 1 to 1,000. This is an upper limit, not a guaranteed count. |

#### Supported input formats

- `https://www.instagram.com/p/{shortcode}/`
- `https://www.instagram.com/reel/{shortcode}/`
- A bare shortcode such as `DLm63qQpxvw`

Public Post and Reel media only. When you supply a bare shortcode, `sourceType` is reported as `unknown` because the URL does not establish whether the media is a Post or a Reel.

### Batch processing

- Research up to **200** Posts and Reels in one run instead of starting each media item separately.
- Repeated references to the same supported media are processed once, helping prevent duplicate processing charges.
- Each media source is handled independently, so one unavailable item does not stop the rest of the batch.
- Every delivered liker row keeps its source Post or Reel, making the merged Dataset ready for cross-source analysis.

### Output

The Dataset **Likers** view contains one row per liker relationship.

- The same Instagram user can appear once for each different source media they liked—that is a distinct, valid relationship.
- Within a single source media, rows are deduplicated by `userId`.
- Results are capped by `resultsLimit` per media.

Alongside the Dataset, the run stores a `RUN_SUMMARY` record with per-source outcomes and totals. Use it to review or troubleshoot a specific Post or Reel from the run's Output tab.

### Output field reference

| Field | Type | Meaning |
|---|---|---|
| `profilePicUrl` | `string \| null` | Profile image URL, when exposed. Usually a temporary CDN URL that may expire. |
| `username` | `string \| null` | Instagram username, when exposed. |
| `fullName` | `string \| null` | Public display name. `null` when it is absent, empty, or when the data source returns placeholder or access-denied text instead of a real name. |
| `profileUrl` | `string \| null` | Profile URL derived from `username`; `null` when no username was exposed. |
| `userId` | `string` | Stable liker ID, normalized as a string. Always present. |
| `isVerified` | `boolean \| null` | Verification status, when exposed. |
| `isPrivate` | `boolean \| null` | Privacy status, when exposed. |
| `position` | `integer` | One-based position of the row inside the delivered result set. **It is not like-time order.** |
| `sourceUrl` | `string` | Canonical URL of the source Post or Reel. |
| `sourceShortcode` | `string` | Canonical Instagram media shortcode. |
| `sourceType` | `post \| reel \| unknown` | Source media type. Shortcode-only input stays `unknown` unless it can be confirmed. |
| `reportedLikeCount` | `integer \| null` | Total likes reported for the media, when the data source supplies it; otherwise `null`. |
| `availableLikerCount` | `integer` | Number of unique public liker profiles collected for this media in this run, before `resultsLimit` is applied. |
| `scrapedAt` | `string` (ISO 8601 date-time) | When this collection ran. |

### How many likers can I get?

**`resultsLimit` is the maximum number you request—not a guaranteed count.**

Instagram can display a total like count that is much larger than the number of liker profiles publicly available for collection. The gap varies by media and can change over time.

That is why three values represent separate facts:

- `reportedLikeCount`—the total likes reported for the media when supplied; it can be `null`.
- `availableLikerCount`—the unique public liker profiles collected in this run before `resultsLimit` is applied.
- Dataset rows—the results delivered after `resultsLimit` and the run spending limit are applied.

Using the illustrative row above as a worked example: the media reports `12,500` likes, `480` unique liker profiles were available, and `200` rows are delivered when `resultsLimit` is `200`.

A run that requests `1,000` and returns fewer profiles can still be successful. The Actor returns the profiles it can collect up to your limit; it does not invent rows or promise the displayed like count.

### Status and errors

Per-source status and codes are recorded in the `RUN_SUMMARY` output record.

| Status / code | Meaning | What to do |
|---|---|---|
| `success` | The media was processed and results were delivered. This also applies when the public liker list ends below `resultsLimit`. | Check the Dataset. |
| `no_likers` | The media was processed, but no public liker profile was available. | Verify that the Post or Reel is public. |
| `partial_success` / `partial_results` | Some valid rows were delivered, but the run spending limit was reached or an optional collection step did not finish. | Raise the spending limit and retry if you need more. |
| `invalid_input` | The value is not a supported Post/Reel URL or shortcode. | Correct the input value. |
| `media_not_found` | The media could not be found or is no longer public. | Check the URL in a browser. |
| `likes_unavailable` | The liker list is not publicly available for this media. | Try different public media. |
| `data_source_rate_limited` / `data_source_timeout` / `data_source_error` | A temporary data-source issue prevented completion. | Retry the run later. |
| `spending_limit_reached` | The run spending limit stopped delivery. | Raise the limit and retry. |
| `usage_limit_exceeded` | The free-plan usage allowance for this Actor has been reached. | Upgrade to a paid Apify plan or contact support. |
| `internal_error` | The source could not be processed safely. | Retry; if it repeats, contact support with the Run ID. |

### 💰 Pricing

This Actor uses **pay-per-event** pricing, so you can estimate the cost from the number of media items processed and liker rows delivered.

- **Actor start—`$0.0005`** per run.
- **Media processing—`$0.001`** per unique valid Post or Reel that enters processing, for every pricing tier.
- **Liker results—priced per delivered unique liker row**, with lower rates for higher Apify pricing tiers.

| Apify pricing tier | Per delivered liker row | Per 1,000 delivered liker rows | 1 Post + 200 liker rows, including start |
|---|---:|---:|---:|
| **FREE** | `$0.0013` | `$1.30` | about `$0.2615` |
| **BRONZE** | `$0.0010` | `$1.00` | about `$0.2015` |
| **SILVER** | `$0.0008` | `$0.80` | about `$0.1615` |
| **GOLD and above** | `$0.0007` | `$0.70` | about `$0.1415` |

Each worked example includes one `$0.0005` Actor start, one `$0.001` media processing event, and 200 delivered liker rows at that tier's rate.

Repeated media and duplicate liker rows are deduplicated, so the same media does not create duplicate processing charges and the same liker within one media does not create duplicate result charges.

You are not charged for:

- Input media rejected as invalid or duplicate before processing—no processing charge.
- Duplicate liker rows, unavailable liker profiles, or empty liker results—no result charge.
- Recovery after a temporary data-source issue—no additional processing charge.

Delivery stops when the run's pay-per-event spending limit is reached, helping you keep each run within the budget you choose.

**See the Actor's Pricing tab for the current published rates and any plan-specific pricing available to your account.**

#### Free-plan users

Free-plan users are subject to the current free usage allowance configured for this Actor. Paid users are not subject to that allowance.

### API usage

Run the Actor programmatically and retrieve the default Dataset when it finishes. Replace the sample input with your own media.

#### JavaScript

```bash
npm install apify-client
```

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('lance_api/instagram-likers-scraper-api').call({
  posts: ['https://www.instagram.com/p/DLm63qQpxvw/'],
  resultsLimit: 200,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].username, items[0].sourceUrl);
```

#### Python

```bash
pip install apify-client
```

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])

run = client.actor('lance_api/instagram-likers-scraper-api').call(run_input={
    'posts': ['https://www.instagram.com/p/DLm63qQpxvw/'],
    'resultsLimit': 200,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[0]['username'], items[0]['sourceUrl'])
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/lance_api~instagram-likers-scraper-api/runs?waitForFinish=120" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"posts":["https://www.instagram.com/p/DLm63qQpxvw/"],"resultsLimit":200}'
```

```bash
## Fetch the default Dataset of the finished run
curl "https://api.apify.com/v2/datasets/{datasetId}/items?format=json" \
  -H "Authorization: Bearer $APIFY_TOKEN"
```

#### Dataset formats

Fetch the finished run's Dataset as JSON, JSONL, CSV, Excel, XML, or RSS using Apify's Dataset API:

```text
https://api.apify.com/v2/datasets/{datasetId}/items?format=csv
```

### FAQ

**Can I see who liked an Instagram Post?**\
Yes. Provide the public Post URL or shortcode and the Actor returns the public liker profiles available for it.

**Can I see who liked an Instagram Reel?**\
Yes. Reel URLs (`https://www.instagram.com/reel/{shortcode}/`) work the same way as Posts.

**Is this an Instagram Likes Scraper or an Instagram Likers Scraper?**\
Both terms are commonly used for this task. This Actor returns the available liker profiles behind the likes—not only a numeric like count.

**What information do I get about each liker?**\
The public profile fields available for each liker: `username`, `fullName`, `userId`, `profileUrl`, `profilePicUrl`, `isVerified`, and `isPrivate`, plus source and collection metadata.

**How many likers can I get per Post or Reel?**\
Up to the `resultsLimit` you request, with a maximum of `1,000` per media—but only as many as are currently available to collect. See [How many likers can I get?](#how-many-likers-can-i-get).

**Why is the liker count lower than the displayed Instagram like count?**\
The displayed like count and the number of liker profiles publicly available for collection are different. A Post can show many more likes than available profiles.

**Can I process multiple Posts and Reels at once?**\
Yes. Submit up to 200 media items in one run. Repeated media are processed once, and each source is handled independently.

**Can I identify users who liked multiple Posts?**\
Yes. The Dataset preserves `userId` and source media for every delivered relationship, so you can compare overlap across sources in your own tools.

**Does the Actor return the time someone liked a post?**\
No. Like timestamps are not available, and the Actor does not reconstruct like order.

**Does `position` represent like order?**\
No. `position` is only the row's position in the delivered result set.

**Can I scrape private Posts or private liker lists?**\
No. The Actor works with public media and publicly available liker data only. It does not bypass login, privacy, or other access controls.

**Does the Actor require an Instagram login or cookies?**\
No. There is no Instagram login, password, or cookie input. The Actor only needs media URLs or shortcodes.

**Are duplicate likers charged twice?**\
No. Within one source media, each unique liker row is delivered and charged once. The same user under another source is a separate valid relationship and result.

**Will a temporary data-source issue charge processing twice?**\
No. Processing is charged at most once per unique valid media item that starts processing.

**How much does it cost?**\
Each run has a `$0.0005` Actor start charge and a `$0.001` charge for each unique media item that enters processing. Delivered liker rows range from `$0.0013` each on FREE to `$0.0007` each on GOLD and higher tiers—that is `$1.30` to `$0.70` per 1,000 delivered liker rows. See the Actor's Pricing tab for current published rates.

### Limitations

- Up to 200 media sources can be submitted per run.
- Up to 1,000 liker profiles can be requested per media item.
- Only public Post, Reel, and liker data can be collected.
- Far fewer liker profiles may be publicly available than the displayed like count suggests.
- Some optional profile fields may be unavailable and are returned as `null`.
- Profile image URLs are usually temporary and may expire.
- Like timestamps and original like order are not available.
- `position` is a Dataset ordering value, not like order.
- Field coverage and public availability can change over time.

### Public data and responsible use

- The Actor works with publicly accessible Instagram Post and Reel liker data.
- No Instagram password, login, or cookie is required from you.
- Use the returned data in accordance with applicable platform terms, Apify terms, privacy rights, and law.
- Do not use this Actor for harassment, spam, unsolicited outreach, unlawful profiling, or attempts to obtain non-public data.

### Support

Open an issue on the Actor page or email <lanceapi2026@hotmail.com>.

For a bug report, include:

- Apify Run ID
- a non-sensitive public Post or Reel URL
- the `resultsLimit` used
- the relevant status or error code from `RUN_SUMMARY`, if available

Do **not** send:

- Apify Token or `APIFY_TOKEN`
- Cookie
- Session ID
- Password
- API Key
- Proxy credentials
- Authorization header

# Actor input Schema

## `posts` (type: `array`):

Public Instagram Post/Reel URLs or shortcodes. Add up to 200 items in one batch. Duplicate references to the same media are processed only once.

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

Maximum number of unique liker profiles returned per post or Reel. Instagram may expose fewer public likers than requested, so this is an upper limit rather than a guaranteed count.

## Actor input object example

```json
{
  "posts": [
    "https://www.instagram.com/p/DLm63qQpxvw/"
  ],
  "resultsLimit": 200
}
```

# Actor output Schema

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

Unique liker relationship rows successfully delivered by this run.

## `runSummary` (type: `string`):

Per-media status, available and delivered liker counts, and charged event counts.

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

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lance_api/instagram-likers-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/vV1g2QfLKTw9TRZfx/builds/EO5EThAfWB0kzL97v/openapi.json