# Instagram Reels Discovery Scraper - No Login (`datascraperes/instagram-reels-discovery-scraper`) Actor

Discover regional public Instagram Reels and creators without login. Select a country and export captions, engagement, authors, audio, thumbnails, and video URLs. Pay only $1 per 1,000 unique Reels delivered.

- **URL**: https://apify.com/datascraperes/instagram-reels-discovery-scraper.md
- **Developed by:** [DataScraperES](https://apify.com/datascraperes) (community)
- **Categories:** Social media, Marketing, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 instagram reels

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

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Reels Discovery Scraper - No Login

Discover public Instagram Reels and creators for a selected country without an Instagram account, cookies, or login credentials. Choose the discovery country and maximum number of unique Reels, then receive structured data for content research, creator discovery, trend monitoring, social media analysis, and automated data workflows.

The Actor begins with Instagram's public logged-out Reels experience. For larger requests, it broadens the dataset with additional public Reels from creators surfaced during that discovery process.

> This is a regional discovery Actor. The selected country controls where the public discovery request is made, but it does not prove that every returned Reel was created in that country. Instagram can recommend global content in every region.

### Why use this Actor?

- No Instagram login, account, cookies, or session required
- Country-level regional discovery with a global `AUTO` option
- Simple maximum-result and maximum-spend control
- Unique results deduplicated by Instagram media ID
- Reel captions, engagement, creator, audio, image, and video data
- Clear distinction between feed discoveries and additional creator Reels
- Automatic concurrency for both small and large requests
- JSON, JSONL, CSV, Excel, XML, and RSS exports
- Apify API, schedules, webhooks, and integrations supported
- Pay only for unique Reels successfully delivered

### Quick start

1. Open the **Input** tab.
2. Select a country under **Discovery country**, such as United States, Spain, Brazil, or Mexico.
3. Enter the maximum number of Reels under **Maximum Reels**.
4. Leave **Concurrency** at `0` for automatic scaling.
5. Click **Save & Start**.
6. Open the **Dataset** when the run finishes and export the results in your preferred format.

For a quick test, use:

```json
{
  "countryCode": "US",
  "resultsLimit": 10
}
````

### Regional discovery

`countryCode` selects the country from which Instagram's logged-out Reels experience is requested. All discovery sessions in the run use that same country, while separate sessions can use different residential addresses inside the selected country.

This setting is useful for comparing the public Reels experience available to audiences in different markets. For example, run once with `ES` and once with `BR`, then compare creators, captions, hashtags, audio, and engagement.

Country targeting influences the discovery context; it is not an origin classifier:

- `discoveryCountry: "ES"` means the Reel was collected through an Instagram discovery session requested from Spain.
- It does not mean the creator lives in Spain or that the Reel was recorded or uploaded there.
- Instagram may surface global or cross-language content in any country.
- Select `AUTO` when you want an unrestricted global sample instead of a fixed country.

The input is a dropdown, so you do not need to remember or type a country code. The Actor supports 50 selected markets plus the global `AUTO` option.

#### Supported discovery countries

| Code | Country | Code | Country |
| --- | --- | --- | --- |
| `US` | United States | `IN` | India |
| `BR` | Brazil | `ID` | Indonesia |
| `TR` | Turkey | `JP` | Japan |
| `MX` | Mexico | `GB` | United Kingdom |
| `DE` | Germany | `AR` | Argentina |
| `IT` | Italy | `FR` | France |
| `KR` | South Korea | `CO` | Colombia |
| `ES` | Spain | `PH` | Philippines |
| `TH` | Thailand | `EG` | Egypt |
| `PK` | Pakistan | `BD` | Bangladesh |
| `SA` | Saudi Arabia | `MY` | Malaysia |
| `NG` | Nigeria | `MA` | Morocco |
| `VN` | Vietnam | `CA` | Canada |
| `AU` | Australia | `ZA` | South Africa |
| `AE` | United Arab Emirates | `NL` | Netherlands |
| `PL` | Poland | `RO` | Romania |
| `PT` | Portugal | `CL` | Chile |
| `PE` | Peru | `EC` | Ecuador |
| `UY` | Uruguay | `GR` | Greece |
| `CZ` | Czechia | `SE` | Sweden |
| `DK` | Denmark | `CH` | Switzerland |
| `AT` | Austria | `BE` | Belgium |
| `IE` | Ireland | `UA` | Ukraine |
| `SG` | Singapore | `NZ` | New Zealand |
| `TW` | Taiwan | `IL` | Israel |

### What the Actor discovers

The dataset can contain two clearly labelled result sources:

| `discoverySource` | Meaning |
| --- | --- |
| `reels_feed` | The Reel was surfaced directly by Instagram's public logged-out Reels experience. |
| `discovered_creator` | The creator was first surfaced in that public experience, and this is another public Reel from the same creator. |

Use only rows with `discoverySource: "reels_feed"` when you need the strictest public-feed sample. Use the complete dataset when you need broader coverage of the creators Instagram surfaced.

Additional creator Reels should not be interpreted as an official global popularity ranking. Instagram does not publish the ranking logic used by its public discovery experience.

### Common use cases

#### Creator discovery

Identify public creators surfaced through Instagram's Reels experience and collect content samples for further evaluation.

#### Trend and format research

Analyze captions, hashtags, mentions, audio, video length, publishing patterns, and engagement signals across a current discovery sample.

#### Influencer and partnership research

Build a candidate dataset containing creator usernames, verification status, public Reel URLs, content descriptions, and available engagement metrics.

#### Social media monitoring

Run the Actor on a schedule and compare datasets over time to observe changes in creators, formats, topics, and audio usage.

#### Content classification

Send captions, hashtags, thumbnails, or Reel URLs into analytics, moderation, tagging, or machine-learning workflows.

#### Data enrichment

Add public Reel and creator information to existing CRM, marketing, research, or business-intelligence datasets.

### Input reference

All input fields are optional. Running the Actor without custom input uses the default values below.

| Field | Type | Default | Allowed values | Description |
| --- | --- | ---: | --- | --- |
| `countryCode` | string | `US` | `AUTO` or one of 50 countries in the dropdown | Country used for the Instagram discovery request. This is a regional targeting signal, not proof of Reel origin. |
| `resultsLimit` | integer | `100` | `1` to `5000` | Maximum number of unique Reels delivered across the run. This is also the main maximum-spend control. |
| `concurrency` | integer | `0` | `0` to `15` | Number of discovery sessions processed in parallel. Use `0` for automatic scaling. |
| `maxRetries` | integer | `3` | `1` to `5` | Maximum attempts after a temporary network error or Instagram rejection. |

#### Discovery country (`countryCode`)

Choose a country from the dropdown. The stored API value is the uppercase code shown below the country name. Common examples:

| Value | Discovery region |
| --- | --- |
| `US` | United States |
| `ES` | Spain |
| `BR` | Brazil |
| `MX` | Mexico |
| `DE` | Germany |
| `AUTO` | No fixed country; global rotating sample |

For consistent market comparisons, keep the same country in every run. To compare countries, use separate runs so every row in a dataset has one clear discovery context. API calls are also restricted to the same 50 codes, preventing misspelled or unsupported values from starting a run.

#### Maximum Reels (`resultsLimit`)

`resultsLimit` is a maximum, not a guaranteed minimum. The Actor stops when one of these conditions is reached:

- The requested number of unique Reels has been delivered.
- Instagram exposes no additional unique results after repeated discovery attempts.
- The configured Apify spending limit cannot pay for another result.
- Temporary Instagram access pressure remains after all configured retries.

If you request 50 Reels and only 20 unique Reels can be delivered, the dataset contains 20 rows and you pay for 20 results.

#### Concurrency (`concurrency`)

The recommended value is `0`:

- Small runs use low concurrency to avoid unnecessary overhead.
- Medium runs increase concurrency automatically.
- Large runs use more parallel sessions to reduce completion time.

Set a manual value only when you specifically need to reduce request pressure or control resource use. Higher concurrency does not guarantee more unique content because Instagram controls the available discovery pool.

#### Maximum request attempts (`maxRetries`)

The default value of `3` is appropriate for most runs. Increase it when temporary network instability is more important than run duration. Lower it when you prefer a faster failure after repeated access problems.

### Input examples

#### Quick sample: 10 Reels

```json
{
  "countryCode": "US",
  "resultsLimit": 10
}
```

#### Research sample: 50 Reels

```json
{
  "countryCode": "ES",
  "resultsLimit": 50,
  "concurrency": 0,
  "maxRetries": 3
}
```

#### Larger discovery dataset: 1,000 Reels

```json
{
  "countryCode": "BR",
  "resultsLimit": 1000,
  "concurrency": 0,
  "maxRetries": 3
}
```

#### Conservative request pressure

```json
{
  "countryCode": "DE",
  "resultsLimit": 100,
  "concurrency": 2,
  "maxRetries": 4
}
```

### Output overview

Every row in the default dataset represents one unique public Reel. Duplicate media IDs are removed across the complete run.

Instagram does not expose every field for every Reel. Unavailable values are returned as `null`, `false`, or an empty list as appropriate. The Actor does not estimate or invent missing metrics.

#### Core Reel fields

| Field | Type | Description |
| --- | --- | --- |
| `schemaVersion` | integer | Version of the output contract. |
| `id` | string | Stable Instagram media ID used for deduplication. |
| `shortCode` | string | Shortcode used in the public Instagram Reel URL. |
| `url` | string | Permanent public Reel page, such as `https://www.instagram.com/reel/.../`. |
| `type` | string | Normalized content type. Always `reel`. |
| `productType` | string or null | Product classification exposed by Instagram, commonly `clips`. |
| `caption` | string or null | Reel caption text. |
| `hashtags` | string\[] | Unique hashtags extracted from the caption, without `#`. |
| `mentions` | string\[] | Unique usernames mentioned in the caption, without `@`. |
| `timestamp` | string or null | Publication time in ISO 8601 UTC format. |
| `scrapedAt` | string | Time the result was collected, in ISO 8601 UTC format. |

#### Engagement and video fields

| Field | Type | Description |
| --- | --- | --- |
| `likesCount` | integer or null | Like count when Instagram exposes it. |
| `commentsCount` | integer or null | Comment count when available. Comments themselves are not included. |
| `videoViewsCount` | integer or null | View count when available. |
| `videoPlaysCount` | integer or null | Play count when available. This can differ from unique views. |
| `videoDurationSeconds` | number or null | Video duration in seconds. |
| `width` | integer or null | Original media width. |
| `height` | integer or null | Original media height. |
| `hasAudio` | boolean | Whether the Reel reports an audio track. |
| `isPaidPartnership` | boolean | Whether Instagram marks the Reel as a paid partnership. |
| `displayUrl` | string or null | Best available thumbnail or display-image URL. |
| `videoUrl` | string or null | Best available direct video URL. Direct media URLs can expire. |

#### Creator fields

The `owner` object can contain:

| Field | Type | Description |
| --- | --- | --- |
| `owner.id` | string or null | Instagram creator ID. |
| `owner.username` | string or null | Public Instagram username. |
| `owner.fullName` | string or null | Public display name. |
| `owner.isVerified` | boolean | Verification status exposed for the creator. |
| `owner.profilePicUrl` | string or null | Public profile-image URL. |

#### Audio fields

The `audio` object can contain:

| Field | Type | Description |
| --- | --- | --- |
| `audio.id` | string or null | Audio identifier when available. |
| `audio.title` | string or null | Track or original-audio title. |
| `audio.artist` | string or null | Artist or creator name exposed for the audio. |
| `audio.isOriginalAudio` | boolean | Whether the metadata represents original audio. |

#### Discovery fields

| Field | Type | Description |
| --- | --- | --- |
| `discoverySource` | string | `reels_feed` or `discovered_creator`. |
| `discoveryCountry` | string or null | Country selected for this discovery run. It is `null` when `countryCode` is `AUTO`. This is not the creator's or Reel's confirmed origin. |
| `seedReelId` | string or null | Reel that led to the creator expansion. It is `null` for direct feed discoveries. |

### Example result

```json
{
  "schemaVersion": 2,
  "id": "1234567890123456789",
  "shortCode": "ExampleCode",
  "url": "https://www.instagram.com/reel/ExampleCode/",
  "type": "reel",
  "productType": "clips",
  "caption": "A public Reel caption #travel @example_creator",
  "hashtags": ["travel"],
  "mentions": ["example_creator"],
  "timestamp": "2026-07-22T12:00:00+00:00",
  "displayUrl": "https://...",
  "videoUrl": "https://...",
  "width": 1080,
  "height": 1920,
  "likesCount": 1250,
  "commentsCount": 34,
  "videoViewsCount": 42000,
  "videoPlaysCount": 45100,
  "videoDurationSeconds": 18.4,
  "hasAudio": true,
  "isPaidPartnership": false,
  "owner": {
    "id": "987654321",
    "username": "example_creator",
    "fullName": "Example Creator",
    "isVerified": false,
    "profilePicUrl": "https://..."
  },
  "audio": {
    "id": "456789",
    "title": "Original audio",
    "artist": "Example Creator",
    "isOriginalAudio": true
  },
  "discoverySource": "reels_feed",
  "discoveryCountry": "ES",
  "seedReelId": null,
  "scrapedAt": "2026-07-22T12:05:00+00:00"
}
```

### Pricing

The Actor uses pay-per-result pricing:

| Event | Price | When it is charged |
| --- | ---: | --- |
| `reel-result` | `$0.001` | Once for each unique Reel successfully written to the default dataset. |

There is no separate startup charge.

#### Cost examples

| Unique Reels delivered | Maximum result charge |
| ---: | ---: |
| 10 | `$0.01` |
| 50 | `$0.05` |
| 100 | `$0.10` |
| 1,000 | `$1.00` |
| 5,000 | `$5.00` |

You are not charged for:

- Duplicate Reels
- Invalid or incomplete records that cannot be delivered
- Failed requests and retries
- Sessions that return no new unique results
- The free run summary

The billing rule is: **one default-dataset row equals one `reel-result` event**.

Apify spending limits are respected. If the remaining budget cannot pay for another result, the Actor stops without delivering unpaid rows.

### Exporting results

Open the run's **Dataset** tab to:

- View results in a table
- Select the fields you want to export
- Download JSON, JSONL, CSV, Excel, XML, or RSS
- Copy the dataset API endpoint
- Connect the dataset to another application

Direct media URLs can expire or become region-restricted. Store the permanent `url` field whenever you need a durable reference to the Reel.

### Run summary

Each run creates a free `SUMMARY` record in the default key-value store. It includes customer-relevant information such as:

- Requested and delivered Reel counts
- Selected discovery country and whether regional targeting was enabled
- Charged result count and estimated result charge
- Whether an Apify spending limit stopped the run
- Whether the available unique discovery pool was exhausted
- Duplicate and invalid records skipped
- Number of creators discovered
- Sessions, requests, response volume, and duration
- Concurrency used and completion time

The summary is not a billable result and does not appear as a Reel row in the dataset.

### Using the Apify API

The Actor can be started programmatically with the Apify API. Replace `YOUR_APIFY_TOKEN` with a token from your Apify account settings.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("datascraperes/instagram-reels-discovery-scraper").call(
    run_input={
        "countryCode": "ES",
        "resultsLimit": 50,
        "concurrency": 0,
        "maxRetries": 3,
    }
)

items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
print(f"Received {len(items)} unique Reels")
```

#### JavaScript

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('datascraperes/instagram-reels-discovery-scraper').call({
    countryCode: 'ES',
    resultsLimit: 50,
    concurrency: 0,
    maxRetries: 3,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Received ${items.length} unique Reels`);
```

#### HTTP request

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/datascraperes~instagram-reels-discovery-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"countryCode":"ES","resultsLimit":50,"concurrency":0,"maxRetries":3}'
```

The run response contains `defaultDatasetId`. Use it to retrieve the results:

```text
https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json
```

Do not expose your Apify token in public code, browser-side applications, shared screenshots, or public URLs.

### Scheduling and integrations

You can use standard Apify features to automate recurring discovery:

- **Schedules:** run daily, weekly, or at another interval.
- **Webhooks:** notify another service when a run succeeds or fails.
- **Tasks:** save reusable input configurations.
- **API clients:** integrate with Python, JavaScript, or direct HTTP requests.
- **Automation platforms:** connect through tools such as Make, Zapier, n8n, Google Sheets, or other Apify integrations.

Every run is an independent discovery snapshot. Instagram's public selection can change between runs, so scheduled datasets are useful for observing change over time.

### Understanding result counts

#### Why can the Actor return fewer results than requested?

`resultsLimit` is the maximum number of unique rows. A run can finish below that limit when:

- Instagram repeatedly returns Reels that are already in the dataset.
- The current public discovery pool is limited.
- Some returned objects lack the minimum fields required for a usable result.
- Instagram keeps rejecting requests after all retries.
- Your Apify spending limit is reached.

Only successfully delivered unique rows are charged.

#### Why can two runs return different Reels?

Instagram can vary public discovery content by time, region, availability, recommendation randomness, and platform experiments. Two runs from the same country can therefore return different Reels. Use `discoveryCountry` to keep the requested market attached to each row.

#### Why do engagement metrics differ between runs?

Likes, comments, views, and plays can change continuously. Instagram can also hide or delay individual metrics.

### Troubleshooting

| Situation | Meaning | Recommended action |
| --- | --- | --- |
| Results include creators from other countries | Country selection controls the request region, not the creator's residence or the Reel's place of creation. | Treat the dataset as a regional recommendation sample, not as verified origin data. |
| Two runs for the same country differ | Instagram's logged-out recommendations are dynamic and partly randomized. | Compare larger samples or recurring snapshots instead of expecting identical rows. |
| A country run cannot initialize | Instagram or the selected regional network was temporarily unavailable. | Retry later, increase `maxRetries`, or use another valid country code. |
| Fewer rows than `resultsLimit` | The requested value is a maximum and the current discovery pool was exhausted or repetitive. | Review `availableResultsExhausted` and `spendingLimitReached` in `SUMMARY`. Run again later if you need a different discovery snapshot. |
| `videoUrl` or `displayUrl` is `null` | Instagram did not expose that media URL for the Reel. | Use the permanent Reel `url`. |
| A direct media URL no longer works | Instagram CDN URLs can expire or be restricted by region. | Re-run the Actor to obtain a fresh URL and retain the permanent Reel page. |
| Likes, views, plays, or comments are `null` | Instagram did not expose that metric. | Treat `null` as unavailable, not as zero. |
| The run stops at an exact spending boundary | The Apify charge limit was reached safely. | Increase the run spending limit only if you want more paid results. |
| A large run takes longer than expected | More sessions and deduplication are required as the requested dataset grows. | Keep automatic concurrency enabled or split the work into scheduled snapshots. |
| The same creator appears multiple times | Larger discovery runs intentionally include additional public Reels from creators surfaced in the feed. | Filter by `owner.id` or `owner.username` when you need one row per creator. |
| A private or deleted Reel is missing | Only publicly accessible content can be returned. | No action is required; inaccessible content is not charged. |

### Limitations

- Country selection controls the discovery request region; it does not verify the creator's residence, nationality, upload location, or filming location.
- The Actor does not accept a profile, hashtag, keyword, city, place, or audio query.
- It does not return a personalized logged-in feed.
- It cannot access private, deleted, restricted, age-gated, or login-only content.
- Results represent a public discovery sample, not a complete index of Instagram Reels.
- `discovered_creator` rows are additional public creator content, not guaranteed trending rankings.
- Engagement metrics depend on what Instagram exposes at collection time.
- Direct video, image, audio, and profile-image URLs can expire.
- Comments are not returned; only the available comment count is included.
- Follower counts and complete profile records are not part of this Actor's output.
- Instagram can change its public pages and available data without notice.

### Choosing the right Instagram Actor

Use this Actor when you want to discover public Reels and creators without supplying a target.

Choose another specialized Actor when you need:

- Reels from one or more specific public profiles
- Posts from specific profiles
- Details for known Instagram profiles
- Comments from a particular post or Reel
- Keyword, hashtag, place, or profile search

This distinction prevents accidental use of a discovery dataset when the real requirement is a complete profile feed or a targeted search.

### Responsible use

This Actor processes publicly accessible Instagram content. You are responsible for ensuring that your collection and use of the data comply with applicable laws, contracts, privacy rules, copyright requirements, and platform policies.

Recommended practices:

- Collect only the fields needed for a legitimate purpose.
- Avoid using public personal data to harm, discriminate against, or profile individuals unfairly.
- Protect exported datasets and Apify API tokens.
- Review retention requirements and delete data that is no longer necessary.
- Respect intellectual-property rights when storing or reusing captions, images, audio, or videos.

The Actor is not affiliated with, endorsed by, or sponsored by Instagram or Meta.

### Frequently asked questions

#### Does the Actor require an Instagram login?

No. You do not provide an Instagram username, password, cookie, or session.

#### Can I scrape Reels from a specific profile?

Not with this Actor. It discovers creators through Instagram's public Reels experience. Use a profile-specific Reels Actor when you already know the username or profile URL.

#### Can I search by keyword or hashtag?

No. There is no search-term input. Instagram controls the public discovery selection.

#### Are the returned Reels guaranteed to be from the selected country?

No. The selected country is the region from which Instagram's public Reels experience is requested. Instagram can recommend international content, and public Reel records usually do not prove where a creator lives or where a video was created. Use `discoveryCountry` as discovery context, not as verified origin data.

#### What does `AUTO` do?

`AUTO` disables fixed-country targeting and produces a broader global sample. Select one of the 50 listed countries when you need comparable regional datasets.

#### Can I target a city?

No. Country-level targeting provides a larger and more reliable discovery pool. The Actor does not claim city-level accuracy.

#### Are all returned Reels trending?

Rows marked `reels_feed` were surfaced directly in Instagram's public discovery experience. Rows marked `discovered_creator` are additional Reels from creators found there and should not be described as an official global trending ranking.

#### Are duplicates charged?

No. The Actor deduplicates by stable Instagram media ID across the complete run. Only unique rows written to the default dataset are charged.

#### What happens if I request 1,000 Reels but receive 700?

You pay for 700 delivered unique rows. Review `SUMMARY` to see whether the available pool, retries, or spending limit stopped the run.

#### Is there a startup fee?

No. The only Actor event is `$0.001` for each unique Reel delivered.

#### Can I download the videos?

When Instagram exposes a direct video URL, it is returned in `videoUrl`. Direct URLs can expire, so keep the permanent `url` field and download media only when you have the right to do so.

#### Are comments included?

No. `commentsCount` may be available, but comment text, authors, and replies are not included.

#### Can I monitor changes over time?

Yes. Create an Apify Task, schedule recurring runs, and store each dataset as a discovery snapshot. Metrics and public selections can change between runs.

#### Can I use the Actor through an API?

Yes. Use the Apify API, Python client, JavaScript client, schedules, tasks, webhooks, or integrations.

#### Does it work with private accounts or private Reels?

No. Only publicly accessible content is supported.

#### Where can I report an issue?

Use the **Issues** tab on the Actor page. Include the run ID, input used, expected result, and a description of the problem. Never include passwords, cookies, API tokens, or other secrets.

# Actor input Schema

## `countryCode` (type: `string`):

Select one of 50 supported discovery countries, or choose Global / unrestricted. This controls where the discovery request is made; it does not prove where each Reel was created.

## `resultsLimit` (type: `integer`):

Maximum number of unique Reels returned. This is also your primary maximum-spend control.

## `concurrency` (type: `integer`):

Parallel Instagram sessions. Keep 0 for automatic scaling from 1 on small runs to 10 on large runs.

## `maxRetries` (type: `integer`):

Attempts per discovery session after temporary network errors or Instagram throttling.

## Actor input object example

```json
{
  "countryCode": "US",
  "resultsLimit": 10,
  "concurrency": 0,
  "maxRetries": 3
}
```

# Actor output Schema

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

Each dataset row is one unique delivered Reel and maps to one reel-result event.

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

Result, billing, request, traffic, duplicate, timing, and completion metrics.

# 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 = {
    "countryCode": "US",
    "resultsLimit": 10,
    "concurrency": 0,
    "maxRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascraperes/instagram-reels-discovery-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 = {
    "countryCode": "US",
    "resultsLimit": 10,
    "concurrency": 0,
    "maxRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("datascraperes/instagram-reels-discovery-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 '{
  "countryCode": "US",
  "resultsLimit": 10,
  "concurrency": 0,
  "maxRetries": 3
}' |
apify call datascraperes/instagram-reels-discovery-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Reels Discovery Scraper - No Login",
        "description": "Discover regional public Instagram Reels and creators without login. Select a country and export captions, engagement, authors, audio, thumbnails, and video URLs. Pay only $1 per 1,000 unique Reels delivered.",
        "version": "1.1",
        "x-build-id": "E6HGzy2hrAF68b69D"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datascraperes~instagram-reels-discovery-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datascraperes-instagram-reels-discovery-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/datascraperes~instagram-reels-discovery-scraper/runs": {
            "post": {
                "operationId": "runs-sync-datascraperes-instagram-reels-discovery-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/datascraperes~instagram-reels-discovery-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-datascraperes-instagram-reels-discovery-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",
                "properties": {
                    "countryCode": {
                        "title": "Discovery country",
                        "enum": [
                            "AUTO",
                            "US",
                            "IN",
                            "BR",
                            "ID",
                            "TR",
                            "JP",
                            "MX",
                            "GB",
                            "DE",
                            "AR",
                            "IT",
                            "FR",
                            "KR",
                            "CO",
                            "ES",
                            "PH",
                            "TH",
                            "EG",
                            "PK",
                            "BD",
                            "SA",
                            "MY",
                            "NG",
                            "MA",
                            "VN",
                            "CA",
                            "AU",
                            "ZA",
                            "AE",
                            "NL",
                            "PL",
                            "RO",
                            "PT",
                            "CL",
                            "PE",
                            "EC",
                            "UY",
                            "GR",
                            "CZ",
                            "SE",
                            "DK",
                            "CH",
                            "AT",
                            "BE",
                            "IE",
                            "UA",
                            "SG",
                            "NZ",
                            "TW",
                            "IL"
                        ],
                        "type": "string",
                        "description": "Select one of 50 supported discovery countries, or choose Global / unrestricted. This controls where the discovery request is made; it does not prove where each Reel was created.",
                        "default": "US"
                    },
                    "resultsLimit": {
                        "title": "Maximum Reels",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of unique Reels returned. This is also your primary maximum-spend control.",
                        "default": 100
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 0,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Parallel Instagram sessions. Keep 0 for automatic scaling from 1 on small runs to 10 on large runs.",
                        "default": 0
                    },
                    "maxRetries": {
                        "title": "Maximum request attempts",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Attempts per discovery session after temporary network errors or Instagram throttling.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```