# Instagram Profile Scraper – Followers & Engagement (`lance_api/instagram-profile-scraper`) Actor

Scrape Instagram profiles in bulk by username, profile URL, or user ID. Get bio, followers, public contact details, recent Posts/Reels, and optional Engagement Insights for creator research, competitor analysis, lead enrichment, and automation.

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

## Pricing

from $2.00 / 1,000 profiles

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 Profile Scraper API

**Scrape Instagram profiles in bulk with bio, followers, public contact details, recent Posts/Reels, and optional Engagement Insights for creator research, competitor analysis, and automated workflows.**

Submit usernames, `@handles`, Instagram profile URLs, or numeric user IDs. The Actor returns one Dataset row per unique profile for export, automation, databases, dashboards, or downstream AI analysis.

- Process up to **200 profiles per run**.
- Get profile, audience, account type, category, verification, and public contact fields.
- Include recent public Posts/Reels without a separate per-post fee.
- Turn Profile Data into Profile Intelligence with optional Profile-level Engagement Insights: engagement rate, average interactions and views, overall posting frequency, recent activity, and activity status.
- Normalize and deduplicate equivalent profile inputs before processing.
- Pay for a Profile result only when a usable profile row is successfully returned.

### Quick start

1. Add one or more values to `profiles`.
2. Keep `includeRecentContent` enabled to return recent Posts/Reels.
3. Enable `includeEngagementInsights` if you want the optional paid analysis. It is disabled by default.
4. Click **Start**, then open the default Dataset from Output.

```json
{
  "profiles": ["instagram", "nasa"],
  "includeRecentContent": true,
  "includeEngagementInsights": false
}
```

The input is prefilled with `instagram`. A run accepts up to 200 unique profiles after normalization and de-duplication.

### Input

| Field | Type | Required | Default | Description |
|---|---|---:|---:|---|
| `profiles` | `string[]` | Yes | Prefill: `["instagram"]` | Usernames, `@handles`, profile URLs, or numeric Instagram user IDs. Maximum 200 unique profiles. |
| `includeRecentContent` | `boolean` | No | `true` | Include usable public Posts/Reels from one healthy response. Disable to omit raw recent content. |
| `includeEngagementInsights` | `boolean` | No | `false` | Calculate optional paid engagement and activity insights. Charged only when usable analysis is delivered. |

The switches are independent. You can enable Engagement Insights while disabling recent content: the Actor can collect an internal sample for analysis and returns `recentContent: []`. Disable both switches for metadata only.

Supported examples: `instagram`, `@instagram`, `https://www.instagram.com/instagram/`, and `25025320`.

Equivalent username forms are processed once. When known identity data proves that a username and numeric ID refer to the same account, they are also merged. Invalid values appear in `RUN_SUMMARY` and do not stop other valid profiles.

### Output

Each unique profile produces one Dataset row. Recent posts stay nested in `recentContent[]`; posts never become separate rows.

Rows can include identity, bio, images, follower/following/post counts, account flags, category, profile-published email/phone/website/WhatsApp details, and optional recent Posts/Reels. Profile-level engagement metrics, overall posting frequency and activity status are calculated only when Engagement Insights is enabled. Missing optional values are `null` or empty arrays rather than guesses.

Illustrative output with Engagement Insights enabled — values are examples, not a captured live result:

```json
{
  "success": true,
  "status": "success",
  "username": "example_creator",
  "followersCount": 128000,
  "accountType": "creator",
  "email": "hello@example.com",
  "engagementRate": 4.07,
  "engagementSampleSize": 1,
  "avgLikes": 5100,
  "avgComments": 115,
  "avgViews": null,
  "postingFrequencyPerWeek": null,
  "latestActivityAt": "2026-10-12T08:00:00.000Z",
  "daysSinceLastActivity": 1,
  "activityStatus": "occasional",
  "recentContent": [{
    "shortcode": "ABC123",
    "url": "https://www.instagram.com/p/ABC123/",
    "type": "photo",
    "timestamp": "2026-10-12T08:00:00.000Z",
    "likesCount": 5100,
    "commentsCount": 115
  }],
  "dataLevel": "full",
  "error": null,
  "scrapedAt": "2026-10-13T08:00:00.000Z"
}
```

#### Dataset views

| View | Focus |
|---|---|
| Profiles | Identity, audience size, account attributes, contact summary, optional engagement, completeness. |
| Contacts | Public email, phone, website, and WhatsApp details. |
| Engagement | Optional Profile-level Insights: rate, sample size, average interactions/views, overall frequency, latest activity and activity status. Metrics are empty when the add-on is disabled. |
| Recent Content | Nested recent-post samples with their owning profiles. |

Views change presentation only; they do not create additional rows.

#### Important fields

| Field | Meaning |
|---|---|
| `id`, `username`, `url` | Stable account identity and profile link. Large IDs remain strings. |
| `followersCount`, `followingCount`, `postsCount`, `reelsCount` | Public counts when available. |
| `accountType` | `personal`, `creator`, `business`, or `unknown`. |
| `email`, `phone`, `externalUrl`, `whatsapp` | Contact details published on the profile. External websites are not crawled. |
| `engagementRate`, `engagementSampleSize` | Optional Insights: engagement percentage and the number of posts with valid interaction counts used for the calculation. |
| `avgLikes`, `avgComments`, `avgViews` | Optional Insights: averages of known interactions and views across the whole profile sample. |
| `postingFrequencyPerWeek` | Overall weekly publishing estimate from all dated sample items. |
| `latestActivityAt`, `daysSinceLastActivity` | Latest activity across the complete sample and complete days since that activity. |
| `activityStatus` | Overall profile activity: `very_active`, `active`, `occasional`, `inactive`, or `unknown`. |
| `recentContent` | Usable public Posts/Reels from the first healthy response; the count varies. |
| `dataLevel` | `full`, `partial`, `basic`, or `failed`. |
| `success`, `status`, `error` | Row outcome and a stable public error when resolution fails. |
| `scrapedAt` | ISO 8601 collection time. |

Recent items can include identity, URL, media type, caption, timestamp, engagement counts, duration, media URLs, location, hashtags, mentions, and music metadata. Availability varies.

### Recent-post collection

When recent content is enabled, the Actor includes usable public Posts/Reels from the first healthy recent-content response. The exact count varies by profile and available public data and is commonly around 12 items. It may contain photos, carousels, videos, and Reels; recognized Reels are marked as `reel`.

Items are normalized, invalid items are removed, duplicates are merged, and usable items are ordered newest first. All usable items from that response are retained. The Actor does not paginate further just to reach a fixed target. The count is not user-configurable.

### Engagement Insights

**Profile-level engagement and activity analysis.** Engagement Insights turns a profile's available recent public content into profile-level performance metrics, including engagement rate, average interactions and views, posting frequency, recent activity, and overall activity status. It is an optional paid add-on and is disabled by default.

When enabled, it can return engagement rate, average likes/comments/views, overall posting frequency, latest activity, days since last activity, and overall activity status. Every usable sample item contributes to the profile analysis when its required data is available. This saves you from cleaning content data and building these calculations yourself before comparing creators, evaluating influencer activity, monitoring competitors, or feeding structured profile metrics into dashboards and AI workflows.

Analysis uses the same normalized sample collected during the profile lookup. It does not request extra pages to expand the sample. Exact metrics depend on the public data available: a missing engagement rate does not prevent other useful metrics from being delivered. Unknown counts stay unknown instead of becoming zero, and `engagementSampleSize` reflects the actual items used for the engagement calculation.

`postingFrequencyPerWeek` is estimated from the interval between the oldest and newest valid timestamps in the sample. It requires at least two dated items spanning one day. `latestActivityAt` always uses the newest timestamp across all formats. Activity is `unknown` without a valid timestamp and `inactive` after more than 30 days without activity; for more recent activity, an estimated 5+ items per week is `very_active`, 1+ is `active`, and a lower or unmeasurable frequency is `occasional`.

One additional Engagement Insights charge applies only when you enable the add-on and usable derived analysis is successfully delivered. Empty samples or unsuccessful calculations create no add-on fee. When disabled, derived fields keep empty placeholders (`null`, sample size `0`, activity status `unknown`) to preserve the Dataset structure.

### Status

| `dataLevel` | `status` | Meaning | Profile results charged |
|---|---|---|---:|
| `full` | `success` | Metadata and requested enrichments are usable. | 1 |
| `partial` | `partial_success` | Usable metadata, but requested fields, recent content, or Insights are unavailable/incomplete. | 1 |
| `basic` | `success` | Metadata-only mode succeeded with both enrichment switches off. | 1 |
| `failed` | `failed` | No usable profile metadata could be returned. | 0 |

The number of recent items does not, by itself, make a result partial. Disabling Engagement Insights does not lower the data level. An unsuccessful requested add-on leaves usable Profile metadata available and creates no Engagement Insights charge.

### Pricing

**Profile data from $1.60 per 1,000 successfully returned profiles**, depending on your Apify plan — as low as $0.0016 per profile. Get structured account data for creator research, prospect lists, and monitoring, with recent public Posts/Reels included when enabled and no separate per-post fee.

**Add Profile-level Engagement Insights from $0.60 per 1,000 profiles**, depending on your plan — as low as $0.0006 extra per profile. Turn the available content sample into engagement and activity metrics without building those calculations yourself. This add-on is disabled by default and charged only when usable analysis is successfully delivered.

#### What you pay for — and what you don't

- **Delivered Profile results:** one result charge per unique, usable profile in a run. A partial result with usable metadata still counts; unavailable optional fields do not make the Profile result free.
- **Recent content is included:** returned Posts/Reels do not create separate content charges or another Profile charge.
- **Duplicate protection:** recognized equivalent inputs are processed once per run. Retries do not create another result or Insights charge for the same profile.
- **No Profile result, no Profile fee:** invalid inputs, not-found profiles, and metadata failures without a usable profile create no Profile Result charge.
- **No usable Insights, no add-on fee:** leaving the add-on off, an empty sample, or an unsuccessful analysis creates no Engagement Insights charge. A usable Profile result is still charged normally.

An **Actor Start charge of $0.0005 applies once per run**, separately from result and Insights fees, including runs that return no usable profiles. Batch up to 200 unique profiles in one run to share that start charge across your list. Enable Engagement Insights only when you need the extra analysis.

The starting prices above reflect available plan discounts, not a rate available on every plan. See this Actor's **Pricing tab** for current plan-specific rates and full pricing details.

### API usage

#### JavaScript

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('lance_api/instagram-profile-scraper-api').call({
  profiles: ['instagram', 'nasa'], includeRecentContent: true, includeEngagementInsights: false,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

#### Python

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('lance_api/instagram-profile-scraper-api').call(run_input={
    'profiles': ['instagram', 'nasa'], 'includeRecentContent': True, 'includeEngagementInsights': False,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/lance_api~instagram-profile-scraper-api/runs?waitForFinish=120" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"profiles":["instagram","nasa"],"includeRecentContent":true,"includeEngagementInsights":false}'
```

### Use cases

- Build creator shortlists with audience size and published contacts, with optional engagement and activity Insights.
- Compare public competitor profiles and use optional Insights to evaluate their posting patterns in your spreadsheet or dashboard.
- Collect structured public business profile data for research and permitted outreach workflows.
- Monitor recent public posts through scheduled runs and repeated exports.
- Feed profile metadata and post text into your own analytics or AI pipeline.

The Actor supplies structured source data; it does not perform lead scoring, sentiment, outreach decisions, or business recommendations.

### Limitations and responsible use

- Results depend on public availability at run time. Private, deleted, restricted, or unavailable accounts may fail.
- Optional fields may be `null`; the recent-post sample can be short or empty.
- Recent content is a latest-post sample, not a complete archive; media URLs may expire.
- Instagram can change public field availability.

Use only public or otherwise permitted data. Follow applicable law, Instagram's terms, privacy and copyright obligations, and anti-spam rules.

### FAQ

**Are duplicate inputs charged twice?** No. Equivalent canonical profiles are processed once per run.

**Can I choose the number of posts?** No. Recent content commonly contains around 12 items, but the actual count varies. The Actor returns usable items from one healthy response without requesting extra pages to reach a target.

**Can I collect only Reels?** No. This Profile Actor uses the posts timeline. Use a dedicated Reels product for a Reels-only workflow.

**Are posts billed separately?** No. Recent Posts/Reels are included with the Profile Result when enabled. Engagement Insights is a separate optional paid analysis.

**Can I get Insights without raw recent posts?** Yes. Enable `includeEngagementInsights` and disable `includeRecentContent`. The Actor can analyze an internal sample while returning an empty `recentContent` array.

**What if Engagement Insights cannot be generated?** You pay no Engagement Insights fee. A usable Profile Result is still returned and charged normally.

**Is a failed profile charged?** No Profile Result charge is created without usable metadata. The Actor Start charge may still apply.

**Do I need Instagram login details?** No login or cookie input is exposed.

### Support

Open an issue on the Actor page or email `lanceapi2026@hotmail.com`. Include the Run ID, a non-sensitive input, visible status/error, and expected versus actual behavior. Never send tokens, cookies, sessions, passwords, API keys, proxy credentials, or authorization headers.

# Actor input Schema

## `profiles` (type: `array`):

Enter usernames (nasa), @usernames (@nasa), Instagram profile URLs (https://www.instagram.com/nasa/), or numeric Instagram user IDs (25025320). A batch can contain up to 200 unique profiles after normalization and de-duplication; repeated references are processed once.

## `includeRecentContent` (type: `boolean`):

Include usable public Posts/Reels from one healthy recent-content response, newest first. The exact count varies and is commonly around 12 items. Additional pages are not fetched just to reach a fixed target. Turn it off to omit raw recent content from the output.

## `includeEngagementInsights` (type: `boolean`):

Calculate Profile-level engagement and activity insights from available recent public content, including engagement rate, average likes/comments/views, overall posting frequency, latest activity, days since last activity, and overall activity status. This is a paid add-on, disabled by default and charged only when usable insights are delivered. If recent content is disabled, an internal sample can still be collected for analysis without returning the raw items.

## Actor input object example

```json
{
  "profiles": [
    "instagram"
  ],
  "includeRecentContent": true,
  "includeEngagementInsights": false
}
```

# Actor output Schema

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

One row per unique profile processed, including explicit failed rows when a profile could not be resolved.

## `datasetConsole` (type: `string`):

No description

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

Per-run totals in plain language: how many profiles were requested, processed, resolved and failed, how complete each row is, how much recent content and contact information was found, and which inputs were rejected.

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

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

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

```

## MCP server setup

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