# Instagram Single Reels Scraper (`simpleapi/instagram-single-reels-scraper`) Actor

Instagram Single Reels Scraper extracts data from any public Instagram Reel, including captions, audio, hashtags, media URLs, views, likes, comments, and timestamps. Ideal for trend analysis, influencer research, content insights, and automating structured Reel data collection at scale.

- **URL**: https://apify.com/simpleapi/instagram-single-reels-scraper.md
- **Developed by:** [SimpleAPI](https://apify.com/simpleapi) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 105 total users, 4 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period. You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#rental-actors

## 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 Reel Scraper — Captions, Engagement Counts and Video URLs

Instagram Single Reels Scraper pulls one Instagram Reel's data from its public URL — no login, no session cookie, no Instagram account. Give it a reel link, a `username/shortcode` pair, or a bare shortcode and get back `captionText`, `likeCount`, `commentCount`, `playCount`, `videoUrlBest`, `thumbnailUrl`, `musicArtistUsername`, and a comment sample, flattened into typed dataset columns. Content researchers, brand monitoring teams, and agencies use it to verify one reel at a time instead of crawling a whole profile. Every run reports success or failure per URL, so nothing goes missing silently.

### What is Instagram Single Reels Scraper?

Instagram Single Reels Scraper is a single-URL extraction tool: point it at one or more specific Instagram Reel links and it returns that reel's caption, engagement counts, video and thumbnail assets, music metadata, and a small comment sample as clean JSON rows — not a bulk profile or hashtag crawl. It runs fully logged out; no Instagram account, session cookie, or API key is required to use it.

- Looks up content by exact reference — full reel URL, `username/shortcode`, or a bare shortcode — one row per input, not a bulk crawl
- Returns identity and caption fields: `shortcode`, `mediaId`, `captionText`, plus raw and ISO posting timestamps
- Reports Instagram's own engagement counters: `likeCount`, `commentCount`, `playCount`
- Extracts the highest-resolution `videoUrlBest` and `thumbnailUrl`, plus music metadata (`musicAudioType`, `musicArtistUsername`)
- Samples the reel's own first-page comments (`commentsExtracted`) with author, text, and verification flag
- Every blocked or failed URL still writes a typed, uncharged `errorReason` row instead of vanishing silently; results export via Apify's standard JSON/CSV/Excel formats or the API

### What data can I extract with Instagram Single Reels Scraper?

Every processed URL is pushed as one row with the fields below — this is every key the Actor writes, not just the dataset's default view.

| Field | Example Value | Use Case |
| --- | --- | --- |
| `url` | `"https://www.instagram.com/cristiano/reel/DOEMHa6iPoz/"` | Identify which reel this row came from |
| `success` | `true` | Separate successfully scraped rows from failed accounting rows |
| `errorReason` | `null` | Typed failure reason (`login_required`, `media_not_found`, `graphql_error`, etc.) on failed rows |
| `shortcode` | `"DOEMHa6iPoz"` | Instagram's own reel identifier, for cross-referencing |
| `mediaId` | `"3712145279353944627"` | Stable internal Instagram media ID for de-duplication |
| `mediaType` | `2` | Instagram's raw media-type flag (2 = video/reel) |
| `productType` | `"clips"` | Confirms the item is a Reel rather than a feed post |
| `captionText` | `"I came here to do what I love, but I #StayedForMore..."` | Caption text for keyword/hashtag/sentiment analysis |
| `captionCreatedAt` | `1756742460` | Unix timestamp the caption was created |
| `takenAt` | `1756742460` | Unix timestamp the reel was posted |
| `takenAtIso` | `"2025-09-01T15:01:00Z"` | Human-readable posting date for reporting |
| `likeCount` | `1806539` | Like total for engagement benchmarking |
| `commentCount` | `20505` | Instagram-reported total comment count |
| `playCount` | `null` | Play/view total when Instagram exposes it (else `null`, never a faked `0`) |
| `videoUrlBest` | `"https://instagram.fxyz1-1.fna.fbcdn.net/o1/v/t2/f2/m86/....mp4"` | Highest-resolution video asset for playback or re-use |
| `videoWidth` | `720` | Width of the selected best-resolution video |
| `videoHeight` | `1280` | Height of the selected best-resolution video |
| `thumbnailUrl` | `"https://instagram.fxyz1-1.fna.fbcdn.net/v/t51.71878-15/....jpg"` | Highest-resolution cover image |
| `hasAudio` | `true` | Filter for reels that carry audio |
| `musicAudioType` | `"original_sounds"` | Distinguish original audio from a licensed track |
| `musicIsOriginalAudio` | `true` | Boolean flag for original-audio reels |
| `musicAssetId` | `null` | ID of the specific audio track, when Instagram supplies one |
| `musicArtistUsername` | `"cristiano"` | Username of the original-audio creator, for trend/audio tracking |
| `location` | `null` | Location object Instagram attaches to the reel, when present |
| `accessibilityCaption` | `null` | Instagram's own auto-alt-text, when present |
| `commentsExtracted` | `[{ "commentId": "...", "commentText": "Not everyone sorry 😣", "commentUserUsername": "nouralaswad94", ... }]` | First-page comment sample for lightweight sentiment spot-checks |
| `commentsExtractedCount` | `2` | Size of the comment sample actually returned |
| `commentCollected` | `true` | Whether any comments were retrieved at all |
| `mediaCollected` | `true` | Whether reel media data was found (`false` on a failed row) |
| `attempts` | `1` | Number of fetch attempts made, including retries |
| `proxy_used` | `"residential"` | Proxy type used on the attempt that succeeded |
| `scraped_at` | `"2026-07-23T11:24:30Z"` | Timestamp of extraction, for freshness checks |

Each `commentsExtracted[]` item carries `commentId`, `commentText`, `commentUserUsername`, `commentUserId`, `commentUserVerified`, `commentLikeCount`, `childCommentCount`, and `commentCreatedAt`.

#### Engagement metrics

`likeCount`, `commentCount`, and `playCount` are read directly from the same logged-out payload the reel's own page serves, giving a snapshot of performance at request time rather than a cached or estimated figure. `playCount` is genuinely `null` on some reels — Instagram doesn't always expose a play/view counter on this response, and the Actor never substitutes a fake `0` to make the row look complete. A common workflow: scrape a short list of reel URLs on a recurring schedule and compare `likeCount`/`commentCount` run-over-run to see whether a specific piece of content is still gaining traction or has plateaued, without needing an Instagram account to check manually.

#### Reel identification fields

Because this Actor works from an exact reel reference rather than a search, `url`, `shortcode`, and `mediaId` are what let you track and de-duplicate a specific reel across repeated runs — feed the same `shortcode` back in later and match it against the earlier row to build a time series for that one piece of content. There is no category, hashtag, or location filter here; the reel you get back is entirely determined by which URL, `username/shortcode` pair, or bare shortcode you pass in.

### How does Instagram Single Reels Scraper differ from the official Instagram API?

Instagram's own Graph API only ever returns data for the Business or Creator account that authorized your app — per Meta's Instagram Platform documentation, there is no endpoint for looking up an arbitrary public reel by URL, which is the Graph API's hardest limit for anyone who needs data on content they don't own.

| Feature | Instagram Graph API | Instagram Single Reels Scraper |
| --- | --- | --- |
| Account required | Business or Creator account linked to a Facebook Page, plus a reviewed Meta developer app | None — just an Apify account to run the Actor |
| Content scope | Only media owned by the authenticated account | Any public reel, by URL, from any account |
| Access setup | App creation, Meta app review, OAuth token generation and refresh | Paste a URL and run |
| Comment access | A separate edge, scoped to the authenticated account's own media | First-page comment sample returned inline with the reel data |
| Output shape | Nested objects following the Graph API's own object schema | Flat, typed dataset columns, one row per reel |
| Login state | Requires a persistent access token tied to a logged-in account | Fully logged out — no session, cookie, or token |

#### Why can't the Graph API just fetch a competitor's or client's reel?

Graph API access is scoped to whichever Business/Creator account authorized your app, and its permissions (`instagram_basic`, `instagram_manage_insights`) only unlock media that account itself owns — there is no "look up any public reel by URL" endpoint, because Meta built the permission model around a brand managing its own account's content and insights, not third-party content discovery. In practice that means a Graph API integration can pull your own reel's data all day but cannot answer "what does this competitor's or client's reel say and how is it performing" — the exact question this Actor answers, since it reads the same data the reel's public page itself serves, independent of any account's token or ownership.

The Graph API is the right tool when you own the account and want its insights inside Meta's own ecosystem. Instagram Single Reels Scraper is the right tool when you need data on a specific reel you don't control — a competitor's, a client's, or one flagged for review — without an app review process or an owned account.

### How to use data extracted from Instagram?

#### Content researchers

Paste a list of reel URLs gathered from a research set — competitor content, a campaign's reels, or links flagged for review — into `urls` and run. Each row's `captionText`, `likeCount`, `commentCount`, `playCount`, and `musicArtistUsername` land directly in a dataset you can export to a spreadsheet, letting you compare caption angles, audio choices, and performance across a curated set of reels without opening Instagram once per link. Because `commentsExtracted` ships inline, a quick read of the top visible comments is available in the same row, useful for a first-pass read on audience reaction before deciding whether a reel warrants deeper analysis.

#### Brand monitoring agencies

Agencies tracking a fixed list of client or competitor reel URLs on a recurring basis can schedule this Actor per client, feeding the same `urls` list into each run. Comparing `likeCount` and `commentCount` across runs shows whether a specific reel is still gaining traction, while a row's `success`/`errorReason` flags a reel that's been deleted, made private, or is otherwise blocked — a real signal worth flagging to the client — without the agency re-checking each link by hand.

#### Market and trend research

Sampling reel URLs tied to a specific `musicAudioType` or `musicArtistUsername` across many creators shows how far a particular sound has spread, and cross-referencing `likeCount`/`playCount` against `takenAtIso` surfaces whether early adopters of a trend outperformed later ones. Because each row is a single verified reel rather than an aggregate, this is best used to build a manual sample set of URLs first (from a hashtag or creator list) and then run them through this Actor for the underlying numbers.

#### AI agents and automated pipelines

Because input and output are plain JSON, an agent can pass a reel URL extracted from a message, ticket, or feed item as `urls` and get back structured fields — `captionText`, engagement counts, `commentsExtracted` — to ground a moderation check, a summarization step, or a RAG pipeline, without the agent needing its own Instagram-fetching or proxy logic.

### 🔼 Input sample

Both parameters are optional — the Actor runs with the prefilled example URLs if you provide nothing else, though `urls` needs at least one real entry to produce any output.

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `urls` | No | array | List of Instagram reel inputs to scrape. Accepts a full URL (`https://www.instagram.com/cristiano/reel/DOEMHa6iPoz/`), a `username/shortcode` pair (`cristiano/DOEMHa6iPoz`), or a bare shortcode. | `["https://www.instagram.com/cristiano/reel/DOEMHa6iPoz/", "cristiano/DOEMHa6iPoz"]` |
| `proxyConfiguration` | No | object | Proxy settings. This Actor always uses RESIDENTIAL Apify Proxy for every request regardless of the group selected here — only the `apifyProxyCountry` (if set) is honored. | `{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "US"}` |

```json
{
  "urls": [
    "https://www.instagram.com/cristiano/reel/DOEMHa6iPoz/",
    "cristiano/DOEMHa6iPoz"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
```

**Common pitfall:** starting a run with `urls` left empty produces **zero** dataset rows — not even an error accounting row, since that check happens before any per-URL processing. Always confirm `urls` has at least one entry before starting a run. Separately, whichever `apifyProxyGroups` value you pick in `proxyConfiguration` is ignored — the Actor always issues requests over a residential proxy for reliability; only the country is actually honored.

### 🔽 Output sample

Output is typed, normalized JSON with a consistent schema across every row, exportable as JSON, CSV, or Excel from the dataset, or fetched via the Apify API.

```json
{
  "url": "https://www.instagram.com/cristiano/reel/DOEMHa6iPoz/",
  "scraped_at": "2026-07-23T11:24:30Z",
  "proxy_used": "residential",
  "attempts": 1,
  "mediaCollected": true,
  "errorReason": null,
  "shortcode": "DOEMHa6iPoz",
  "mediaId": "3712145279353944627",
  "mediaType": 2,
  "productType": "clips",
  "captionText": "I came here to do what I love, but I #StayedForMore. The people, the energy, and...",
  "captionCreatedAt": 1756742460,
  "takenAt": 1756742460,
  "takenAtIso": "2025-09-01T15:01:00Z",
  "likeCount": 1806539,
  "commentCount": 20505,
  "playCount": null,
  "videoUrlBest": "https://instagram.ftun10-1.fna.fbcdn.net/o1/v/t2/f2/m86/AQN4j-akK4-Os0...mp4",
  "videoWidth": 720,
  "videoHeight": 1280,
  "thumbnailUrl": "https://instagram.ftun10-1.fna.fbcdn.net/v/t51.71878-15/539543640_1700...jpg",
  "hasAudio": true,
  "musicAudioType": "original_sounds",
  "musicIsOriginalAudio": true,
  "musicAssetId": null,
  "musicArtistUsername": "cristiano",
  "location": null,
  "accessibilityCaption": null,
  "commentsExtracted": [
    {
      "commentId": "17899517133514496",
      "commentText": "Not everyone sorry 😣",
      "commentUserUsername": "nouralaswad94",
      "commentUserId": "399797756",
      "commentUserVerified": false,
      "commentLikeCount": null,
      "childCommentCount": null,
      "commentCreatedAt": null
    }
  ],
  "commentsExtractedCount": 1,
  "commentCollected": true,
  "success": true
}
```

A blocked or failed URL still produces a row instead of silence:

```json
{
  "url": "https://www.instagram.com/someone/reel/abc12345/",
  "scraped_at": "2026-07-11T00:00:00Z",
  "proxy_used": "none",
  "attempts": 3,
  "mediaCollected": false,
  "errorReason": "login_required",
  "commentCollected": false,
  "commentsExtracted": [],
  "commentsExtractedCount": 0,
  "success": false
}
```

This uncharged accounting row is never billed — only successfully scraped reels (the `row_result` event) are. Filter it out downstream with `success == true` or `errorReason == null`.

### How do you filter and target specific Reels?

With only `urls` and `proxyConfiguration` as inputs, there is no category, keyword, or location filter to tune here — the single targeting mechanism is which exact reels you list in `urls`. Precision comes from what you put into that array: a full URL or `username/shortcode` pair pins down one exact reel with no ambiguity, while batching several references in a single run scopes that run to exactly the set of reels you care about (a client's latest posts, a competitor watchlist, a queue of links flagged for review) without pulling in anything else. There's no volume cap in the schema beyond the length of `urls` itself, so scoping a run is really just curating that list — and checking `success`/`errorReason` on the way out tells you which of those specific reels actually came back.

### ▶️ Want to try other Instagram scrapers?

| Scraper Name | What it extracts |
| --- | --- |
| Instagram Reels Scraper With Engagement Analytics | Bulk Reels per creator with co-author/tagged-user/paid-partnership detection and derived engagement-rate, velocity, and views-per-follower analytics |
| Instagram Comments Scraper (Spam & Toxic Comment Detection) | Comments and replies from a post/reel with rule-based toxicity, spam, scam, and bot-pattern flags |
| Instagram Profile Scraper + Account Privacy Checker | Bulk account status (active/private/not found), account-type classification, and full profile data |
| Instagram Hashtag Scraper: Content Planner | Posts/reels for a hashtag turned into a best-time-to-post histogram and recurring caption keywords |
| Instagram Followers Count Scraper | Follower/following/post counts plus full public profile data for any username |
| Instagram Tagged Posts Scraper: Videos, Carousels & Reels Info | Posts where a target profile is tagged, with normalized video, carousel-slide, and Reels music data |

### How to extract Instagram data programmatically

This Actor runs as a standard Apify Actor: one API call starts the run, structured JSON comes back from the dataset — no separate scraping infrastructure to maintain.

#### Python example

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("SimpleAPI/instagram-single-reels-scraper").call(run_input={
    "urls": ["https://www.instagram.com/cristiano/reel/DOEMHa6iPoz/"],
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["captionText"], item["likeCount"], item["videoUrlBest"])
```

#### Export to spreadsheets or CRM

Export the dataset directly as CSV from the Apify Console or via the API, then import into a spreadsheet or tracking sheet. Map `url` to a source-link column, `captionText` to a content/notes column, and `likeCount`/`commentCount`/`playCount` to numeric engagement columns so every imported row still traces back to the original reel.

### Is it legal to scrape Instagram Reels?

Yes — this Actor collects only what is publicly visible on a reel's own page, without logging in or accessing anything behind an authentication wall, and public reels exist to be seen and shared. That said, scraped rows can contain personal data: a commenter's `commentUserUsername`, and a `musicArtistUsername` identifying an original-audio creator. Where that applies, GDPR and CCPA govern how you may store and use it — you need a lawful basis for holding personal data and must honor deletion/access requests from the people it describes. Consult legal counsel for commercial applications involving bulk storage of personal data.

### ❓ FAQ

#### What happens if a reel is deleted or made private after I scrape it?

The dataset holds a snapshot from `scraped_at` — it doesn't update itself. Re-run the same URL later if you need to check current status; a reel that's since been removed, made private, or otherwise blocked comes back with `success: false` and a typed `errorReason` (e.g. `media_not_found`, `login_required`) instead of stale data pretending to be current.

#### Can I get comments along with the main reel data?

Yes, automatically — every row includes `commentsExtracted`, a first-page sample of the reel's own visible comments (author, text, verification flag), with `commentsExtractedCount` telling you how many were found. This comes from the same response as the reel data itself, so there's no separate comment-fetch step or extra input to enable — but it is a small, first-page sample, not the full comment thread.

#### How accurate is the engagement data?

The Actor returns `likeCount`, `commentCount`, and `playCount` exactly as Instagram's own logged-out response reports them at request time. Counts change continuously on Instagram itself, so treat each row as a snapshot and re-scrape the same URL if you need current numbers.

#### How many reels can I get per run?

There's no hard cap in the input schema — every entry in `urls` is processed in the same run. Each URL gets up to 3 fetch attempts on a freshly rotated residential proxy if a request fails or comes back blocked, with a short pause between items, so a large `urls` list simply takes proportionally longer rather than being truncated.

#### How do I control exactly which reel I get back?

There's no keyword or category search here — the reel you get is whichever one you reference in `urls`, as a full URL, a `username/shortcode` pair, or a bare shortcode. This makes the Actor precise for known-reel lookups but not a discovery tool; pair it with a separate hashtag or profile scraper if you need to find reel URLs first.

#### Does Instagram Single Reels Scraper work with Claude, ChatGPT, and AI agent frameworks?

Yes — it's callable as a standard HTTP endpoint via the Apify API by any agent framework that can make an authenticated REST call. Pass a reel URL as `urls` and read structured fields (`captionText`, engagement counts, `commentsExtracted`) back from the dataset.

#### How does Instagram Single Reels Scraper compare to other Instagram scrapers?

It's deliberately narrower than a bulk Reels crawler: it takes exact reel URLs rather than a creator or hashtag to crawl, and it does not extract owner/creator identity, co-author or tagged-user graphs, paid-partnership flags, or derived engagement-rate analytics — those are covered by this account's own Instagram Reels Scraper With Engagement Analytics, built on the same fetch technique. Choose this Actor when you already have the specific reel links you need; choose the analytics variant when you need to crawl a creator's Reels in bulk with collaboration and ratio data attached.

#### Can I use this without an Instagram API key or developer account?

Yes — no Instagram login, session cookie, API key, or Meta developer account is required. The only credential needed is your own Apify account to run the Actor.

#### Do I need to configure my own proxies for this to work reliably?

No — the Actor always requests over a residential Apify Proxy regardless of what you set in `proxyConfiguration`; only the `apifyProxyCountry` value, if provided, is honored. This is a deliberate reliability choice, since datacenter IPs get blocked quickly on Instagram's logged-out surfaces.

### Conclusion

Instagram Single Reels Scraper turns a specific reel URL into a structured, typed dataset row — caption, engagement counts, video and thumbnail assets, music metadata, and a comment sample — without an Instagram login or a Meta developer account. It's built for researchers, brand monitoring agencies, and anyone who needs honest per-URL accounting on a known list of reels rather than a bulk profile crawl. Start a run in Apify Console with your reel URLs in `urls` to see rows populate the dataset as each one is scraped.

# Actor input Schema

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

List of Instagram reel inputs to scrape. Supports multiple formats:

✅ Full URLs: https://www.instagram.com/cristiano/reel/DOEMHa6iPoz/
✅ Username/Shortcode: cristiano/DOEMHa6iPoz
✅ Shortcode only: DOEMHa6iPoz

## `proxyConfiguration` (type: `object`):

Proxy settings for the scraper. This actor always uses RESIDENTIAL Apify Proxy for every request regardless of the group you pick here — only the country (if set) is honored.

## Actor input object example

```json
{
  "urls": [
    "https://www.instagram.com/cristiano/reel/DOEMHa6iPoz/",
    "cristiano/DOEMHa6iPoz"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

All scraped items in the Actor'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 = {
    "urls": [
        "https://www.instagram.com/cristiano/reel/DOEMHa6iPoz/",
        "cristiano/DOEMHa6iPoz"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("simpleapi/instagram-single-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 = {
    "urls": [
        "https://www.instagram.com/cristiano/reel/DOEMHa6iPoz/",
        "cristiano/DOEMHa6iPoz",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("simpleapi/instagram-single-reels-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "urls": [
    "https://www.instagram.com/cristiano/reel/DOEMHa6iPoz/",
    "cristiano/DOEMHa6iPoz"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call simpleapi/instagram-single-reels-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,simpleapi/instagram-single-reels-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/vUkc7KycIhJrcicvR/builds/ensZZrcaVnFhXAIxK/openapi.json