# Instagram Posts & Reels Scraper – No Login Required (`coderx/instagram-posts-reels-scraper-no-login-required`) Actor

Scrape public Instagram posts or reels without login. Get JSON with captions, likes, comments, views & profile stats — fast, resumable, no cookies required.

- **URL**: https://apify.com/coderx/instagram-posts-reels-scraper-no-login-required.md
- **Developed by:** [CoderX](https://apify.com/coderx) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 result items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Posts & Reels Scraper

### 📌 Overview

The **Instagram Posts & Reels Scraper** is a simple tool for collecting a public Instagram profile plus their recent posts or reels — no login or cookies required. Just provide a username, choose posts or reels, say how many you want, and get back structured JSON.

### 🚀 Features

- Works without login or cookies ✅
- Scrapes **both** feed posts and reels — your choice per run
- Returns key profile details (name, followers/following, verification, etc.) alongside the scraped items
- Resume a previous run exactly where it left off, with no duplicates or gaps (paid)
- Clean, predictable JSON output every time

### 🔧 How It Works

1. Enter an Instagram username.
2. Choose `posts` or `reels`, and how many items you want.
3. Get the profile info, then each scraped item, streamed to the dataset as structured JSON while the run is still going.
4. *(Optional)* Pass the `cursor` from a previous run's output to continue exactly where it left off.

### 📥 Input Parameters

| Parameter | Type | Required | Description |
| --- | --- | --- | --- |
| `username` | String | Yes | The Instagram username to scrape. |
| `contentType` | String (`posts` or `reels`) | Yes | Whether to scrape feed posts or reels. Default: `reels`. |
| `quantity` | Integer | Yes | Minimum number of items to return. The actual count may be slightly higher than requested. Default: `24`. |
| `cursor` | String | No | Resume cursor from a previous run's output, to continue where it left off. |

#### Example Input

```json
{
  "username": "instagram",
  "contentType": "reels",
  "quantity": 24
}
```

### 🔐 Usage Limits

| Plan | Runs per day | Items per run | Resume cursor |
| --- | --- | --- | --- |
| FREE | 1 | Up to 12 | ❌ Not included |
| Paid | Unlimited ✅ | As requested ✅ | ✅ Included |

> Upgrade to a paid plan to remove the daily run limit, scrape more than 12 items per run, and get a resume cursor to continue exactly where you left off.

### 📤 Output Data

Items land in the dataset **one row at a time as they're scraped**, not as one big record at the end — so if a run is ever interrupted, everything already scraped (and, on a paid run, already charged) is still there. Each row has a `type` field telling you what it is:

| `type` | When it's pushed | What it contains |
| --- | --- | --- |
| `profile` | Once, right after your username resolves | Public profile details + what was requested |
| `item` | Once per post/reel, as each is scraped | One post or reel |
| `summary` | Once, at the end of the run | Totals, resume cursor, and any warning |
| `error` | Instead of the above, if the run couldn't proceed at all | A short, safe error message |

#### 🧑‍💼 `profile` Row

A deliberately small, relevant set of profile fields — not the full profile record — plus the run's own settings:

| Field | Description |
| --- | --- |
| `username` | Instagram handle |
| `fullName` | Profile display name |
| `profilePicUrl` | Profile picture URL |
| `followersCount` | Follower count |
| `followsCount` | Following count |
| `postsCount` | Total posts on the profile (not the number returned by this run) |
| `verified` | Whether the account is verified |
| `private` | Whether the account is private |
| `user_id` | Instagram numeric user ID |
| `content_type` | `posts` or `reels`, echoing your input |
| `requested_quantity` | What you asked for |
| `quantity_capped_to` | Present only if the free-tier cap reduced your requested quantity |

#### 🎬 `item` Rows

Each row is one post or reel, depending on `contentType`:

| Field | Description |
| --- | --- |
| `id` | Media ID |
| `media_type` | `1` = image, `2` = video/reel, `8` = carousel |
| `product_type` | e.g. `"clips"` for reels |
| `code` | Shortcode used in the post URL (`instagram.com/p/<code>/`) |
| `caption` | Caption text |
| `like_count` | Number of likes |
| `comments_count` | Number of comments |
| `timestamp` | When it was posted (Unix epoch seconds) |
| `play_count` / `ig_play_count` / `fb_play_count` | Play/view counts by source |
| `view_count` / `content_views_count` | Additional view metrics, when available |
| `impressions` | Best-available view estimate |
| `reach` | Reach, when available |
| `video_views` | View count for reels |
| `share_count` / `reshare_count` / `media_repost_count` | Share and repost counts |
| `share_count_disabled` / `like_and_view_counts_disabled` | Whether those counts are hidden by the creator |

#### 🔁 `summary` Row

| Field | Description |
| --- | --- |
| `returned_count` | Actual number of items returned |
| `next_cursor` | Resume cursor — pass back as `cursor` on your next run to continue (paid only) |
| `has_more` | Whether more content exists beyond what was returned |
| `warning` | Present only if scraping stopped early due to a temporary error, after some items were still collected |

***

#### 📦 Example Output

Three rows from a single run (an `item` row repeats once per scraped post/reel):

```json
{
  "type": "profile",
  "username": "instagram",
  "fullName": "Instagram",
  "followersCount": 686294115,
  "followsCount": 155,
  "postsCount": 7500,
  "verified": true,
  "private": false,
  "user_id": "25025320",
  "content_type": "reels",
  "requested_quantity": 24
}
```

```json
{
  "type": "item",
  "username": "instagram",
  "content_type": "reels",
  "id": "3958651149055237302",
  "media_type": 2,
  "product_type": "clips",
  "code": "DLxxxxxxxx",
  "caption": "New drop 🔥",
  "like_count": 45210,
  "comments_count": 812,
  "timestamp": 1771528094,
  "video_views": 1245000
}
```

```json
{
  "type": "summary",
  "username": "instagram",
  "user_id": "25025320",
  "content_type": "reels",
  "returned_count": 24,
  "next_cursor": null,
  "has_more": true
}
```

#### Example error output (private or nonexistent account)

```json
{
  "type": "error",
  "username": "someprivateaccount",
  "error": "Restricted Profile"
}
```

***

### ⚙️ Notes & Limitations

> ⚠️ **Free users** get 1 run per day, capped at 12 items per run. **Paid users** get unlimited runs, full requested quantities, and resumable pagination.

- Only works with **public profiles** — private or restricted accounts return an `error` row, not data.
- Nonexistent or unreachable profiles return `{"type": "error", "error": "Does not exist"}` instead of failing the run.
- Items are written to the dataset one by one as they're scraped, so an interrupted run still keeps everything scraped up to that point.
- Engagement numbers reflect what's publicly visible and may differ slightly from Instagram's own app in real time.

### 🧠 Use Cases

- Influencer and creator research
- Competitive content benchmarking
- Reels/posts performance analytics
- Building social media dashboards

### ❓ FAQ

**Do I need an Instagram login or cookies?**
No — this scraper only reads publicly visible data.

**Can it scrape private accounts?**
No. A private account returns `{"error": "Restricted Profile"}` instead of data.

**What happens if I request more items than the free plan allows?**
Your `quantity` is silently capped at 12; the `profile` row includes `quantity_capped_to` so you know it happened.

**How do I run it more than once a day?**
Upgrade to a paid plan — free accounts are limited to one run per day.

**How does the resume cursor work?**
A paid run's `summary` row includes a `next_cursor`. Pass that value back as the `cursor` input on your next run to continue exactly where the previous one left off — no duplicates, no gaps.

**Can I scrape posts and reels in the same run?**
Not in a single run — set `contentType` to `posts` or `reels` and run it twice if you need both.

### 💡 Keywords

Instagram scraper, Instagram posts scraper, Instagram reels scraper, scrape Instagram without login, Instagram public data extractor, Instagram engagement data, Instagram API alternative

***

#### ⚠️ Disclaimer

This tool should be used **responsibly**. It collects only **publicly available data** that is viewable without logging in — it does not access private accounts or bypass Instagram's authentication. Instagram's terms of service restrict certain scraping practices; the developer is not responsible for misuse.

***

🚀 **Scrape Instagram posts and reels — quickly, safely, and reliably.**

# Actor input Schema

## `username` (type: `string`):

The Instagram username to scrape posts or reels from.

## `contentType` (type: `string`):

Choose whether to scrape posts or reels.

## `quantity` (type: `integer`):

Maximum number of items to scrape. Defaults to 24.

## `cursor` (type: `string`):

Pagination cursor from a previous run. Paste the cursor value from the last dataset record to continue scraping from where you left off. Leave empty to start from the beginning.

## Actor input object example

```json
{
  "username": "bethfiit",
  "contentType": "reels",
  "quantity": 12
}
```

# Actor output Schema

## `results` (type: `string`):

The posts or reels scraped in this run, or an error message if the run failed.

# 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 = {
    "username": "bethfiit",
    "contentType": "reels",
    "quantity": 12
};

// Run the Actor and wait for it to finish
const run = await client.actor("coderx/instagram-posts-reels-scraper-no-login-required").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 = {
    "username": "bethfiit",
    "contentType": "reels",
    "quantity": 12,
}

# Run the Actor and wait for it to finish
run = client.actor("coderx/instagram-posts-reels-scraper-no-login-required").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 '{
  "username": "bethfiit",
  "contentType": "reels",
  "quantity": 12
}' |
apify call coderx/instagram-posts-reels-scraper-no-login-required --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,coderx/instagram-posts-reels-scraper-no-login-required"
        }
    }
}

```

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/0sbX1gk143QX0BTwJ/builds/gj4XWbwEODBchdl6w/openapi.json