# Instagram Video Downloader API (`lance_api/instagram-video-downloader-api`) Actor

Download public Instagram video, audio, images, carousel media, and post metadata.

- **URL**: https://apify.com/lance\_api/instagram-video-downloader-api.md
- **Developed by:** [LanceAPI](https://apify.com/lance_api) (community)
- **Categories:** Social media, AI, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 media results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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

**Paste an Instagram link. Get the media URL and post data your app can use.**

Instagram Video Downloader API turns public Reels and posts into download-ready **video, audio, image, cover, and carousel URLs**—plus the caption, creator, duration, publish date, and available engagement numbers. No browser automation to build. No page HTML to maintain. Just send URLs and get structured JSON back.

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

#### The quick version

- **You send:** public Instagram Reel or post URLs.
- **You get:** direct media links and clean post metadata in JSON.
- **You pay for:** successful unique results only—never failed URLs or duplicates.
- **Price per 1,000 results:** **Free $2.50 · Starter $2.00 · Scale $1.50 · Business $1.00**.
- **Batch size:** 5 unique URLs on Free runs and up to 100 on paid runs.
- **One thing to know:** Instagram CDN links expire, so download or copy the files soon after the run.

### What you get

- **The best available media link** for video, audio, image, cover, or carousel content.
- **The post context your workflow needs:** caption, creator, publish time, duration, and available engagement metrics.
- **Cleaner batch jobs:** tracking parameters are removed, duplicate posts run once, and one bad URL does not stop the rest.
- **Predictable JSON:** consistent result objects and fixed engagement keys make integrations easier to maintain.
- **Easy automation:** call it from the Apify Console, REST API, JavaScript, Python, schedules, webhooks, or an AI agent.

The Actor returns URLs, not hosted copies of the files. If you need permanent storage, download the media into your own bucket or asset library right after the run.

### Try it in under a minute

1. Click **Try for free** or **Start**.
2. Paste one or more public Instagram Reel or post URLs.
3. Click **Start**.
4. Open **Dataset** and use the link in `media.videoUrl`, `media.audioUrl`, `media.imageUrl`, or `media.items`.

Most public posts need nothing else. If Instagram puts a public post behind a login check, you can optionally provide your own session ID for that run.

Example input:

```json
{
  "urls": [
    "https://www.instagram.com/p/DbbQB9tCgeO/"
  ]
}
```

The example is ready to run as-is. Swap in your own public post whenever you are ready.

### Input reference

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `urls` | array of strings | Required | Public Instagram URLs using `/reel/`, `/reels/`, or `/p/`. Provide at least one URL. The Input Schema accepts up to 100 entries. |
| `sessionid` | string | None | Optional sensitive session value used only for the current run when Instagram places otherwise public content behind a login check. It does not grant access to private content. |

#### Supported URLs

The Actor accepts:

- `https://www.instagram.com/reel/SHORTCODE/`
- `https://www.instagram.com/USERNAME/reel/SHORTCODE/`
- `https://www.instagram.com/reels/SHORTCODE/`
- `https://www.instagram.com/p/SHORTCODE/`
- The same URLs with tracking query parameters such as `?utm_source=...`

Supported hosts are `instagram.com`, `www.instagram.com`, and `m.instagram.com`. A `/p/` post may contain a video, image, or carousel. Username-prefixed Reel links are normalized to the same canonical Reel URL.

The Actor does not accept profile pages, usernames, Stories, Explore pages, login pages, shortened share redirects, or private posts. Open a share redirect in your browser first and provide the final canonical post or Reel URL.

#### Batch limits and duplicate handling

- Non-paying runs accept up to 5 unique URLs.
- Paying runs accept up to 100 unique URLs.
- Blank entries are ignored and surrounding whitespace is removed.
- Exact duplicates are removed.
- URLs that differ only by `/reel/` versus `/reels/`, host spelling, or tracking parameters are normalized and processed once.
- Each unique input normally creates one Dataset item, including item-level errors.
- Items are processed concurrently, so Dataset order is not guaranteed. Match results using `inputUrl` rather than array position.
- Exceeding the applicable batch limit stops the run before item processing with `BATCH_LIMIT_EXCEEDED`.

The program also recognizes the legacy keys `videoUrls`, `bulkUrls`, and `videoUrl` for existing integrations. New integrations should use `urls` because it is the documented Input Schema field.

### Output reference

A successful Dataset item contains the original URL, canonical URL, content details, media links, author information, engagement metrics, and a null `error`.

```json
{
  "success": true,
  "status": "success",
  "inputUrl": "https://www.instagram.com/p/DbbQB9tCgeO/",
  "normalizedUrl": "https://www.instagram.com/p/DbbQB9tCgeO/",
  "content": {
    "id": "1234567890123456789_123456789",
    "pk": "1234567890123456789",
    "shortcode": "DbbQB9tCgeO",
    "type": "video",
    "caption": "Example Instagram caption",
    "publishedAt": "2026-01-15T10:30:00.000Z",
    "durationSeconds": 18.4
  },
  "media": {
    "videoUrl": "https://example-cdn.invalid/video.mp4",
    "smallVideoUrl": "https://example-cdn.invalid/video-small.mp4",
    "audioUrl": "https://example-cdn.invalid/audio.mp4",
    "thumbnailUrl": "https://example-cdn.invalid/thumbnail.jpg",
    "mediaUrlsTemporary": true
  },
  "author": {
    "id": "123456789",
    "username": "example_creator",
    "displayName": "Example Creator",
    "avatarUrl": "https://example-cdn.invalid/avatar.jpg",
    "verified": false
  },
  "engagement": {
    "viewCount": 1200,
    "playCount": 1320,
    "likeCount": 85,
    "commentCount": 7,
    "shareCount": null
  },
  "platformData": {
    "instagram": {
      "productType": "clips",
      "mediaType": 2
    }
  },
  "error": null
}
```

The example uses placeholder CDN URLs to show the response structure. Real runs return the available URLs supplied for the requested Instagram post.

#### Top-level fields

| Field | Meaning |
| --- | --- |
| `success` | `true` when usable media was resolved; otherwise `false`. |
| `status` | Stable result category such as `success`, `invalid_url`, `login_required`, `private_content`, `media_not_found`, or `error`. |
| `inputUrl` | The URL supplied by the user. |
| `normalizedUrl` | Canonical Instagram URL without tracking parameters, when normalization succeeds. |
| `content` | Post identity, type, caption, publication time, and duration when available. |
| `media` | Resolved media and thumbnail URLs. |
| `author` | Available creator identity and profile metadata. |
| `engagement` | Stable engagement counters. |
| `platformData` | Small Instagram-specific classification values when available. |
| `error` | `null` on success; otherwise a safe error object. |

#### Content fields

| Field | Meaning |
| --- | --- |
| `id` | Instagram media identifier when supplied. |
| `pk` | Instagram media primary key when supplied. |
| `shortcode` | Shortcode used in the canonical post URL. |
| `type` | Normalized media type: `video`, `image`, or `carousel`. |
| `caption` | Post caption or description when available. |
| `publishedAt` | Publication time as an ISO 8601 timestamp when available. |
| `durationSeconds` | Video duration in seconds, rounded to at most two decimal places. |

#### Media fields

| Field | Meaning |
| --- | --- |
| `videoUrl` | Preferred downloadable video URL. |
| `smallVideoUrl` | A smaller video alternative when a genuinely different variant is available. |
| `audioUrl` | Separate audio-track URL when available. |
| `thumbnailUrl` | Cover or preview image URL. |
| `imageUrl` | Downloadable image URL for an image item. |
| `videoVariants` | Additional video variants when the source exposes distinct alternatives. |
| `items` | Normalized child media for a carousel. Each item may contain its own type and media URLs. |
| `mediaUrlsTemporary` | Always `true`; download URLs are temporary and can expire. |

Optional fields are emitted only when the source provides a real value. Empty `videoVariants` or `items` arrays are not added merely as placeholders.

#### Engagement fields

The `engagement` object always contains the following five keys:

| Field | Meaning |
| --- | --- |
| `viewCount` | Independent view count supplied by Instagram, or `null`. |
| `playCount` | Independent play count supplied by Instagram, or `null`. |
| `likeCount` | Like count, or `null`. |
| `commentCount` | Comment count, or `null`. |
| `shareCount` | Share count, or `null`. There is no separate switch or charge for this field. |

Unavailable engagement values are returned as `null`, not copied from another metric, estimated, or replaced with zero. `viewCount` and `playCount` may be equal, different, or independently unavailable because they represent separate source fields.

### Carousel and image posts

For a carousel, `content.type` is `carousel` and the downloadable child media is returned in `media.items`. Each child is normalized independently and can be a video or image.

For a single image post, `content.type` is `image` and the preferred file is normally available in `media.imageUrl`. Because Instagram can expose different combinations of media fields, integrations should check the relevant URL fields instead of assuming every result contains `media.videoUrl`.

### Download the returned media

The Dataset stores URLs, not the media bytes. To save a returned file, read the appropriate URL from the result and download it promptly. For example:

```bash
curl -L 'RETURNED_MEDIA_URL' -o instagram-media.mp4
```

Use the correct file extension for the returned media type. Do not treat a CDN URL as a permanent identifier or publish it as a long-lived link.

### Status and error handling

| Status | Meaning |
| --- | --- |
| `success` | At least one usable media URL was resolved. |
| `invalid_url` | The input is malformed or is not a supported Instagram post/Reel URL. |
| `login_required` | Instagram placed the requested public page behind a login check. |
| `private_content` | The content is private or otherwise inaccessible. |
| `media_not_found` | No usable video, audio, or image source was found. |
| `error` | Another item-level or temporary error occurred. Inspect `error.code` and `error.retryable`. |

Failed result example:

```json
{
  "success": false,
  "status": "media_not_found",
  "inputUrl": "https://www.instagram.com/reel/EXAMPLE/",
  "normalizedUrl": "https://www.instagram.com/reel/EXAMPLE/",
  "content": {},
  "media": {},
  "author": {},
  "engagement": {
    "viewCount": null,
    "playCount": null,
    "likeCount": null,
    "commentCount": null,
    "shareCount": null
  },
  "platformData": {
    "instagram": {}
  },
  "error": {
    "code": "MEDIA_NOT_FOUND",
    "message": "Media was not found.",
    "retryable": false
  }
}
```

If `error.retryable` is `true`, retry the URL later. A valid public post can be temporarily unavailable because of rate limits, login gating, regional or age restrictions, CDN changes, or changes to the page response.

Item-level failures do not stop other URLs in the batch. Top-level input errors such as empty input or an exceeded batch limit stop the run before Dataset processing.

### Run with JavaScript

Install the Apify API client:

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

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const input = {
  urls: ['https://www.instagram.com/p/DbbQB9tCgeO/'],
};

const run = await client
  .actor('lance_api/instagram-video-downloader-api')
  .call(input);

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run with Python

Install the Apify API client:

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

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])

run_input = {
    'urls': ['https://www.instagram.com/p/DbbQB9tCgeO/'],
}

run = client.actor('lance_api/instagram-video-downloader-api').call(
    run_input=run_input
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Run with cURL

The synchronous endpoint starts the Actor, waits for completion, and returns Dataset items:

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/lance_api~instagram-video-downloader-api/run-sync-get-dataset-items' \
  -H 'Authorization: Bearer APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "urls": ["https://www.instagram.com/p/DbbQB9tCgeO/"]
  }'
```

For long or large batches, use the asynchronous Run Actor endpoint and retrieve the Dataset after the run finishes. Keep API tokens out of source control, screenshots, prompts, and logs.

### Use with AI agents through MCP

After publication, MCP-compatible AI clients can discover and run this Actor through the hosted Apify MCP server.

1. Connect the client to `https://mcp.apify.com` using Streamable HTTP.
2. Authenticate with Apify using your client's supported OAuth or API-token method.
3. Ask the agent to find and run `lance_api/instagram-video-downloader-api`.
4. Provide individual public Instagram post or Reel URLs and ask the agent to retrieve the Dataset output.

Common MCP tools are `search-actors`, `fetch-actor-details`, and `call-actor`. Running an Actor and reading its storage requires authentication.

Example agent request:

> Run lance\_api/instagram-video-downloader-api for this public Instagram Reel and return the downloadable video URL, caption, author, duration, and engagement metadata.

### Pricing

Pay only for successful, unique results. Your price automatically drops with your Apify plan:

| Apify plan | Price per 1,000 successful results | Price per result |
| --- | ---: | ---: |
| Free | **$2.50** | $0.0025 |
| Starter | **$2.00** | $0.0020 |
| Scale | **$1.80** | $0.0018 |
| Business | **$1.50** | $0.0015 |

One result can include a video, a separate audio track, a cover image, or multiple carousel items. You still pay for **one result**, not for every file inside it.

Failed URLs, unsupported URLs, and duplicates removed before processing do **not** trigger a `media-result` charge. Apify may separately show its standard Actor-start event in the run pricing.

### Use cases

- Pull Reels into an editing, clipping, or repurposing workflow
- Save approved social assets to your own media library
- Feed videos and captions into AI analysis or moderation pipelines
- Collect post metadata for creator, campaign, or content research
- Grab covers, audio tracks, and carousel assets without manual downloading
- Power no-code automations, internal tools, and AI agents with clean Instagram data

### Limits and practical notes

- Public Instagram posts and Reels only; profile and profile-post collection are not included.
- Private posts, removed posts, Stories, login pages, and unsupported redirect/share URLs cannot be downloaded.
- An optional session ID may help with a login check on public content but must not be used to bypass access controls or retrieve private content.
- Metadata is best effort. Instagram may omit captions, counters, author fields, audio tracks, or alternative media variants.
- Download URLs are temporary and may stop working after the run.
- Instagram can rate-limit requests, change page data, or temporarily withhold media URLs.
- Dataset item order is not guaranteed for batches.
- No permanent file hosting, profile scraping, comment-list scraping, or historical engagement tracking is included.

### Responsible use

Use this Actor only for content you are legally permitted to access, download, and process. Respect privacy, copyright, contractual restrictions, Instagram's terms, and applicable laws. Do not use session credentials to access private content, bypass access controls, or process another person's account without authorization.

Never publish, log, email, or include an Instagram session ID or Apify API token in a support request. Rotate any credential immediately if it is exposed.

### Related Actor

Need searchable speech instead of only media links? Use **Instagram Video AI Transcript Scraper API** to generate plain text, timestamped segments, SRT, WebVTT, and optional translations from individual public Instagram videos:

`lance_api/instagram-video-ai-transcript-scraper-api`

### FAQ

#### Does this Actor save files to Apify storage?

No. It returns temporary downloadable URLs in the Dataset. Your application must download and store the files if permanent retention is required.

#### Why did a valid-looking URL fail?

The post may be private, removed, image-only with unavailable image data, region- or age-restricted, temporarily rate-limited, or placed behind a login check. Confirm that the final canonical URL opens publicly in a logged-out browser and retry later when `error.retryable` is `true`.

#### Why is the caption or another metadata field missing?

Instagram may not expose every field in every response. Optional `content`, `media`, and `author` fields are omitted when unavailable rather than populated with invented values.

#### Why are `viewCount` and `playCount` equal?

They are independent source values and are never copied from one another. Instagram can report the same number for both, different numbers, or omit either value.

#### Is `shareCount` charged separately?

No. It is returned whenever available and otherwise set to `null`. There is no share-count option or separate fee.

#### Are duplicate URLs returned or charged twice?

No. Canonical duplicates are processed once. Tracking parameters, equivalent Reel path variants, and supported host variants do not create additional results or charges.

#### Why are `videoVariants` or carousel `items` missing?

Those fields appear only when Instagram exposes genuine alternatives. Empty arrays are not returned as processing diagnostics.

#### Can I download every file from a carousel?

When carousel children are available, they are returned in `media.items`. Check each child object's `type`, `videoUrl`, and `imageUrl` fields.

#### Does the Actor scrape profiles, feeds, Stories, or comments?

No. It accepts individual public post and Reel URLs. It returns an available comment count, but it does not download comment bodies or expand profile feeds.

#### How should I handle temporary download URLs?

Download the files immediately after the run and store them in storage you control. Do not rely on Instagram CDN URLs remaining valid.

### Support

For help, open an issue on the Actor page or email lanceapi2026@hotmail.com.

Include the Actor run ID, the input URL with unnecessary query parameters removed, the expected behavior, the actual `status` and `error.code`, and a short reproducible description. Never send Apify tokens, Instagram session IDs, passwords, cookies, or other credentials.

# Actor input Schema

## `urls` (type: `array`):

Public Instagram post or Reel URLs. Free runs accept 5; paid runs accept 100.

## `sessionid` (type: `string`):

Used only for this run and never stored in results or logs.

## Actor input object example

```json
{
  "urls": [
    "https://www.instagram.com/reel/DbqnhhDR7rs/?utm_source=ig_web_copy_link&igsh=NTc4MTIwNjQ2YQ=="
  ]
}
```

# Actor output Schema

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

No description

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

No description

# 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 = {
    "urls": [
        "https://www.instagram.com/reel/DbqnhhDR7rs/?utm_source=ig_web_copy_link&igsh=NTc4MTIwNjQ2YQ=="
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lance_api/instagram-video-downloader-api").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 = { "urls": ["https://www.instagram.com/reel/DbqnhhDR7rs/?utm_source=ig_web_copy_link&igsh=NTc4MTIwNjQ2YQ=="] }

# Run the Actor and wait for it to finish
run = client.actor("lance_api/instagram-video-downloader-api").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 '{
  "urls": [
    "https://www.instagram.com/reel/DbqnhhDR7rs/?utm_source=ig_web_copy_link&igsh=NTc4MTIwNjQ2YQ=="
  ]
}' |
apify call lance_api/instagram-video-downloader-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/2a2e4NKzPbJYXhjCz/builds/es8CpipLQGjNKCypO/openapi.json