# iRecommend Product Reviews Scraper (`automation-lab/irecommend-product-reviews-scraper`) Actor

💬 Extract public iRecommend.ru product and service reviews with ratings, authors, dates, media, engagement counts, and stable review IDs.

- **URL**: https://apify.com/automation-lab/irecommend-product-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event + usage

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

## iRecommend Product Reviews Scraper

Collect public product and service reviews from iRecommend.ru as clean, structured data.

Turn review cards into rows with stable IDs, ratings, authors, publication dates, comments, images, and direct links.

Use the data in spreadsheets, dashboards, warehouses, sentiment pipelines, or scheduled reputation monitoring.

- 🇷🇺 Preserves Russian and Cyrillic text exactly
- ⭐ Supports rating filters
- 📅 Supports publication-date filters
- 🔗 Accepts multiple product pages
- 📦 Exports JSON, CSV, Excel, XML, and RSS through Apify
- 🔄 Paginates automatically until your limit is reached

### What does iRecommend Product Reviews Scraper do?

The Actor opens public `irecommend.ru/content/...` product or service pages and extracts one dataset row per review card.

It handles iRecommend's anonymous browser verification flow, follows pagination, and stops at your global review limit.

Every saved row includes:

- the source product page
- stable review, product, and version identifiers
- the direct full-review URL
- title and teaser text
- star rating
- author name, profile, and avatar
- publication date
- comment count
- preview image URLs and total photo count
- an ISO scrape timestamp

No iRecommend account is required.

### Who is it for?

#### Brand and reputation teams

Monitor fresh feedback about a brand, delivery service, cosmetic, appliance, app, or other reviewed product.

#### Ecommerce analysts

Compare rating distributions, review cadence, engagement, and visual-review volume across competing products.

#### Consumer-insights researchers

Build a Russian-language corpus for topic analysis, complaint clustering, qualitative research, or sentiment scoring.

#### Data and automation teams

Schedule recurring runs and send normalized review records into a warehouse, BI tool, webhook, or downstream Actor.

#### Agencies

Create repeatable review-monitoring workflows for multiple clients without copying cards manually.

### Why use this Actor?

Manual review collection is slow and difficult to refresh.

This Actor provides:

- predictable structured fields
- stable numeric IDs for deduplication
- automatic pagination
- multi-page input in one run
- filters that reduce downstream cleanup
- incremental dataset writes
- partial results if a later target page stops responding
- standard Apify exports and integrations

The default input is intentionally small, so you can validate the output before increasing `maxItems`.

### What iRecommend review data can you extract?

| Field | Type | Meaning |
|---|---|---|
| `sourceUrl` | string | Canonical product or service page |
| `reviewId` | integer | Stable iRecommend review ID |
| `productId` | integer | Product entity ID |
| `versionId` | integer | Review version ID exposed by the card |
| `reviewUrl` | string | Direct public review URL |
| `title` | string | Review headline |
| `teaser` | string | Review preview text |
| `rating` | integer | Star rating from 1 to 5 |
| `author` | object | Name, profile URL, and optional avatar |
| `publishedAt` | string | Source date in `DD.MM.YYYY` format |
| `commentsCount` | integer | Visible comment count |
| `imageUrls` | array | Visible review preview images |
| `photosCount` | integer | Total photos reported on the card |
| `scrapedAt` | string | UTC extraction timestamp |

### How to scrape iRecommend product reviews

1. Open an iRecommend product or service page.
2. Copy its `https://irecommend.ru/content/...` URL.
3. Open this Actor's **Input** tab.
4. Add the URL under **Product review pages**.
5. Keep the default maximum for a cheap first run.
6. Optionally choose rating or date filters.
7. Click **Start**.
8. Open the dataset when the run finishes.
9. Export the records in your preferred format.

Add several product pages when you want one combined dataset.

### Input

Example:

```json
{
  "startUrls": [
    {
      "url": "https://irecommend.ru/content/sait-prilozhenie-dostavki-produktov-samokat"
    }
  ],
  "maxItems": 50,
  "minRating": 1,
  "maxRating": 3,
  "dateFrom": "2026-01-01",
  "dateTo": "2026-12-31"
}
````

#### `startUrls`

Required array of public iRecommend product or service review pages.

The Actor accepts request-list objects and plain URL strings through the API.

#### `maxItems`

Maximum reviews saved across all supplied pages.

The default is 10 and the maximum is 10,000.

#### `minRating` and `maxRating`

Optional integer boundaries from 1 through 5.

Use `maxRating: 2` to focus on critical feedback.

Use `minRating: 5` to collect only top-rated reviews.

#### `dateFrom` and `dateTo`

Optional inclusive dates in `YYYY-MM-DD` format.

The source's `DD.MM.YYYY` dates are parsed before filtering.

#### `proxyConfiguration`

Optional Apify Proxy or custom proxy settings.

Direct anonymous browser access is the default and normally completes iRecommend's public verification flow automatically.

### Output example

```json
{
  "sourceUrl": "https://irecommend.ru/content/sait-prilozhenie-dostavki-produktov-samokat",
  "reviewId": 11205258,
  "productId": 5814124,
  "versionId": 19755845,
  "reviewUrl": "https://irecommend.ru/content/samokat-sponsor-moikh-uzhinov-s-indeikoi-i-urodlivogo-kulicha-na-paskhu-dorogo-ili-vygodno",
  "title": "Самокат - спонсор моих ужинов...",
  "teaser": "Я очень люблю вкусную и полезную пищу...",
  "rating": 4,
  "author": {
    "name": "Panna Lisa",
    "url": "https://irecommend.ru/users/panna-lisa",
    "avatar": "https://cdn-irec.r-99.com/sites/default/files/imagecache/60i/pictures/picture-582516-e513c.jpg"
  },
  "publishedAt": "14.07.2026",
  "commentsCount": 12,
  "imageUrls": [
    "https://cdn-irec.r-99.com/sites/default/files/imagecache/200i/user-images/582516/example.jpg"
  ],
  "photosCount": 30,
  "scrapedAt": "2026-07-15T08:00:00.000Z"
}
```

### How pagination and limits work

The first product page contains the first review batch.

Additional batches use iRecommend's ordinary `?page=N` pagination.

The Actor reuses one browser session for each source page and stops when:

- `maxItems` is reached
- no next page exists
- a page produces no new review IDs
- the target fails after bounded waiting

Rating and date filters are applied before records are saved.

### How deduplication works

Review rows are deduplicated by `reviewId` across the complete run.

This avoids duplicate exports when:

- the same product URL is supplied twice
- cards overlap during pagination
- multiple source pages expose the same review

For monitoring across separate runs, deduplicate downstream on `reviewId` or use it as an upsert key.

### How much does it cost to scrape iRecommend reviews?

This Actor uses pay-per-event pricing.

You pay a small run-start fee and a per-review fee only for records saved to the dataset.

Filtered-out cards are not charged as review results.

Apify subscription tiers receive tiered per-result prices; check the live pricing panel for the exact current amount.

A small 10-review test is the best way to estimate the cost of your workflow.

### Review monitoring workflow

For recurring reputation monitoring:

1. Create a task from a working Actor input.
2. Set a suitable `maxItems` limit.
3. Use `dateFrom` for the monitoring window.
4. Schedule the task daily or weekly.
5. Connect the dataset to your destination.
6. Upsert records by `reviewId`.
7. Alert on low ratings or selected Russian keywords.

Remember that a date filter does not change the source's page order; the Actor still reads public cards until it reaches the limit or the end.

### Tips for reliable runs

- Start with one known public product page.
- Use canonical `/content/...` URLs rather than search pages.
- Keep first runs small.
- Increase limits only after inspecting sample records.
- Use multiple source URLs for a combined portfolio export.
- Use stable IDs instead of titles for deduplication.
- Do not block scripts in custom browser infrastructure; the anonymous verification needs JavaScript.
- Add a proxy only when direct routing is unavailable in your environment.

### Integrations

#### Google Sheets

Send dataset rows to a spreadsheet for triage, tagging, and analyst notes.

#### Slack or email alerts

Filter for one- or two-star records and notify a customer-support or reputation channel.

#### Webhooks

Trigger downstream processing when a run succeeds and fetch the dataset through the API.

#### Data warehouses

Load JSON or CSV into BigQuery, Snowflake, PostgreSQL, or another analytics store.

#### Sentiment analysis

Pass `title` and `teaser` to a Russian-language sentiment or topic model.

#### Zapier and Make

Use Apify integrations to move new review records into no-code workflows.

### API usage in JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/irecommend-product-reviews-scraper').call({
  startUrls: [{
    url: 'https://irecommend.ru/content/sait-prilozhenie-dostavki-produktov-samokat',
  }],
  maxItems: 25,
  maxRating: 3,
});

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

### Use with the Apify API in Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/irecommend-product-reviews-scraper').call(run_input={
    'startUrls': [{
        'url': 'https://irecommend.ru/content/sait-prilozhenie-dostavki-produktov-samokat'
    }],
    'maxItems': 25,
    'minRating': 4,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~irecommend-product-reviews-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "startUrls": [{
      "url": "https://irecommend.ru/content/sait-prilozhenie-dostavki-produktov-samokat"
    }],
    "maxItems": 10
  }'
```

Poll the returned run ID, then read its default dataset.

### Use iRecommend reviews with Apify MCP

Connect AI assistants to this Actor through Apify MCP:

`https://mcp.apify.com/?tools=automation-lab/irecommend-product-reviews-scraper`

#### Claude Code setup

Add the Apify MCP server from your terminal:

```bash
claude mcp add --transport http apify 'https://mcp.apify.com/?tools=automation-lab/irecommend-product-reviews-scraper'
```

Authenticate with your Apify token when prompted.

#### Claude Desktop setup

Add this server to the `mcpServers` object in Claude Desktop's configuration:

```json
{
  "mcpServers": {
    "apify-irecommend": {
      "url": "https://mcp.apify.com/?tools=automation-lab/irecommend-product-reviews-scraper"
    }
  }
}
```

#### Cursor setup

Open **Cursor Settings → MCP**, add a remote HTTP server, and use the same Apify MCP URL. The `mcpServers` JSON above can also be adapted to Cursor's MCP configuration.

#### VS Code setup

Open **MCP: Add Server** from the VS Code command palette, choose **HTTP**, and paste the Actor-specific Apify MCP URL.

#### Example prompts

- “Collect the newest 25 reviews from this iRecommend product page.”
- “Find one- and two-star iRecommend reviews and summarize recurring complaints.”
- “Compare rating and comment patterns across these three iRecommend pages.”
- “Export review IDs, authors, ratings, comments, and direct URLs as a CSV-ready table.”

The Actor's structured dataset lets assistants reason over IDs, ratings, dates, and authors without parsing raw HTML.

### Data quality and source behavior

The Actor extracts values shown on public review cards.

`teaser` is a preview, not necessarily the complete review body.

`imageUrls` contains visible preview images, while `photosCount` can be larger.

Comment totals and cards can change between runs as iRecommend updates the site.

The source date remains in `DD.MM.YYYY` format to preserve the displayed value.

### Error handling

An invalid non-iRecommend URL is skipped with a warning.

If one source page fails, records already saved remain available.

If a later pagination page fails, the Actor keeps partial progress and logs the failing URL.

The run fails early when:

- no product URLs are supplied
- `maxItems` is outside the allowed range
- minimum rating is greater than maximum rating

### Legality: is it legal to scrape iRecommend reviews?

This Actor is designed for publicly accessible review cards.

Data-protection, copyright, database-right, and website terms can vary by jurisdiction and use case.

You are responsible for ensuring that your collection, storage, and use have a lawful basis.

Avoid collecting unnecessary personal data, respect applicable retention rules, and do not use the output for harassment, spam, or prohibited profiling.

When in doubt, consult qualified legal counsel.

### FAQ: frequently asked questions

#### Does the Actor require an iRecommend account?

No. It uses the public anonymous review flow.

#### Does it download full review text?

V1 returns the title and teaser exposed on product review cards, plus the direct full-review URL.

#### Can I scrape several products in one run?

Yes. Add multiple entries to `startUrls`; `maxItems` applies globally.

#### Can I collect only negative reviews?

Yes. Set `maxRating` to 1 or 2.

#### Can I collect reviews from a date range?

Yes. Use inclusive `dateFrom` and `dateTo` values.

#### Why did I receive fewer rows than `maxItems`?

Filters may exclude cards, the source may have fewer reviews, or iRecommend may have stopped serving a later page. Check the run log for the exact page outcome.

#### Why is `imageUrls` shorter than `photosCount`?

Cards expose only preview images. `photosCount` reports the review's total visible photo count.

#### Why does the first page briefly return 521?

That can be iRecommend's anonymous JavaScript verification response. The Actor waits for the automatic reload and real review cards.

#### How do I avoid duplicate records between scheduled runs?

Use `reviewId` as your downstream upsert or deduplication key.

### Related scrapers

Explore other public review and product-data tools from Automation Lab:

- [Trustpilot Scraper](https://apify.com/automation-lab/trustpilot-scraper)
- [Google Maps Reviews Scraper](https://apify.com/automation-lab/google-maps-reviews-scraper)
- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper)

Choose the source-specific Actor that matches the website your workflow monitors.

### Support

If a public iRecommend product page stops producing expected review rows:

1. Keep the smallest reproducible input.
2. Note the source URL and run ID.
3. Compare the visible cards with the dataset.
4. Open an Actor issue with those details.

Clear reproduction details help distinguish a changed selector, source outage, or route-specific verification problem.

# Actor input Schema

## `startUrls` (type: `array`):

One or more https://irecommend.ru/content/... pages.

## `maxItems` (type: `integer`):

Global maximum number of review rows saved across all product pages.

## `minRating` (type: `integer`):

Keep reviews at or above this star rating.

## `maxRating` (type: `integer`):

Keep reviews at or below this star rating.

## `dateFrom` (type: `string`):

Keep reviews published on or after this date (YYYY-MM-DD).

## `dateTo` (type: `string`):

Keep reviews published on or before this date (YYYY-MM-DD).

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

Optional Apify Proxy or custom proxy settings.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://irecommend.ru/content/sait-prilozhenie-dostavki-produktov-samokat"
    }
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://irecommend.ru/content/sait-prilozhenie-dostavki-produktov-samokat"
        }
    ],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/irecommend-product-reviews-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 = {
    "startUrls": [{ "url": "https://irecommend.ru/content/sait-prilozhenie-dostavki-produktov-samokat" }],
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/irecommend-product-reviews-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 '{
  "startUrls": [
    {
      "url": "https://irecommend.ru/content/sait-prilozhenie-dostavki-produktov-samokat"
    }
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/irecommend-product-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/irecommend-product-reviews-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "iRecommend Product Reviews Scraper",
        "description": "💬 Extract public iRecommend.ru product and service reviews with ratings, authors, dates, media, engagement counts, and stable review IDs.",
        "version": "0.1",
        "x-build-id": "cigkiQw2kZQgBv6ZW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~irecommend-product-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-irecommend-product-reviews-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/automation-lab~irecommend-product-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-irecommend-product-reviews-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/automation-lab~irecommend-product-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-irecommend-product-reviews-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Product review pages",
                        "type": "array",
                        "description": "One or more https://irecommend.ru/content/... pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum reviews",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Global maximum number of review rows saved across all product pages.",
                        "default": 10
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Keep reviews at or above this star rating."
                    },
                    "maxRating": {
                        "title": "Maximum rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Keep reviews at or below this star rating."
                    },
                    "dateFrom": {
                        "title": "Published from",
                        "type": "string",
                        "description": "Keep reviews published on or after this date (YYYY-MM-DD)."
                    },
                    "dateTo": {
                        "title": "Published to",
                        "type": "string",
                        "description": "Keep reviews published on or before this date (YYYY-MM-DD)."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy or custom proxy settings."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```