# Instagram Likers Scraper | $0.50/1K on Starter (`publicsignallabs/instagram-likers-scraper`) Actor

Extract users who liked Instagram posts and reels for about $0.50 per 1,000 rows on Starter. Results are subject to availability from Instagram. No login, cookies, browser, or proxy setup.

- **URL**: https://apify.com/publicsignallabs/instagram-likers-scraper.md
- **Developed by:** [Public Signal Labs](https://apify.com/publicsignallabs) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.45 / 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?

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 Likers Scraper | $0.50/1K on Starter

Extract users who liked Instagram posts and reels into structured account rows for audience research, campaign analysis, creator discovery, and social media workflows. Results are subject to availability from Instagram. About $0.50 per 1,000 rows on Starter. No login, cookies, browser, or proxy setup.

### What this Actor does

- Accepts one or more public Instagram post or reel URLs
- Also accepts bare post/reel shortcodes
- Returns the available ranked list of users who liked each source
- Preserves source provenance, current rank, total-like count, and available-liker count
- Works without Instagram credentials, cookies, session IDs, browsers, or proxy configuration
- Exports structured rows to JSON, CSV, Excel, XML, and other Apify dataset formats

Use it for public audience sampling, campaign engagement review, creator discovery, brand research, and repeatable data pipelines where a specific public post or reel is the source boundary.

### Quick start

1. Enter one or more public Instagram post/reel URLs or bare shortcodes.
2. Set the maximum number of users returned for each source.
3. Run the Actor, then preview or export the default dataset.

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

### Input

| Field | Rules |
| --- | --- |
| `posts` | Required list of public Instagram sources. Supported URL paths are `/p/<shortcode>`, `/reel/<shortcode>`, and `/reels/<shortcode>`. Bare shortcodes are also accepted. The schema accepts up to 50 unique sources; plan-specific limits are detailed in Pricing. |
| `resultsLimit` | Required integer per source from 25 through 3,000. Default and Store prefill: 200. Plan-specific effective limits are detailed in Pricing. |

URL query strings and fragments are removed. Duplicate URL/shortcode forms that identify the same media are rejected before extraction. Profile, Story, Explore, redirect, non-Instagram, and numeric-media-ID inputs are not accepted.

### Dataset rows

Every charged dataset item has exactly this shape:

```json
{
  "source_input": "https://www.instagram.com/reel/ExampleCode/",
  "source_shortcode": "ExampleCode",
  "source_url": "https://www.instagram.com/reel/ExampleCode/",
  "source_type": "reel",
  "total_like_count": 20159,
  "available_liker_count": 1996,
  "rank": 1,
  "id": "9007199254740997",
  "username": "sample_creator",
  "full_name": "Sample Creator",
  "is_private": false,
  "is_verified": false,
  "profile_pic_url": "https://...",
  "profile_url": "https://www.instagram.com/sample_creator/"
}
```

| Field | Meaning |
| --- | --- |
| `source_input` | Submitted source after whitespace trimming |
| `source_shortcode` | Validated case-sensitive Instagram media shortcode |
| `source_url` | Normalized public post/reel URL when a URL was supplied; `null` for a bare shortcode |
| `source_type` | `post`, `reel`, or `unknown` for a bare shortcode |
| `total_like_count` | Total like count reported for the source when the request ran |
| `available_liker_count` | Unique valid users in the current available response before applying `resultsLimit` |
| `rank` | One-based position in the current ranked response |
| `id` | Stable Instagram user ID represented as a string |
| `username` | Current public username |
| `full_name` | Public display name; empty when absent |
| `is_private` | Whether the liker account is private |
| `is_verified` | Whether the liker account is verified |
| `profile_pic_url` | External profile-image URL when available; it may expire |
| `profile_url` | Public profile URL constructed from the username |

Duplicate user IDs are removed within each source. The same user can legitimately appear once for each requested source because every row retains customer-visible source provenance.

### Ranked-snapshot boundary

Instagram does not expose every liker of high-engagement media through this surface. This Actor returns the **currently available ranked snapshot** in the order received.

- Small sources may return every liker.
- High-engagement sources usually return a bounded subset.
- The available count varies by post, reel, and request time.
- There is no supported next page or continuation token.
- Running the same source later may return a changed count or order.

`total_like_count` reports the source's current overall count. `available_liker_count` reports how many unique valid users were available to this run. `resultsLimit` then caps how many of those available rows are stored.

### Pricing

Billing uses two transparent events:

1. one **post or reel source** event for each source successfully validated and processed, including a valid source with no current likers;
2. one **dataset item** event for each persisted liker row.

The source event costs `$0.003` per individual post or reel. Apify may display this normalized as `$3.00 / 1,000` source events; it does **not** mean one source costs $3.00. It covers validating and processing one source independently of how many liker rows are available.

Invalid, unavailable, restricted, or temporarily failed sources do not incur a source or row event. If a run reaches its spending limit, it stops before storing an uncharged row.

| Plan | Source event | Dataset item | One source / 1,000 rows |
| --- | ---: | ---: | ---: |
| Free | $0.003 | $0.00050 | $0.503 |
| Starter | $0.003 | $0.00050 | $0.503 |
| Scale | $0.003 | $0.00048 | $0.483 |
| Business | $0.003 | $0.00045 | $0.453 |

Starter examples:

- valid source with no available likers: $0.003;
- one source returning 25 rows: $0.0155;
- one source returning 200 rows: $0.103;
- one source returning 1,000 rows: $0.503.

Multiple sources are priced independently.

#### FREE demo limits

FREE Apify accounts can run this Actor up to 5 times per UTC calendar month. Each admitted FREE run accepts exactly one post or reel and returns up to 200 liker rows for it. There is no continuation workflow in any plan. Console, CLI, API, schedules, webhooks, MCP, and other Apify launch methods share the same account allowance. A run counts once admitted even when it is later aborted or unsuccessful, and resurrecting it does not start another extraction. Creating another task or API token does not reset the allowance. Paid Apify users are not subject to these demo limits.

### Run summary

Run status, source charges, row counts, availability, truncation, and sanitized failures are stored in the default key-value store's `OUTPUT` record rather than mixed into the dataset:

Allowance exhaustion and replay complete the Apify run successfully, while `OUTPUT.status` remains `FAILED`; the stable `stopReason`/`freeTier.outcome` remains machine-readable, and identity/quota verification errors still fail the platform run.

```json
{
  "status": "SUCCEEDED",
  "stopReason": null,
  "isPaying": true,
  "requestedSources": 1,
  "resultsLimitPerSource": 200,
  "deliveredCount": 200,
  "chargedCount": 200,
  "sourceChargedCount": 1,
  "sources": [
    {
      "inputIndex": 0,
      "sourceShortcode": "ExampleCode",
      "sourceUrl": "https://www.instagram.com/reel/ExampleCode/",
      "sourceType": "reel",
      "status": "succeeded",
      "totalLikeCount": 20159,
      "availableLikerCount": 1996,
      "deliveredCount": 200,
      "chargedCount": 200,
      "sourceCharged": true,
      "truncated": true
    }
  ]
}
```

`status` can be `SUCCEEDED`, `PARTIAL`, `FAILED`, or `CHARGE_LIMIT_REACHED`. Inspect every source entry when a run contains multiple sources. Aggregate non-PII request, retry, transfer, duplicate, mapping, source-charge, row-charge, storage-stop, and timing metrics are stored separately in `AUDIT`.

Admitted FREE runs include a `freeTier` object with the UTC month, claimed slot, remaining allowance, effective result limit, and policy version. Rejected FREE runs use stable reasons such as `free_monthly_limit`, `free_run_already_consumed`, or `free_quota_unavailable`. The record never contains an Apify user ID, API token, or internal quota-storage identifier.

### FREE boundary

FREE runs accept exactly one source with a plan-specific effective row cap, checked before extraction. The public schema retains paid limits so the same input works after upgrading. The exact FREE demo limits are detailed in Pricing.

### Limitations

This Actor:

- returns the current ranked public snapshot, not every liker or a historical archive;
- has no pagination or continuation workflow;
- does not poll sources or accumulate users across runs;
- does not return when a user liked the source because that timestamp is not exposed;
- does not bypass private-content, deleted-content, age, region, or other access restrictions;
- cannot guarantee stable counts, ordering, usernames, or permanent profile-image URLs;
- may fail temporarily when Instagram changes or limits public access.

A private liker account may appear because the like relationship is exposed on a public source. The Actor does not open or extract that account's private posts.

### Public-data and privacy guidance

Use this Actor only for lawful purposes and public data you are permitted to process. Apply appropriate notice, retention, security, and deletion controls for your jurisdiction and use case. Do not use the output for harassment, discrimination, sensitive-trait inference, or attempts to access private content.

This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Instagram or Meta.

### API example

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

After completion, use the run's default dataset URL to download JSON, CSV, Excel, XML, or another supported export format.

### Support

Use the **Issues** tab on this Actor's Apify Store page. Include the run ID, expected result, and observed result. Never include API tokens, Instagram credentials, cookies, or other secrets.

# Actor input Schema

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

Canonical Instagram post/reel URLs or bare shortcodes. Supported URL paths are /p/, /reel/, and /reels/. The schema accepts up to 50 unique sources; plan-specific limits are detailed in Store Pricing.

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

Maximum users returned for each source, ranked by Instagram. Schema range: 25–3,000; plan-specific effective limits are detailed in Store Pricing.

## Actor input object example

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

# Actor output Schema

## `likers` (type: `string`):

Charged live ranked liker rows from the default dataset, ready for preview or export.

## `summary` (type: `string`):

Run status, FREE policy outcome, delivered and charged counts, and sanitized per-source outcomes.

## `audit` (type: `string`):

Aggregate request, retry, source-charge, row-charge, duplicate, mapping, transfer, and timing metrics.

# 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/ExampleCode/"
    ],
    "resultsLimit": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("publicsignallabs/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/ExampleCode/"],
    "resultsLimit": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("publicsignallabs/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/ExampleCode/"
  ],
  "resultsLimit": 200
}' |
apify call publicsignallabs/instagram-likers-scraper --silent --output-dataset

```

## MCP server setup

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