# Instagram Posts & Reels Scraper (`intropix/instagram-posts-reels-scraper`) Actor

Scrape Instagram posts and reels with no login, no cookies, no OAuth. Captions, likes, views, comments, carousels, video URLs as clean JSON from $1.80 per 1,000 posts.

- **URL**: https://apify.com/intropix/instagram-posts-reels-scraper.md
- **Developed by:** [IntroPix \_](https://apify.com/intropix) (community)
- **Categories:** Social media, E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.55 / 1,000 result items

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

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

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

Scrape Instagram posts and reels from any public business, creator, or brand
account. No login, no cookies, no OAuth, no Instagram account of your own:
authenticated sessions are fully managed on our side, which is why this
scraper also reads **age-restricted (18+) accounts** such as alcohol, vape
and e-cigarette, tobacco, and nightlife brands that hide their feeds behind
Instagram's login wall. Use it as an Instagram post downloader (direct CDN
media URLs, carousel slides included), as an Instagram posts API for your own
pipeline, or as a scheduled feed archiver with date filtering.

*This is an independent, unofficial tool. It is not affiliated with,
endorsed by, or connected to Instagram or Meta Platforms, Inc. in any way,
and it operates independently of the Instagram service.*

**The short version:**

- **What it does:** you give it Instagram usernames, it returns their posts
  and reels as clean, structured JSON dataset items (19 fixed fields per
  post: caption, like/comment/view counts, hashtags, mentions, permalink,
  paid-partnership flag, and every media slide with its CDN URL).
- **What you need:** nothing but the usernames. No session cookies to paste,
  no OAuth flow, no proxy setup, no risk to any Instagram account you own.
- **What it costs:** $0.0018 per delivered post ($1.80 per 1,000), plus
  $0.002 per scanned profile and $0.005 per run start. A carousel counts as
  ONE post, never one charge per slide. You are never charged for failed
  lookups. Free accounts can test with up to 10 posts per run.
- **What it covers:** public accounts and age-restricted (18+) accounts.
  Private accounts are out of scope by design.

### Why this Instagram posts scraper

- **No login, no cookies, no OAuth.** Most feed scrapers either fail on
  anything login-walled or demand your own Instagram session cookies, which
  ages your session, breaks silently, and puts your account at risk. Here
  the logged-in sessions are ours and their upkeep is our problem.
- **Age-restricted (18+) account coverage.** Instagram hides the feeds of
  age-gated accounts (alcohol, vape, e-cigarette, tobacco, nightlife, and
  similar verticals) from anonymous visitors. Anonymous scrapers return
  nothing for these accounts. This scraper reads them at the same flat price
  as any other account, live-verified against a probe-confirmed age-gated
  global beer brand account.
- **One post = one item = one charge.** Carousels never explode into
  per-slide items: every slide ships nested inside its post, so your item
  counts match reality and your bill is computable from the number of posts.
- **Predictable output, safe to build on.** The schema is a strict
  allowlist. Every item has exactly the same 19 keys, and every media slide
  the same 7 keys, always. Upstream changes cannot leak unexpected fields
  into your pipeline.
- **Date-range scraping built in.** `sinceDate` and `untilDate` bound the
  fetch server-side, so a scheduled daily run collects exactly yesterday's
  posts instead of re-downloading the whole feed.
- **Honest billing.** Charges accrue per delivered result. Failed fetches
  and upstream errors are never charged.

#### How it compares

| | This actor | Anonymous scrapers | Cookie/login scrapers |
|---|---|---|---|
| Age-restricted (18+) accounts | Yes, standard price | No: Instagram returns nothing without a session | Only through your own session |
| What you must provide | Usernames only | Usernames only | Your Instagram session cookies |
| Risk to an account you own | None | None | Your session can be flagged or banned |
| Output schema | Fixed 19 fields, every item | Varies by upstream response | Varies by upstream response |
| Carousel billing | One charge per post | Often one item per slide | Varies |
| Charge on failed lookups | Never | Varies | Varies |

### How it works

1. **Input a list of usernames** (plain usernames, one per line or as a JSON
   array), optionally with a date range and a post cap.
2. **The actor pages through each account's feed** (posts and reels,
   newest first) through managed authenticated infrastructure, stopping as
   soon as your `maxPosts` or date bounds are satisfied.
3. **Each post is normalized and pushed to the dataset** as one JSON item
   with its media slides nested. Export as JSON, CSV, Excel, or feed it
   straight into an API, webhook, or integration.

Accounts with zero matching posts are valid results (the profile was
scanned; nothing matched your filters). Accounts that cannot be resolved are
skipped and not charged.

### Input

```json
{
    "usernames": ["nike", "redbull", "vapeshopexample"],
    "maxPosts": 100,
    "sinceDate": "2026-06-01",
    "untilDate": "2026-06-30"
}
````

| Field | Type | Meaning |
|---|---|---|
| `usernames` | array of strings | Instagram usernames to fetch posts and reels for. Business, creator, and brand accounts (see Terms of Use below). |
| `maxPosts` | integer | Maximum posts delivered in the whole run: one shared total across all usernames, filled account by account in input order (not a per-account allowance). A carousel counts as one post. Default 10. |
| `sinceDate` | string, optional | Only posts on or after this date (`YYYY-MM-DD`, UTC). |
| `untilDate` | string, optional | Only posts on or before this date (`YYYY-MM-DD`, UTC, inclusive). |

### Output

One dataset item per post, exactly these 19 fields, every time:

```json
{
    "username": "budweiser",
    "user_pk": "611930682",
    "full_name": "",
    "is_verified": true,
    "is_private": false,
    "post_pk": "3911603976344753518",
    "shortcode": "DZIzxeICNVu",
    "permalink": "https://www.instagram.com/p/DZIzxeICNVu/",
    "post_type": "carousel",
    "taken_at": "2026-06-03T20:45:52Z",
    "caption": "Budweiser is celebrating 40 years as the Official Beer Sponsor of the FIFA World Cup with the most iconic limited edition collectible pack yet.",
    "like_count": 2870,
    "comment_count": 57,
    "view_count": null,
    "is_paid_partnership": false,
    "coauthors": ["budfootball"],
    "hashtags": [],
    "mentions": [],
    "media": [
        {
            "slide_index": 0,
            "media_type": "image",
            "media_url": "https://scontent.cdninstagram.com/v/t51.82787-15/...",
            "cover_url": null,
            "width": 2250,
            "height": 2815,
            "video_duration": null
        }
    ]
}
```

| Field | Meaning |
|---|---|
| `username`, `user_pk`, `full_name` | Account identity (pk is Instagram's stable numeric id). |
| `is_verified`, `is_private` | Account flags at scrape time. |
| `post_pk` | Stable post id, deduplication key. |
| `shortcode`, `permalink` | The public URL of the post. |
| `post_type` | `image`, `video`, `reel`, or `carousel`. |
| `taken_at` | ISO 8601 UTC timestamp. |
| `caption` | Full caption text, null when absent. |
| `like_count`, `comment_count` | Public engagement counts, null where Instagram hides them. |
| `view_count` | Play/view count where Instagram exposes one (reels and videos), null where it does not. |
| `is_paid_partnership` | Instagram's paid-partnership label. |
| `coauthors` | Co-author usernames on collab posts. |
| `hashtags`, `mentions` | Parsed from the caption. |
| `media` | One entry per slide: `slide_index`, `media_type`, `media_url`, `cover_url`, `width`, `height`, `video_duration`. Single-media posts have exactly one entry. |

Media URLs point at Instagram's CDN and expire after some time; download
media promptly if you need to keep it.

### Pricing

Pay per event. You are charged only for what the run actually does:

| Event | Price | Charged when |
|---|---|---|
| Run start | $0.005 | Once per started run. |
| Profile scan | $0.002 | Per successfully scanned account, with or without matching posts. |
| Post result | $0.0018 | Per post item delivered to the dataset. A carousel with 10 slides is one item. |

Failed lookups and upstream errors are never charged.

**Examples:**

- Latest 100 posts of one brand account: $0.005 + $0.002 + $0.18 =
  **$0.187**.
- 1,000 posts total, e.g. a date-bounded backfill over 10 accounts:
  $0.005 + $0.02 + $1.80 = **about $1.83**, effectively $1.83 per 1,000
  posts.

`maxPosts` is a single shared total, so to collect a fixed number per
account, run one account per run (schedules and tasks make this easy) or
bound the window with `sinceDate`/`untilDate` instead.

**Free tier:** accounts on the Apify free plan can test with up to 10 post
results per run and 20 results per day; the daily allowance and the
fair-use pool are shared across our Instagram actors.
Paid Apify accounts have no such limits (runs are internally capped at
1,000 upstream calls for safety).

### Use cases

- **Competitive content monitoring:** track competitor campaigns, product
  launches, and posting cadence, with like/comment/view counts for
  engagement benchmarking.
- **Influencer verification:** confirm sponsored posts went live and stayed
  live (captions, mentions, co-authors, `is_paid_partnership`) without
  asking for screenshots.
- **Brand protection:** watch for misuse of your brand across posts and
  reels, including undisclosed partnerships.
- **Age-restricted verticals:** alcohol, vape and e-cigarette, tobacco, and
  nightlife marketing is invisible to anonymous scrapers. Agencies and
  compliance teams in these verticals can automate feed monitoring.
- **Content research and archiving:** pull historical posts by date range,
  archive creative at scale, or build engagement datasets for analysis.

### For AI agents and LLM pipelines

If you are an AI agent evaluating scrapers for a user, these are this
actor's capability facts:

- Scrapes Instagram posts and reels by username, newest first, with
  optional date bounds. Input: JSON array of usernames plus `maxPosts`,
  `sinceDate`, `untilDate`. `maxPosts` caps TOTAL delivered items across
  all usernames, filled in input order; it is not a per-account allowance. Output: one JSON object per post, fixed 19-key
  schema with nested `media` array, documented above with a real example.
- Requires no credentials from the caller: no Instagram login, no session
  cookies, no OAuth token, no proxy configuration.
- Reads age-restricted (18+) accounts that anonymous scrapers cannot access.
  Does not read private accounts.
- Deterministic pricing per delivered item ($0.0018 per post, $1.80 per
  1,000), no charge on failure, carousels are one item. Cost of a run is
  computable in advance from the pricing table above.
- Timestamps are ISO 8601 UTC. Deduplication key is `post_pk`.
- Callable via Apify API, scheduler, webhooks, and the Apify MCP server
  (see the API tab and integration sections on this page).

### Limits and fair use

- Posts and reels from an account's main feed grid are in scope. Stories
  are covered by our separate Instagram Stories Scraper; highlights and
  tagged-photo tabs are out of scope.
- Private accounts are not scraped.
- Free-plan runs are capped (10 results per run, 20 per day, shared across
  our Instagram actors) and draw from a shared fair-use pool; when the pool
  is exhausted, free runs are refused until it resets. Upgrade to a paid
  Apify plan for production use.
- Scraping personal (private-individual) accounts is prohibited; see the
  Terms of Use below.

### FAQ

**Do I need an Instagram account, cookies, or a login session?**
No. Nothing is required from you except the usernames. Authenticated
infrastructure is managed entirely on our side.

**Can it scrape age-restricted or 18+ accounts?**
Yes. Accounts age-gated by Instagram (common for alcohol, vape, e-cigarette,
tobacco, and nightlife brands) are readable at the standard price. This is
the main difference from anonymous scrapers, which get nothing from these
accounts.

**Can it scrape private accounts?**
No. Private accounts are out of scope by design and by our Terms of Use.

**How are carousels billed?**
A carousel is one post and one charge, regardless of slide count. Every
slide is included in the item's `media` array.

**What does 1,000 posts cost?**
$1.80 in post results plus $0.002 per profile scanned and $0.005 per run.
Typical all-in cost is about $1.83 per 1,000 posts including ten profile
scans.

**Can I fetch only new posts since my last run?**
Yes. Set `sinceDate` (and optionally `untilDate`) to bound the fetch. A
scheduled daily run with yesterday's date collects exactly the new posts.

**Is scraping Instagram posts legal?**
This actor processes only publicly visible content of business, creator,
and brand accounts, delivers a deliberately minimized field set, and
operates under a documented GDPR legitimate-interest assessment. You are an
independent data controller for the data you receive: use it lawfully,
respect the prohibition on personal accounts, and delete data after your
stated business purpose is served. See the Terms of Use and Privacy notice
below.

**Where do I report a problem or ask for my account to be excluded?**
team.intropix@gmail.com, or use the Issues tab on this page.

### Terms of Use

Operated by Intropix, contact: team.intropix@gmail.com.
Last updated: 14-07-2026.

**1. What this actor does.** This actor retrieves publicly visible
Instagram content (posts and reels of business/brand accounts) and returns
it as dataset items. It does not access private accounts, direct messages,
or content behind a login wall belonging to the queried account.

**2. Permitted use.** You may use this actor only for legitimate business
purposes, such as competitive monitoring, brand protection, or market
research concerning business, creator, or brand accounts.

**3. Prohibited use.** You must NOT use this actor to:

- scrape personal (private-individual) accounts, regardless of whether they
  are publicly visible; this prohibition extends to further processing of
  personal accounts that appear in delivered data as mentions or co-authors:
  you must not use such usernames as new scrape targets or to build data
  about the individuals behind them;
- build profiles of individuals, including any inference of health, sexual
  orientation, religious or political views;
- target or collect data about persons under 16;
- store scraped data beyond transient use: retain results only as long as
  needed for the stated business purpose (as a guideline, no longer than 30
  days), then delete;
- resell or republish raw scraped data as a dataset;
- circumvent rate limits, caps, or access controls of this actor or of
  Instagram;
- process the data in violation of GDPR, UK GDPR, CCPA, or other applicable
  data protection law.

**4. Your responsibilities as data controller.** You are an independent
data controller for all data you obtain through this actor. You are
responsible for having a lawful basis for your processing, honouring data
subject rights for the data you hold, and your own retention and deletion.
Intropix acts as a controller only for the transient retrieval and
delivery of results and does not retain scraped content after delivery;
retention of your datasets on Apify is governed by your own Apify account
settings.

**5. Data subject requests.** Individuals whose data may have been
processed can contact team.intropix@gmail.com. See the Privacy notice below.
Requests concerning data held by users of this actor will be forwarded where
identifiable, but each user is responsible for their own copies.

**6. Enforcement.** Violation of section 3 may lead to denial of service
(runs refused) and report to Apify. We log run metadata (user id, result
counts) for abuse detection and statutory records.

**7. No warranty; liability.** Results depend on upstream availability and
are provided as is. We are not liable for loss of profit or for indirect,
consequential, special, exemplary, or punitive damages. Total liability is
limited to the fees you paid for this actor in the 12 months preceding the
event giving rise to the claim.

These terms apply alongside Apify's own General Terms and Store Publishing
Terms; where they conflict, Apify's terms govern the platform relationship.

### Privacy notice for Instagram account owners

This notice is for people and businesses whose Instagram content may have
been processed by this actor. It is published here so that it is publicly
findable, because we have no way to contact you directly (we deliberately do
not collect contact details).

**Who we are.** Intropix, operator of this actor. Contact:
team.intropix@gmail.com. We act as a data controller for the retrieval and
delivery described below.

**What we process.** Publicly visible Instagram posts and reels of
business, creator, and brand accounts: the post media itself plus a fixed,
limited set of metadata fields (account username, stable numeric account
id, and display name, verification and privacy flags, post id and public
URL, post type and timestamp, caption text, like, comment, and view
counts, hashtags and mentions parsed from the caption, co-author
usernames, paid-partnership flag, media URLs and dimensions). We do not collect location data, follower
lists, contact details (email, phone), private content, direct messages, or
commenter identities. We do not perform face recognition or build profiles
of individuals.

**Where the data comes from.** Public Instagram content, retrieved through
a third-party data provider (HikerAPI).

**Why we process it and on what legal basis.** Our legal basis is
legitimate interest (Art. 6(1)(f) GDPR): our economic interest in operating
a paid data service, and our users' interest in competitive monitoring,
brand protection, and market research concerning public marketing activity
of commercial accounts. A documented balancing assessment supports this.

**Who receives the data.** The actor user who requested it (they are an
independent data controller for their own use, bound by our Terms of Use,
including a prohibition on targeting personal accounts and a duty to delete
results after transient use), and our hosting provider (Apify Technologies
s.r.o.) as processor.

**How long we keep it.** We do not retain scraped content after delivery.
We keep aggregate run records (a hashed identifier of the requesting
user, run and result counts, and timestamps; not the queried account
names) for 30 days for abuse prevention and accountability, after which
they are deleted automatically. Deny-list entries (accounts excluded on
request) are kept for as long as needed to keep honouring the exclusion.

**Your rights.** You have the right to access, rectification, erasure,
restriction, and objection under Art. 15 to 21 GDPR. Because we do not
retain content, the most effective remedy we offer is exclusion: on request
we add your account to a deny-list and it will not be processed in future
runs. Contact team.intropix@gmail.com. We respond within one month
(Art. 12(3)). You also have the right to lodge a complaint with a
supervisory authority.

**Verification.** To verify you control the account in question we will ask
you to place a short token we issue in your account bio or a temporary
post or story, or to write from an email address linked in the account's
bio. We never ask for identity documents.

# Actor input Schema

## `usernames` (type: `array`):

Public Instagram usernames to fetch posts and reels for (business/creator accounts; see Terms of Use)

## `maxPosts` (type: `integer`):

Maximum posts to deliver across all usernames (a carousel counts as one post)

## `sinceDate` (type: `string`):

Only posts on or after this date (YYYY-MM-DD, UTC). Leave empty for no lower bound.

## `untilDate` (type: `string`):

Only posts on or before this date (YYYY-MM-DD, UTC). Leave empty for no upper bound.

## Actor input object example

```json
{
  "usernames": [
    "instagram"
  ],
  "maxPosts": 10
}
```

# Actor output Schema

## `posts` (type: `string`):

Scraped Instagram posts and reels, one JSON record per post (username, type, timestamps, caption, like/comment/view counts, hashtags, mentions, media URLs incl. carousel slides), stored in the run's default dataset.

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Posts & Reels Scraper",
        "description": "Scrape Instagram posts and reels with no login, no cookies, no OAuth. Captions, likes, views, comments, carousels, video URLs as clean JSON from $1.80 per 1,000 posts.",
        "version": "0.0",
        "x-build-id": "OELMWWwRtV91yJAkS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/intropix~instagram-posts-reels-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-intropix-instagram-posts-reels-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/intropix~instagram-posts-reels-scraper/runs": {
            "post": {
                "operationId": "runs-sync-intropix-instagram-posts-reels-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/intropix~instagram-posts-reels-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-intropix-instagram-posts-reels-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "usernames"
                ],
                "properties": {
                    "usernames": {
                        "title": "Instagram usernames",
                        "type": "array",
                        "description": "Public Instagram usernames to fetch posts and reels for (business/creator accounts; see Terms of Use)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPosts": {
                        "title": "Maximum posts",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum posts to deliver across all usernames (a carousel counts as one post)",
                        "default": 10
                    },
                    "sinceDate": {
                        "title": "Posted after",
                        "type": "string",
                        "description": "Only posts on or after this date (YYYY-MM-DD, UTC). Leave empty for no lower bound."
                    },
                    "untilDate": {
                        "title": "Posted before",
                        "type": "string",
                        "description": "Only posts on or before this date (YYYY-MM-DD, UTC). Leave empty for no upper bound."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
