# Ultra FAST Instagram Profile Scraper (`rover-omniscraper/instagram-profile-scraper`) Actor

The fastest Instagram profile scraper on Apify. Extract followers, bio, business info, posts & more via Instagram's internal API — no login, no browser. Concurrent scraping, rotating proxies & 60+ user agents. Structured JSON in seconds.

- **URL**: https://apify.com/rover-omniscraper/instagram-profile-scraper.md
- **Developed by:** [Rover Omniscraper](https://apify.com/rover-omniscraper) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 6 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 Profile Scraper � Apify Actor

**Extract full Instagram public profile data at scale � followers, bio, business info, recent posts, and more � in seconds.**

The Instagram Profile Scraper is a production-ready [Apify](https://apify.com) actor that retrieves comprehensive public profile data directly from Instagram's internal API. No browser required, no login required � just fast, reliable, structured JSON output.

Built for marketers, researchers, data analysts, agencies, and developers who need accurate Instagram profile intelligence programmatically and at scale.

---

### Table of Contents

- [What Does This Actor Do?](#what-does-this-actor-do)
- [Why Use This Actor?](#why-use-this-actor)
- [Features](#features)
- [Use Cases](#use-cases)
- [Input Configuration](#input-configuration)
- [Proxy Modes](#proxy-modes)
- [Example Inputs](#example-inputs)
- [Output Data](#output-data)
- [Example Output](#example-output)
- [Performance](#performance)
- [Anti-Detection & Reliability](#anti-detection--reliability)
- [Limitations](#limitations)
- [Local Development](#local-development)
- [License](#license)

---

### What Does This Actor Do?

This actor scrapes **public Instagram profiles** by username using Instagram's `web_profile_info` API endpoint � the same endpoint the Instagram website uses internally. For each username you provide, it returns a complete, structured JSON object containing every piece of publicly available profile data.

Scraped data includes profile statistics, biography, profile images, business contact details, account flags (verified, private, business), and the user's most recent posts � all in one request per profile.

---

### Why Use This Actor?

- **No Instagram account needed** � works entirely without authentication
- **No browser automation** � lightweight HTTP requests, not Puppeteer or Playwright
- **Concurrent scraping** � scrape multiple profiles simultaneously, not one at a time
- **Full data payload** � every field Instagram exposes publicly, including raw data for advanced parsing
- **Three proxy modes** � works with Apify's built-in proxies or your own residential proxies
- **Production-hardened** � automatic retries, exponential backoff, CSRF token management, and rotating user agents

---

### Features

- **Multi-profile scraping** � Provide a list of usernames and scrape them all in one run
- **Concurrent execution** � Configurable concurrency (up to 20 simultaneous requests) for maximum speed
- **Three proxy modes** � Apify built-in proxy, residential rotating proxy, or manual residential proxy rotation
- **60+ rotating user agents** � Chrome, Firefox, Safari, Edge, and Opera across Windows, macOS, Linux, Android, and iOS
- **Matching `sec-ch-ua` headers** � Chromium-based user agents include correct client hint headers to pass bot detection
- **TLS fingerprint spoofing** � Uses `got-scraping` which mimics real browser TLS fingerprints
- **CSRF token acquisition** � Fetches a real CSRF token from Instagram before each profile request
- **Automatic retries with exponential backoff** � Handles rate limiting (429), access denied (401/403), and transient network errors
- **Partial results on failure** � Results are pushed to the dataset immediately; partial runs are never lost
- **Full raw data output** � Includes the complete unprocessed API response for custom downstream parsing

---

### Use Cases

| Use Case | Description |
|---|---|
| **Influencer Research** | Verify follower counts, engagement quality, bio, and niche for influencer marketing |
| **Competitor Analysis** | Monitor competitors' follower growth, posting frequency, and content strategy |
| **Lead Generation** | Extract business email, phone, and category from brand and creator profiles |
| **Market Research** | Analyze verified accounts, business density, and audience sizes in any niche |
| **Brand Monitoring** | Track branded account stats, bio changes, or profile picture updates over time |
| **Academic Research** | Collect public social media data for studies, papers, and social network analysis |
| **Data Enrichment** | Append Instagram profile data to your CRM, analytics platform, or database |
| **Journalism & OSINT** | Verify public figures' accounts, follower counts, and publicly stated information |

---

### Input Configuration

Configure the actor using the following input fields.

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `usernames` | `string[]` | ? Yes | � | List of Instagram usernames to scrape. The `@` prefix is optional and will be stripped automatically. |
| `proxyMode` | `string` | No | `"apify"` | Proxy strategy to use. See [Proxy Modes](#proxy-modes). Options: `apify`, `residential_rotating`, `residential_manual`, `none`. |
| `apifyProxyGroups` | `string[]` | No | `["RESIDENTIAL"]` | Apify proxy groups to use (e.g. `RESIDENTIAL`, `GOOGLE_SERP`). Only applies when `proxyMode` is `apify`. |
| `apifyProxyCountry` | `string` | No | `"US"` | Two-letter country code for Apify proxy geolocation (e.g. `US`, `GB`, `DE`). Only applies when `proxyMode` is `apify`. |
| `residentialRotatingProxy` | `string` | No | � | A single proxy URL that auto-rotates IPs on each request (e.g. from Bright Data, Oxylabs, Smartproxy). Format: `http://user:pass@host:port`. Only applies when `proxyMode` is `residential_rotating`. |
| `residentialProxies` | `string[]` | No | � | A list of proxy URLs. The actor rotates between them in round-robin order. Only applies when `proxyMode` is `residential_manual`. |
| `maxRetries` | `integer` | No | `3` | Maximum number of retry attempts per username if a request fails. Range: 0�10. |
| `delayBetweenRequests` | `integer` | No | `500` | Maximum random jitter delay (in ms) added before each concurrent request. Helps avoid rate limiting. Set to `0` for no delay. Range: 0�30000. |
| `concurrency` | `integer` | No | `5` | Number of profiles to scrape simultaneously. Higher values are faster but more likely to trigger rate limits without proxies. Range: 1�20. |

---

### Proxy Modes

Instagram aggressively rate-limits and blocks scrapers operating from datacenter IPs. Using a quality residential proxy is strongly recommended for any run beyond a handful of profiles.

#### `apify` (Recommended)
Uses [Apify Proxy](https://docs.apify.com/platform/proxy) � Apify's built-in proxy infrastructure with residential and datacenter pools and optional country targeting. This is the easiest option when running on the Apify platform.

#### `residential_rotating`
Provide a single proxy endpoint from a third-party provider (Bright Data, Oxylabs, Smartproxy, etc.) that automatically rotates the exit IP on each connection. Set it in `residentialRotatingProxy`.

#### `residential_manual`
Provide a list of proxy URLs in `residentialProxies`. The actor rotates through them in round-robin order. If one fails, it moves to the next automatically.

#### `none`
Makes direct requests without any proxy. **Not recommended for production** � Instagram will quickly rate-limit datacenter IPs. Use only for local development and testing.

---

### Example Inputs

#### Basic � Apify Proxy (Recommended)

```json
{
    "usernames": ["cristiano", "instagram", "therock", "natgeo", "nasa"],
    "proxyMode": "apify",
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US",
    "maxRetries": 3,
    "concurrency": 5
}
````

#### Residential Rotating Proxy

```json
{
    "usernames": ["nike", "apple", "google"],
    "proxyMode": "residential_rotating",
    "residentialRotatingProxy": "http://user:pass@proxy.provider.com:8080",
    "maxRetries": 3,
    "concurrency": 3
}
```

#### Manual Proxy Rotation

```json
{
    "usernames": ["spotify", "netflix", "microsoft"],
    "proxyMode": "residential_manual",
    "residentialProxies": [
        "http://user:pass@proxy1.provider.com:8080",
        "http://user:pass@proxy2.provider.com:8080",
        "http://user:pass@proxy3.provider.com:8080"
    ],
    "maxRetries": 3,
    "concurrency": 3
}
```

***

### Output Data

Each scraped profile produces one JSON record in the Apify dataset. Output is organized into the following sections:

#### Metadata

- `scrapedAt` � ISO 8601 timestamp of when the profile was scraped
- `status` � `success`, `not_found`, or `failed`

#### Basic Info

- `username` � Instagram handle
- `fullName` � Display name
- `userId` � Numeric Instagram user ID
- `fbid` � Connected Facebook ID (if any)

#### Profile Details

- `biography` � Profile bio text
- `biographyWithEntities` � Bio with hashtag and mention entity metadata
- `bioLinks` � Array of links in bio (title, URL, link type)
- `externalUrl` � Primary external URL shown on profile
- `pronouns` � Pronouns (if set)
- `category` / `categoryEnum` � Account category (e.g. Musician, Brand, Athlete)

#### Profile Images

- `profilePicUrl` � Standard-resolution profile picture URL
- `profilePicUrlHD` � High-resolution profile picture URL

#### Account Statistics

- `followers` � Total follower count
- `following` � Total following count
- `postsCount` � Number of feed posts
- `igtvVideos` � Number of IGTV videos
- `clipVideos` � Highlight reel count

#### Account Flags

- `isVerified` � Blue checkmark status
- `isPrivate` � Whether the account is set to private
- `isBusinessAccount` � Business account flag
- `isProfessionalAccount` � Creator or professional account flag
- `isJoinedRecently` � Recently created account indicator
- `hasGuides` � Has published Instagram Guides
- `hasChannel` � Has an Instagram Broadcast Channel
- `hasClips` � Has Reels content

#### Business Information *(when publicly available)*

- `businessContactMethod` � Preferred contact method
- `businessEmail` � Public business email address
- `businessPhoneNumber` � Public business phone number
- `businessCategoryName` � Business category label
- `businessAddressJson` � Structured address (city, zip code, country code)

#### Social Graph

- `mutualFollowersCount` � Number of mutual followers
- `mutualFollowers` � Array of mutual follower usernames

#### Recent Posts *(up to 12)*

Each post entry includes:

- `id`, `shortcode`, `postUrl`
- `type` � `GraphImage`, `GraphVideo`, or `GraphSidecar`
- `caption` � Post caption text
- `likes`, `comments` � Engagement counts
- `timestamp`, `date` � Posted at (Unix timestamp and ISO format)
- `displayUrl`, `thumbnailUrl` � Media URLs
- `isVideo`, `videoViewCount` � Video-specific metadata
- `dimensions` � Media width and height in pixels
- `location` � Tagged location name
- `accessibilityCaption` � Auto-generated image description

#### Pagination

- `hasMorePosts` � Whether the profile has more posts beyond the 12 returned
- `endCursor` � Cursor for paginating additional posts

#### Raw Data

- `moreUserData` — The complete, unprocessed user object from Instagram's API. Useful for extracting fields not yet explicitly mapped by the actor.

***

### Example Output

```json
{
    "scrapedAt": "2026-04-09T12:00:00.000Z",
    "status": "success",
    "username": "instagram",
    "fullName": "Instagram",
    "userId": "25025320",
    "biography": "Discover what's new on Instagram ???",
    "followers": 700938922,
    "following": 235,
    "postsCount": 8394,
    "isVerified": true,
    "isPrivate": false,
    "isBusinessAccount": true,
    "profilePicUrl": "https://...",
    "profilePicUrlHD": "https://...",
    "bioLinks": [],
    "recentPostsCount": 12,
    "recentPosts": [ "..." ],
    "hasMorePosts": true,
    "endCursor": "QVFDd..."
}
```

***

### Performance

Benchmarks using `concurrency: 5` and no proxy (direct connection):

| Profiles | Approximate Time |
|---|---|
| 1 | ~1.5 seconds |
| 5 | ~3�4 seconds |
| 10 | ~7�9 seconds |
| 50 | ~35�50 seconds |

With high-quality residential proxies and `concurrency: 10�15`, throughput improves significantly. For large-scale runs (hundreds of profiles), Apify residential proxies with `concurrency: 10` is the recommended configuration.

***

### Anti-Detection & Reliability

Instagram actively detects and blocks automated scraping. This actor employs multiple layers of anti-detection to maximize reliability:

| Technique | Description |
|---|---|
| **User Agent Rotation** | 60+ real browser user agents selected randomly per request across Chrome, Firefox, Safari, Edge, and Opera on all major platforms |
| **Client Hint Headers** | `sec-ch-ua`, `sec-ch-ua-mobile`, `sec-ch-ua-platform`, and `sec-ch-ua-full-version-list` headers generated to precisely match the selected user agent |
| **TLS Fingerprint Spoofing** | HTTP requests use `got-scraping` which replicates the TLS handshake of a real browser, not a Node.js HTTP client |
| **CSRF Token Acquisition** | A real `csrftoken` cookie is obtained from Instagram's homepage before each API call |
| **Realistic Header Sets** | Full browser session headers including `sec-fetch-*`, `dnt`, `accept-encoding`, `referer`, `x-ig-app-id`, and randomized web device/session IDs |
| **Exponential Backoff** | On 429 (rate limit) responses, the actor waits an increasing amount of time before retrying |
| **Proxy Rotation** | Each retry uses a fresh proxy session to avoid IP-level bans |

***

### Limitations

- **Private profiles** � Only public profiles can be scraped. Private accounts return a `not_found` result.
- **Posts cap** � Instagram's `web_profile_info` endpoint returns a maximum of 12 recent posts per profile. Deeper post pagination is not supported in this version.
- **Rate limiting** � Instagram rate limits vary by IP reputation. Residential proxies greatly reduce the chance of being blocked.
- **API changes** � Instagram occasionally modifies internal API response structures without notice. If data fields go missing, check for an updated actor version.
- **No Stories or Highlights** � Stories, Highlights, Reels carousels, and live video data are not available from this endpoint.
- **No private data** � This actor only retrieves publicly accessible profile data. No private messages, follower lists, or analytics are collected.

***

### Local Development

**Prerequisites:** Node.js 18+, [Apify CLI](https://docs.apify.com/cli)

**Install dependencies:**

```
npm install
```

**Provide test input** by creating `storage/key_value_stores/default/INPUT.json`:

```json
{
    "usernames": ["instagram"],
    "proxyMode": "none",
    "maxRetries": 1,
    "concurrency": 1
}
```

**Run with Apify CLI** (simulates the full Apify platform environment):

```
apify run
```

**Run directly:**

```
npm start
```

Output is written to `storage/datasets/default/`.

***

### License

ISC � AntiG

# Actor input Schema

## `usernames` (type: `array`):

List of Instagram usernames to scrape (without the @ symbol). Example: \["zaryab", "cristiano", "instagram"]

## `proxyMode` (type: `string`):

Choose how proxies should be used:

- **apify**: Use Apify's built-in proxy infrastructure (recommended)
- **residential\_rotating**: Use a single residential rotating proxy endpoint (auto-rotates IPs)
- **residential\_manual**: Provide multiple residential proxy URLs — the actor will rotate between them
- **none**: No proxy (not recommended, will likely get blocked)

## `apifyProxyGroups` (type: `array`):

Apify proxy groups to use (e.g., RESIDENTIAL, GOOGLE\_SERP). Leave empty for automatic selection. Only used when Proxy Mode is 'Apify Proxy'.

## `apifyProxyCountry` (type: `string`):

Country code for Apify proxy (e.g., US, GB, DE). Only used when Proxy Mode is 'Apify Proxy'.

## `residentialRotatingProxy` (type: `string`):

Single rotating proxy URL that auto-rotates IPs. Format: http://user:pass@host:port or socks5://user:pass@host:port. Only used when Proxy Mode is 'Residential Rotating Proxy'.

## `residentialProxies` (type: `array`):

List of residential proxy URLs. The actor will rotate between them. Format: http://user:pass@host:port. Only used when Proxy Mode is 'Residential Proxies (Manual Rotation)'.

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

Maximum number of retry attempts per username if a request fails.

## `delayBetweenRequests` (type: `integer`):

Max random delay in milliseconds added before each concurrent request. Helps avoid rate limiting. Set to 0 for no delay.

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

Number of usernames to scrape simultaneously. Higher = faster but more likely to trigger rate limits.

## Actor input object example

```json
{
  "usernames": [
    "instagram"
  ],
  "proxyMode": "apify",
  "apifyProxyGroups": [
    "RESIDENTIAL"
  ],
  "apifyProxyCountry": "US",
  "maxRetries": 3,
  "delayBetweenRequests": 500,
  "concurrency": 5
}
```

# 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 = {
    "usernames": [
        "instagram"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("rover-omniscraper/instagram-profile-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 = { "usernames": ["instagram"] }

# Run the Actor and wait for it to finish
run = client.actor("rover-omniscraper/instagram-profile-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 '{
  "usernames": [
    "instagram"
  ]
}' |
apify call rover-omniscraper/instagram-profile-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ultra FAST Instagram Profile Scraper",
        "description": "The fastest Instagram profile scraper on Apify. Extract followers, bio, business info, posts & more via Instagram's internal API — no login, no browser. Concurrent scraping, rotating proxies & 60+ user agents. Structured JSON in seconds.",
        "version": "0.0",
        "x-build-id": "hMVVspPJvYXThG9Kz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rover-omniscraper~instagram-profile-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rover-omniscraper-instagram-profile-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/rover-omniscraper~instagram-profile-scraper/runs": {
            "post": {
                "operationId": "runs-sync-rover-omniscraper-instagram-profile-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/rover-omniscraper~instagram-profile-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-rover-omniscraper-instagram-profile-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": [
                    "usernames"
                ],
                "properties": {
                    "usernames": {
                        "title": "Instagram Usernames",
                        "type": "array",
                        "description": "List of Instagram usernames to scrape (without the @ symbol). Example: [\"zaryab\", \"cristiano\", \"instagram\"]",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyMode": {
                        "title": "Proxy Mode",
                        "enum": [
                            "apify",
                            "residential_rotating",
                            "residential_manual",
                            "none"
                        ],
                        "type": "string",
                        "description": "Choose how proxies should be used:\n- **apify**: Use Apify's built-in proxy infrastructure (recommended)\n- **residential_rotating**: Use a single residential rotating proxy endpoint (auto-rotates IPs)\n- **residential_manual**: Provide multiple residential proxy URLs — the actor will rotate between them\n- **none**: No proxy (not recommended, will likely get blocked)",
                        "default": "apify"
                    },
                    "apifyProxyGroups": {
                        "title": "Apify Proxy Groups",
                        "type": "array",
                        "description": "Apify proxy groups to use (e.g., RESIDENTIAL, GOOGLE_SERP). Leave empty for automatic selection. Only used when Proxy Mode is 'Apify Proxy'.",
                        "default": [
                            "RESIDENTIAL"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "apifyProxyCountry": {
                        "title": "Apify Proxy Country",
                        "type": "string",
                        "description": "Country code for Apify proxy (e.g., US, GB, DE). Only used when Proxy Mode is 'Apify Proxy'.",
                        "default": "US"
                    },
                    "residentialRotatingProxy": {
                        "title": "Residential Rotating Proxy URL",
                        "type": "string",
                        "description": "Single rotating proxy URL that auto-rotates IPs. Format: http://user:pass@host:port or socks5://user:pass@host:port. Only used when Proxy Mode is 'Residential Rotating Proxy'."
                    },
                    "residentialProxies": {
                        "title": "Residential Proxy List",
                        "type": "array",
                        "description": "List of residential proxy URLs. The actor will rotate between them. Format: http://user:pass@host:port. Only used when Proxy Mode is 'Residential Proxies (Manual Rotation)'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxRetries": {
                        "title": "Max Retries Per Username",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum number of retry attempts per username if a request fails.",
                        "default": 3
                    },
                    "delayBetweenRequests": {
                        "title": "Delay Between Requests (ms)",
                        "minimum": 0,
                        "maximum": 30000,
                        "type": "integer",
                        "description": "Max random delay in milliseconds added before each concurrent request. Helps avoid rate limiting. Set to 0 for no delay.",
                        "default": 500
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of usernames to scrape simultaneously. Higher = faster but more likely to trigger rate limits.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
