# Instagram Reels Downloader (`agentx/instagram-reels-downloader`) Actor

Process one publicly accessible Instagram post or Reel for structured metadata, source-dependent comments, and an optional stored video file.

- **URL**: https://apify.com/agentx/instagram-reels-downloader.md
- **Developed by:** [AgentX](https://apify.com/agentx) (community)
- **Categories:** Videos, Social media, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/platform/actors/running/actors-in-store#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 Video Downloader processes one publicly accessible Instagram post or Reel, returns a consistent metadata record, and can optionally save the video file to the run’s Apify key-value store.

- One URL produces one reviewable 39-field Dataset item when processing succeeds.
- Metadata, engagement counters, comments, and media details stay nullable when Instagram does not expose them.
- Four modes cover metadata-only processing and low, medium, or high preferred download quality.
  **[Run one Instagram Reel](https://apify.com/agentx/instagram-video-downloader/59aU9vig8wglWOBe1/input)**

**[Use the Actor through the API](https://apify.com/agentx/instagram-video-downloader/api)**

Start with metadata mode and `max_comments: 0`. This is the smallest production check, but zero does not guarantee an empty `comments` array: Instagram or the extractor can still include comments in the metadata response.

### Why Choose This API

Instagram Video Downloader offers a deliberately small contract for one cited Instagram video. Submit a public post or Reel URL and receive normalized fields such as `id`, `thumbnail`, `title`, `description`, `published_at`, `author`, dimensions, engagement counters, comments, and processing provenance. That stable shape is easier to validate and integrate than passing an evolving extractor response directly to downstream systems.

The Actor separates metadata work from media delivery. Metadata mode does not intentionally download or store the video. Low, medium, and high modes request an available rendition, then place a successfully produced MP4 in the run’s key-value store and return its stored URL. The selected quality is a preference with fallbacks, not a promise that Instagram provides a particular resolution or codec.

Comments are source-dependent. A positive `max_comments` value asks for no more than that many formatted records. A zero value disables the explicit comment request, but the extractor may still return comments bundled with other metadata; a live zero-limit run returned 12. Always inspect the actual array length instead of treating zero as a guaranteed empty result.

This Actor is narrower than a profile, feed, hashtag, Story, carousel, discovery, or batch scraper. That boundary is useful when a workflow needs a defensible one-input-to-one-record operation, a single download artifact, or a small regression test before building a larger pipeline.

### Quick Start Guide

Use a public Instagram post or Reel that contains video. The following public Reel was reachable during the July 23, 2026 verification:

```json
{
  "video_url": "https://www.instagram.com/reel/DbGeVKoSJto/",
  "video_quality": "metadata",
  "max_comments": 0
}
```

Submit the input in Apify Console and wait for a terminal run status. Open the Dataset item and compare its `id`, title or description, author, thumbnail, and publication timestamp with the source. The verified example returned ID `DbGeVKoSJto`, platform `Instagram`, a 1080-by-1920 frame, and an empty `video` value in metadata mode.

Treat identity validation as part of success. A run can finish technically while an input redirects, becomes unavailable, or resolves to unexpected media. Counters also change over time, so compare the meaning and type of each field rather than expecting old numeric values to remain identical.

After metadata succeeds, test a positive comment limit separately. Request a download only when the use case requires a retained file and the content owner or applicable terms permit it. Each run accepts one URL; callers that process a list should start separate bounded runs and handle deduplication themselves.

### Input Parameters

| Parameter | Type | Required | Public constraint | Behavior |
|---|---|---:|---|---|
| `video_url` | string | Yes | One non-empty value | URL passed to the extractor; use a public Instagram post or Reel containing video. |
| `video_quality` | string | No | `high`, `medium`, `low`, `metadata` | Omitted input becomes `metadata`; download modes use resolution-aware fallbacks. |
| `max_comments` | integer | No | 0–10,000 in the public schema | Omitted input becomes 0; positive values limit formatted comments, while zero may still retain source-provided comments. |

Only `video_url` is required. Optional values are not prefilled, which preserves whether a caller explicitly selected them. Extra public input properties are rejected by the schema.

Low mode prefers formats at or below 480p, medium prefers formats at or below 720p, and high can consider formats up to 2160p. Each mode falls back when the preferred representation is unavailable. The result can therefore have a lower resolution than the selected ceiling.

The public schema caps `max_comments` at 10,000. This is an API input constraint, not evidence that Instagram will return 10,000 comments. Availability, ordering, visibility, moderation, rate limits, and extractor support all affect the returned sample. There is no credential, cookie, proxy, username, date, country, language, profile, playlist, or batch input.

### Output Data Schema

Every successful Dataset row follows the same 26-key top-level contract in runtime order:

| Area | Fields |
|---|---|
| Provenance | `processor`, `processed_at` |
| Identity | `id`, `thumbnail`, `platform`, `title`, `description`, `duration`, `published_at` |
| Author | `author`, `author_id`, `author_url` |
| Classification | `categories`, `tags` |
| Engagement | `view_count`, `like_count`, `shares_count`, `dislike_count`, `comment_count` |
| Media | `width`, `height`, `fps`, `audio_title`, `audio_artist`, `comments`, `video` |

An abbreviated verified shape is:

```json
{
  "processor": "https://apify.com/agentx/instagram-video-downloader",
  "processed_at": "2026-07-23T19:11:53+00:00",
  "id": "DbGeVKoSJto",
  "platform": "Instagram",
  "title": "Video by instagram",
  "author": "Instagram",
  "width": 1080,
  "height": 1920,
  "comments": [
    {
      "author": "example_viewer",
      "text": "Example comment",
      "like_count": 0,
      "published_at": "2026-07-23T19:06:14+00:00"
    }
  ],
  "video": ""
}
```

The example shortens text and replaces the real commenter identity. It illustrates field names and types, not a fixed response. The metadata check returned `categories` and `tags` as empty arrays; `view_count`, share and dislike counts, FPS, audio fields, and author URL were null. Null means unavailable, not zero. `comment_count` is the source’s aggregate counter, whereas `comments` contains the source-dependent records included in this run.

In metadata mode, `video` is an empty string. In download mode, it should become the Apify storage URL only after an MP4 is produced and stored. Temporary Instagram thumbnail or media URLs can expire and should not be treated as permanent source assets.

Source-dependent fields also present in every item:

| Field | Meaning |
|---|---|
| `source_url` | Canonical page URL of the item on its own platform |
| `media_type` | Kind of media the source reports, such as video or audio |
| `live_status` | Whether the item is a recording, currently live, or a finished stream |
| `availability` | Source visibility, such as public, unlisted, or needs\_auth |
| `age_limit` | Minimum viewer age the source enforces; zero means no restriction |
| `language` | Primary language of the item as reported by the source |
| `followers` | Follower or subscriber count of the author at processing time |
| `is_verified` | Whether the author's account carries a verified badge |
| `saves_count` | Times viewers saved the item, on sources that expose it |
| `file_ext` | Container extension of the selected media, such as mp4 or webm |
| `file_size` | Size of the selected media in bytes, exact or approximate |
| `subtitles` | Language codes of published subtitle tracks; auto-captions excluded |
| `chapters` | Chapter markers with title and start and end time in seconds |

### Integration Examples

The public Actor name is `agentx/instagram-video-downloader`; its stable Actor ID is `59aU9vig8wglWOBe1`. Start the same bounded metadata scenario through HTTP:

```bash
curl -X POST "https://api.apify.com/v2/acts/agentx~instagram-video-downloader/runs?token=$APIFY_TOKEN&timeout=180" \
 -H "Content-Type: application/json" \
 -d '{"video_url":"https://www.instagram.com/reel/DbGeVKoSJto/","video_quality":"metadata","max_comments":0}'
```

Poll the returned run ID, then read the default Dataset. Keep tokens in environment variables or a secrets manager; never put them in Actor input, source control, screenshots, or support messages.

For a hosted MCP client, configure the Actor and pass the same arguments:

```json
{
  "mcpServers": {
    "apify-instagram-video": {
      "url": "https://mcp.apify.com?tools=agentx/instagram-video-downloader",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  },
  "exampleToolArguments": {
    "video_url": "https://www.instagram.com/reel/DbGeVKoSJto/",
    "video_quality": "metadata",
    "max_comments": 0
  }
}
```

Follow the [Apify MCP documentation](https://docs.apify.com/integrations/mcp) for client-specific setup. The July 23 MCP baseline run `hVYNBdXWkigil1431` succeeded in 14.1 seconds with one Dataset item, one `INPUT` key-value record, and about 71 MB peak memory. That observation verifies one bounded scenario, not every future Instagram response.

### Pricing & Cost Calculator

The callable Actor’s hosted pricing record exposes pay-per-event pricing:

| Event | Billing unit | Public price |
|---|---|---:|
| `actor_usage` | Metered runtime, proxy, and storage event | $0.00001 |
| `metadata` | One successfully processed metadata result without a stored video | $0.08 |
| `download` | One successfully processed result with video download and storage | $0.20 |

A successful metadata-only item is billed through the metadata path plus applicable metered platform usage. A successful download item uses the download path instead of the metadata event. Failed access attempts may still consume platform resources even when no result event is produced.

For planning, 10 successful metadata items across 10 runs correspond to $0.80 in metadata events before metered usage. Ten successful downloads correspond to $2.00 in download events before metered usage. Each run processes one URL, so multiply the relevant event by the expected number of successful runs. Use Apify spending limits and bounded test inputs; do not rely on a charge cap as a work limit.

### Use Cases & Applications

Content operations teams can preserve authorized Reel metadata and, when required, the source file for an internal review record. Researchers can capture a timestamped public snapshot containing the author, caption, dimensions, thumbnail, and available engagement values for one cited post. Developers can feed the normalized row into a webhook, catalog, moderation queue, or asset-management workflow.

AI teams can pass an authorized stored video to a separate transcription, caption, classification, or scene-analysis service. Media teams can use metadata mode first to validate identity and cost before requesting the file. Quality preferences help control file size, but the caller must inspect the returned dimensions and storage object rather than assuming the label was fulfilled exactly.

Small comment samples can support documented qualitative review when the source exposes them and the use is lawful. This Actor does not promise complete threads, reply trees, stable order, deleted comments, or historical coverage. Repeated metadata runs can observe current public counters, but the Actor does not calculate deltas, deduplicate records, or explain why a counter changed.

### FAQ

#### Can it download an entire Instagram profile?

No. It accepts one post or Reel URL and produces at most one Dataset record per run.

#### Does `max_comments: 0` guarantee no comments?

No. It disables the explicit positive comment request, but source-provided comments may still be present. Inspect the returned array and discard it downstream if your workflow must not retain comments.

#### Why did no item appear?

Open the exact URL in a private browser, confirm it is public and contains video, remove tracking fragments, and retry metadata mode with zero comments. Private, deleted, region-restricted, age-gated, login-only, or temporarily blocked content can fail.

#### Why is `video` empty?

That is expected in metadata mode. In download mode, an empty value means no video file was successfully produced or stored; inspect the run log and key-value store, then retest metadata to separate source access from media transfer.

#### Does high mode guarantee 4K?

No. It is an upper-bound preference with fallbacks. Instagram decides which renditions exist.

#### Why are counters or audio fields null?

The source or extractor did not expose them for that response. Null is not a measured zero.

#### Can it access private accounts, Stories, or sign-in-only media?

No authentication or Story input is exposed. Do not use the Actor to bypass access controls.

#### Can I schedule it?

Yes. Each scheduled run reprocesses the configured URL, and availability or counters may change. Store timestamps and deduplicate externally.

#### How do Reel, post, and IGTV URLs differ in practice?

All three resolve through the same single-item contract, but the fields Instagram publishes vary. A Reel usually carries audio track attribution, while an older feed post often leaves `audio_title` and `audio_artist` null. Submit the canonical `/reel/<code>/` or `/p/<code>/` permalink rather than a profile or story address, because those have no single media target.

#### Trust & Certifications

The same audit compared runtime key order with the Dataset schema, checked input defaults and enum values, and reviewed every public billing event. The baseline returned the intended Reel and exactly 26 top-level fields.

This page does not claim an external security, privacy, quality, or compliance certification. Apify provides the hosting, storage, API, and run controls described in its own documentation; users remain responsible for evaluating whether those controls meet their requirements. Live proof is scenario-specific because Instagram responses and extractor behavior can change.

For reproducibility, retain the run ID, redacted input, build version, Dataset item count, and expected field list. Recheck identity and nullability after dependency or platform changes rather than treating an old successful run as permanent evidence.

#### Legal & Compliance

Process only content you are authorized to access, download, analyze, and retain. Public visibility does not automatically grant permission to copy, redistribute, train on, or commercially reuse media or comments. Users are responsible for the [Instagram Terms of Use](https://help.instagram.com/581066165581870), the [Instagram Privacy Policy](https://privacycenter.instagram.com/policy/), copyright, privacy, applicable law, and internal retention rules.

Do not use this Actor to bypass access controls, evade platform safeguards, build undeclared personal profiles, or claim complete audience coverage. Minimize collected data, protect retained media and comments, and delete records when the stated purpose or lawful retention period ends. If a person requests removal under an applicable process, keep enough provenance to locate the relevant run without exposing unrelated data.

### Related Tools

- [Instagram Reel Scraper](https://apify.com/agentx/instagram-reel-scraper) extracts broader post and Reel records with media-part and engagement detail.
- [Video Transcript](https://apify.com/agentx/video-transcript) converts speech from authorized media into text.
- [Video Captions Downloader](https://apify.com/agentx/video-captions-downloader) retrieves caption tracks when a supported source exposes them.
- [All Video Scraper](https://apify.com/agentx/all-video-scraper) provides a multi-platform video entry point.

### Support & Community

Instagram availability, counts, comments, and temporary media URLs can change after that date.

- [AgentX community](https://t.me/Apify_Actor)
- [Contact the AgentX team](https://t.me/AiAgentApi)
- [Actor input in Apify Console](https://apify.com/agentx/instagram-video-downloader/59aU9vig8wglWOBe1/input)
- [Apify API reference](https://apify.com/agentx/instagram-video-downloader/api)
- [Apify MCP documentation](https://docs.apify.com/integrations/mcp)

For support, include the Actor link, stable Actor ID, run ID, build number, redacted input, expected outcome, actual terminal status, and Dataset item count. Do not send API tokens, private URLs, cookies, or personal data.

**[Run one Instagram Reel](https://apify.com/agentx/instagram-video-downloader/59aU9vig8wglWOBe1/input)**

**[Use the Actor through the API](https://apify.com/agentx/instagram-video-downloader/api)**

# Actor input Schema

## `video_url` (type: `string`):

Publicly accessible Instagram post or Reel URL containing video.

## `video_quality` (type: `string`):

Preferred download quality, or metadata-only mode without a video file.

## `max_comments` (type: `integer`):

Maximum comments to request explicitly. Source-provided comments may still appear when set to 0.

## Actor input object example

```json
{
  "video_url": "https://www.instagram.com/reel/DbGeVKoSJto/",
  "max_comments": 4
}
```

# Actor output Schema

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

All video details and optional download links with full engagement stats and comments

# 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 = {
    "video_url": "https://www.instagram.com/reel/DbGeVKoSJto/",
    "max_comments": 4
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentx/instagram-reels-downloader").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 = {
    "video_url": "https://www.instagram.com/reel/DbGeVKoSJto/",
    "max_comments": 4,
}

# Run the Actor and wait for it to finish
run = client.actor("agentx/instagram-reels-downloader").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 '{
  "video_url": "https://www.instagram.com/reel/DbGeVKoSJto/",
  "max_comments": 4
}' |
apify call agentx/instagram-reels-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/59aU9vig8wglWOBe1/builds/jrBNvfuXEtKn8mK5r/openapi.json