# Instagram Reels Scraper for Public Profiles (`datascraperes/instagram-public-reels-scraper`) Actor

Scrape Instagram Reels from public profiles in bulk without login. Export captions, views, likes, comments, hashtags, audio, timestamps, and video URLs. Pay only $1 per 1,000 unique Reels delivered.

- **URL**: https://apify.com/datascraperes/instagram-public-reels-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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/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 Scraper for Public Profiles

> **Unofficial community Actor.** This Actor is not affiliated with, endorsed by, or sponsored by Instagram or Meta.

Collect Instagram Reels from one or many **public profiles** without providing an Instagram account, cookies, or login credentials. Enter usernames, `@handles`, or complete profile URLs and receive one clean dataset row per unique Reel.

Use this Instagram Reels scraper to export captions, hashtags, mentions, publication dates, likes, comments, views, plays, video duration, audio details, owner information, thumbnails, and temporary video URLs. Results can be downloaded as JSON, CSV, Excel, XML, or another Apify dataset format.

### What can this Instagram Reels scraper do?

- Scrape the Reels tab of known public Instagram profiles.
- Process a single creator or a list of up to 10,000 profile inputs.
- Collect up to 10,000 Reels per profile and 100,000 Reels per run.
- Return unique Reels only, even when a profile is submitted more than once.
- Include pinned Reels or exclude them from the results.
- Limit the total number of results to control the maximum possible Actor charge.
- Run manually, on a schedule, through the API, or from an Apify integration.

This Actor is designed specifically for **Reels belonging to known public profiles**. It does not search by hashtag or keyword, accept individual Reel URLs, scrape comments or their authors, download files into storage, or transcribe audio.

### Common use cases

- Monitor the Reel activity of creators, brands, or competitors.
- Build social media performance and engagement reports.
- Research captions, hashtags, mentions, sounds, and publishing patterns.
- Create datasets for content discovery or market research.
- Track new public Reels with scheduled recurring runs.
- Send Reel data to Google Sheets, a database, a webhook, or an automation workflow.

### How to scrape Reels from an Instagram profile

1. Open the Actor's **Input** tab.
2. Add one or more public Instagram usernames, `@handles`, or profile URLs.
3. Set **Maximum total Reels** and **Maximum Reels per profile**.
4. Leave **Profile concurrency** at `0` unless you need a specific value.
5. Click **Start**.
6. Open the **Dataset** tab to preview or export the Reels.

For a quick test, use this input:

```json
{
  "profiles": ["nasa"],
  "resultsLimit": 5,
  "maxReelsPerProfile": 5
}
````

### Pricing

The Actor uses pay-per-event pricing and costs **$1 per 1,000 unique Reels** delivered, which is **$0.001 per Reel**.

| Unique Reels delivered | Actor charge |
| ---: | ---: |
| 1 | $0.001 |
| 20 | $0.020 |
| 50 | $0.050 |
| 1,000 | $1.000 |

You are charged for the results actually delivered, not for the number requested:

- If you request 50 Reels and the public profile exposes 50, the Actor delivers 50 and charges `$0.050`.
- If you request 50 Reels but the public profile exposes only 20, the Actor delivers 20 and charges `$0.020`.
- If a profile is private, unavailable, or has no accessible Reels, it produces no Reel charge.

The billable event is `reel-result`. Each event represents one unique Reel successfully written to the default dataset. Invalid inputs, duplicate profile inputs, duplicate Reels, filtered pinned Reels, unavailable profiles, and failed requests are not charged.

`resultsLimit` is the simplest way to control the maximum possible Actor charge. For example, a limit of `200` means the Actor can deliver at most 200 billable Reels, for a maximum Actor charge of `$0.200`.

### Input

#### Input fields

| Field | Type | Default | Allowed values | Description |
| --- | --- | ---: | --- | --- |
| `profiles` | array | required | 1–10,000 items | Instagram usernames, `@handles`, or complete public profile URLs. |
| `resultsLimit` | integer | `1000` | 1–100,000 | Maximum number of unique Reels returned across the entire run. |
| `maxReelsPerProfile` | integer | `100` | 1–10,000 | Maximum number of unique Reels returned from each profile. |
| `skipPinnedReels` | boolean | `false` | `true` or `false` | When enabled, Reels pinned in the profile's Reels tab are excluded and not charged. |
| `concurrency` | integer | `0` | 0–5 | Number of profiles processed at the same time. `0` selects a suitable value automatically. |
| `maxRetries` | integer | `3` | 1–5 | Number of attempts allowed when Instagram temporarily rejects or interrupts a request. |

#### Accepted profile formats

These values all identify public Instagram profiles:

```json
{
  "profiles": [
    "nasa",
    "@natgeo",
    "https://www.instagram.com/instagram/"
  ]
}
```

#### Example: request up to 50 Reels from one profile

```json
{
  "profiles": ["nasa"],
  "resultsLimit": 50,
  "maxReelsPerProfile": 50,
  "skipPinnedReels": false,
  "concurrency": 0,
  "maxRetries": 3
}
```

This input can return and charge for at most 50 Reels. If only 20 are publicly available, the output contains 20 rows and the Actor charge is `$0.020`.

#### Example: collect all publicly exposed Reels from one profile

```json
{
  "profiles": ["nasa"],
  "resultsLimit": 10000,
  "maxReelsPerProfile": 10000,
  "skipPinnedReels": false
}
```

The Actor continues until Instagram exposes no more Reels or one of the limits is reached. “All” therefore means all Reels that Instagram makes publicly accessible to the Actor at run time, up to the supported limit of 10,000 Reels per profile.

#### Example: scrape several profiles with a global limit

```json
{
  "profiles": [
    "nasa",
    "natgeo",
    "https://www.instagram.com/instagram/"
  ],
  "resultsLimit": 120,
  "maxReelsPerProfile": 50,
  "skipPinnedReels": true,
  "concurrency": 0
}
```

The Actor can return up to 50 Reels from any one profile, but never more than 120 Reels in total. The run stops when the global limit is reached or all submitted profiles have been processed.

#### How the two result limits work together

- `maxReelsPerProfile` limits each profile separately.
- `resultsLimit` limits the combined output from all profiles.
- The first limit reached determines when collection stops.
- Limits are maximums, not guaranteed result counts. A profile may expose fewer Reels.

### Output

Each default dataset row represents one unique Instagram Reel.

#### Available data

| Data group | Fields |
| --- | --- |
| Reel identity | `id`, `shortCode`, `url`, `type`, `productType` |
| Content | `caption`, `hashtags`, `mentions`, `accessibilityCaption` |
| Publishing and source | `timestamp`, `sourceUsername`, `sourceProfileId`, `sourceProfileUrl`, `scrapedAt` |
| Engagement | `likesCount`, `commentsCount`, `videoViewsCount`, `videoPlaysCount` |
| Media | `displayUrl`, `videoUrl`, `width`, `height`, `videoDurationSeconds`, `hasAudio` |
| Context | `isPinned`, `isPaidPartnership`, `location`, `coauthors`, `taggedUsers` |
| Owner and audio | `owner`, `audio` |

#### Example dataset item

```json
{
  "schemaVersion": 1,
  "id": "3889868956217334394",
  "shortCode": "DX7lzTOJ1p6",
  "url": "https://www.instagram.com/reel/DX7lzTOJ1p6/",
  "type": "reel",
  "productType": "clips",
  "caption": "A public Reel caption #space @nasa",
  "hashtags": ["space"],
  "mentions": ["nasa"],
  "timestamp": "2026-04-19T04:10:21+00:00",
  "displayUrl": "https://scontent.example/image.jpg",
  "videoUrl": "https://scontent.example/video.mp4",
  "width": 1080,
  "height": 1920,
  "likesCount": 1200,
  "commentsCount": 34,
  "videoViewsCount": 25000,
  "videoPlaysCount": 27000,
  "videoDurationSeconds": 18.4,
  "hasAudio": true,
  "isPaidPartnership": false,
  "isPinned": false,
  "accessibilityCaption": null,
  "owner": {
    "id": "528817151",
    "username": "nasa",
    "fullName": "NASA",
    "isVerified": true,
    "isPrivate": false,
    "profilePicUrl": "https://scontent.example/profile.jpg"
  },
  "location": null,
  "coauthors": [],
  "taggedUsers": [],
  "audio": {
    "id": "123",
    "title": "Original audio",
    "artist": "nasa",
    "isOriginalAudio": true
  },
  "sourceUsername": "nasa",
  "sourceProfileId": "528817151",
  "sourceProfileUrl": "https://www.instagram.com/nasa/",
  "scrapedAt": "2026-07-22T18:00:00+00:00"
}
```

Some fields can be `null` when Instagram does not expose them for a particular Reel. Counts represent the public values available at the time of the run and may change later.

#### Additional run records

The run output also links to two records in the default key-value store:

- `SUMMARY` contains result totals, charge information, applied limits, status totals, and completion time.
- `PROFILE_REPORT` contains one status row for every submitted input, including invalid, duplicate, private, unavailable, and completed profiles. These status rows are not Reel results and are not charged.

### Exporting results

Open the run's **Dataset** tab to preview the results. You can then:

- Download JSON, JSONL, CSV, Excel, XML, or another available dataset format.
- Select only the fields required by your workflow.
- Access the dataset through its API endpoint.
- Connect the output to another Apify Actor or an external automation.

The `displayUrl`, `videoUrl`, and profile image URLs are temporary Instagram CDN links. Download media promptly if you need to preserve it; the Actor returns the URLs but does not archive the files.

### API examples

Use the Actor ID `datascraperes/instagram-public-reels-scraper` with your Apify API token.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("datascraperes/instagram-public-reels-scraper").call(
    run_input={
        "profiles": ["nasa", "natgeo"],
        "resultsLimit": 20,
        "maxReelsPerProfile": 10,
        "skipPinnedReels": False,
    }
)

for reel in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(reel["url"], reel.get("videoViewsCount"))
```

#### JavaScript

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

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

const run = await client.actor('datascraperes/instagram-public-reels-scraper').call({
    profiles: ['nasa', 'natgeo'],
    resultsLimit: 20,
    maxReelsPerProfile: 10,
    skipPinnedReels: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const reel of items) {
    console.log(reel.url, reel.videoViewsCount);
}
```

Never place your Apify API token in public code or shared input.

### Automating recurring Reel collection

Apify lets you reuse a saved input as a task, run it on a schedule, and react to run events with webhooks. Typical workflows include:

- Schedule the Actor daily or weekly to collect recent public Reels.
- Send completed dataset information to a webhook.
- Connect runs to Make, Zapier, n8n, Google Sheets, Slack, or other supported integrations.
- Start runs from your own application with the Apify API client.

Each scheduled run creates a new dataset. Use the Reel `id` or `shortCode` in your destination system if you need to identify items already collected by an earlier run.

### Limits and important notes

- Only publicly accessible Instagram profiles and Reels are supported.
- A run accepts up to 10,000 profile inputs.
- The maximum total output is 100,000 unique Reels per run.
- The maximum output from one profile is 10,000 unique Reels.
- Duplicate inputs and duplicate Reels do not create duplicate dataset rows or charges.
- Instagram may expose fewer Reels than are visible to a logged-in user.
- Public fields and engagement metrics depend on what Instagram exposes at run time.
- Temporary media URLs can expire after the run.
- The Actor does not bypass private profiles or access-controlled content.

### Frequently asked questions

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

Set both `resultsLimit` and `maxReelsPerProfile` to `10000` for one profile. The Actor collects until Instagram exposes no more Reels or the 10,000-per-profile limit is reached. It cannot guarantee access to content Instagram does not expose publicly.

#### What happens if I request 50 Reels but the profile only has 20?

You receive 20 dataset rows and are charged for 20 Reels: `$0.020`. The remaining 30 requested results are not charged.

#### Does it require an Instagram login, cookies, or password?

No. You only provide public profile usernames or URLs.

#### Can it scrape private profiles?

No. Private profiles and access-controlled content are skipped. They do not generate Reel charges.

#### Can I submit the same profile more than once?

Yes, but duplicate profile inputs are processed only once. The duplicate is listed in `PROFILE_REPORT` and is not charged.

#### Can it scrape a list of profiles?

Yes. Submit up to 10,000 inputs and use the global and per-profile limits to control how the available result capacity is distributed.

#### Can it scrape an individual Reel URL?

No. This Actor accepts profile usernames and profile URLs, then collects Reels belonging to those profiles.

#### Does it scrape Reel comments?

No. `commentsCount` is the public count shown for the Reel; individual comments and comment authors are not included.

#### Why is a field missing or `null`?

Instagram does not expose every field for every Reel. For example, view counts, location, audio metadata, accessibility text, or direct media URLs may be unavailable.

#### Does it download the videos?

No. The dataset can include a temporary direct `videoUrl` when Instagram exposes one. Save the file promptly if you need a permanent copy and make sure your use is legally permitted.

#### How do I avoid collecting pinned Reels?

Set `skipPinnedReels` to `true`. Excluded pinned Reels are not written to the dataset and are not charged.

#### Why did a run return no results?

Check `PROFILE_REPORT` for each input's status. Common causes are an invalid username, a private or unavailable profile, a profile with no publicly exposed Reels, or a temporary restriction from Instagram. You can retry temporary failures without being charged for failed requests.

### Responsible use

Only collect data you are legally permitted to use. Follow applicable privacy, copyright, data protection, and platform rules. Do not use the Actor to access private content, impersonate people, harass users, or create unlawful datasets.

### Support

If a valid public profile consistently produces an unexpected result, open the Actor's **Issues** tab and include:

- The Apify run ID.
- A small example of the profile input and limits used.
- The expected and actual result counts.
- Any status or error shown in `PROFILE_REPORT`.

Do not include API tokens, passwords, cookies, or other credentials in a support request.

# Actor input Schema

## `profiles` (type: `array`):

Usernames, @handles, or complete public Instagram profile URLs. Duplicate profiles are skipped without fetching or charging them twice.

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

Maximum number of unique Reels returned across the run. Use this as the primary maximum-spend control.

## `maxReelsPerProfile` (type: `integer`):

Maximum unique Reels returned from each profile. Pagination stops independently for every profile.

## `skipPinnedReels` (type: `boolean`):

Exclude Reels pinned in the profile's Reels tab. Excluded rows are not charged.

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

Profiles processed in parallel. Keep 0 for automatic scaling: 1 for small runs and up to 5 for large inputs.

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

Maximum isolated attempts after temporary throttling, server errors, or connection failures.

## Actor input object example

```json
{
  "profiles": [
    "nasa"
  ],
  "resultsLimit": 5,
  "maxReelsPerProfile": 5,
  "skipPinnedReels": false,
  "concurrency": 0,
  "maxRetries": 3
}
```

# Actor output Schema

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

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

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

Delivered-Reel, billing, duplicate, traffic, limit, status, duration, and completion totals.

## `profileReport` (type: `string`):

A free status record for every submitted profile, including invalid, duplicate, unavailable, and completed inputs.

# 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 = {
    "profiles": [
        "nasa"
    ],
    "resultsLimit": 5,
    "maxReelsPerProfile": 5,
    "skipPinnedReels": false,
    "concurrency": 0,
    "maxRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascraperes/instagram-public-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 = {
    "profiles": ["nasa"],
    "resultsLimit": 5,
    "maxReelsPerProfile": 5,
    "skipPinnedReels": False,
    "concurrency": 0,
    "maxRetries": 3,
}

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

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

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

```

## CLI example

```bash
echo '{
  "profiles": [
    "nasa"
  ],
  "resultsLimit": 5,
  "maxReelsPerProfile": 5,
  "skipPinnedReels": false,
  "concurrency": 0,
  "maxRetries": 3
}' |
apify call datascraperes/instagram-public-reels-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Reels Scraper for Public Profiles",
        "description": "Scrape Instagram Reels from public profiles in bulk without login. Export captions, views, likes, comments, hashtags, audio, timestamps, and video URLs. Pay only $1 per 1,000 unique Reels delivered.",
        "version": "1.0",
        "x-build-id": "pKtIFdl2UIWEZWTQD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datascraperes~instagram-public-reels-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datascraperes-instagram-public-reels-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/datascraperes~instagram-public-reels-scraper/runs": {
            "post": {
                "operationId": "runs-sync-datascraperes-instagram-public-reels-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/datascraperes~instagram-public-reels-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-datascraperes-instagram-public-reels-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "profiles"
                ],
                "properties": {
                    "profiles": {
                        "title": "Instagram profiles",
                        "minItems": 1,
                        "maxItems": 10000,
                        "type": "array",
                        "description": "Usernames, @handles, or complete public Instagram profile URLs. Duplicate profiles are skipped without fetching or charging them twice.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "resultsLimit": {
                        "title": "Maximum total Reels",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of unique Reels returned across the run. Use this as the primary maximum-spend control.",
                        "default": 1000
                    },
                    "maxReelsPerProfile": {
                        "title": "Maximum Reels per profile",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum unique Reels returned from each profile. Pagination stops independently for every profile.",
                        "default": 100
                    },
                    "skipPinnedReels": {
                        "title": "Skip pinned Reels",
                        "type": "boolean",
                        "description": "Exclude Reels pinned in the profile's Reels tab. Excluded rows are not charged.",
                        "default": false
                    },
                    "concurrency": {
                        "title": "Profile concurrency",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Profiles processed in parallel. Keep 0 for automatic scaling: 1 for small runs and up to 5 for large inputs.",
                        "default": 0
                    },
                    "maxRetries": {
                        "title": "Maximum request attempts",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Maximum isolated attempts after temporary throttling, server errors, or connection failures.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
