# Citilink Scraper - Russian Electronics Store Products (`crawlerbros/citilink-scraper`) Actor

Scrape Citilink.ru, one of Russia's largest electronics and appliance retailers. Search products by keyword, browse any category, or fetch full product details - pricing, ratings, specifications, images, and stock status.

- **URL**: https://apify.com/crawlerbros/citilink-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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 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

## Citilink Scraper

Scrape **[Citilink.ru](https://www.citilink.ru)**, one of Russia's largest electronics, computer,
and home-appliance retailers. Search products by keyword, browse any catalog category, pull full
specifications for individual products, or fetch full-text customer reviews — no login, cookies,
or API key required.

### What this actor does

- **Search** — run a free-text keyword search (e.g. `iphone`, `ноутбук`, `телевизор`) and get
  back matching products with price, rating, and availability.
- **Browse a category** — pull every product listed under any Citilink catalog category
  (smartphones, laptops, TVs, appliances, etc.) by slug or URL.
- **Product details** — fetch full specifications, description, price, color variants, variant
  axes (colour/storage/etc.), and images for one or more products by ID or URL.
- **Reviews** — fetch full-text customer reviews (title, body, view count, likes/dislikes) for
  one or more products by ID or URL — distinct from the star-rating opinion summary already
  included in product details.
- **Empty fields are omitted** from every record — a field only appears when Citilink actually
  supplied a value for it.

### Output: per-product (search / byCategory)

- `id` — Citilink product ID
- `name`, `shortName` — Product title
- `slug` — Citilink's URL slug for the product
- `productUrl` — Canonical product page URL
- `isAvailable` — Whether the product is currently purchasable
- `priceCurrent`, `priceOld`, `discountPercent`, `bonusPoints` — Pricing (RUB)
- `categoryId`, `categoryName` — Catalog category
- `brand` — Brand name
- `rating`, `opinionsCount`, `reviewsCount` — Customer feedback
- `properties` — Key specs shown on the listing card (name/value pairs)
- `images`, `imageUrl` — Product photo URLs
- `multiplicity` — Minimum purchasable quantity increment, when above 1
- `accessMode` — Citilink's own visibility/sale mode for the listing
- `earliestDeliveryDate` — Earliest self-pickup/delivery date, if available
- `labels` — Promotional badges (installment plans, bundles, etc.)
- `sourceUrl`, `scrapedAt`, `recordType` — Standard metadata

### Output: per-product (productDetails)

All of the fields above, plus:

- `originalProductId` — Citilink's underlying product ID (differs from `id` for some listings)
- `description` — Full product description (plain text)
- `properties` — Full specification list, each with an optional `measure` (unit)
- `categorySlug`, `categoryPath` — Category slug and full breadcrumb (root → leaf)
- `brandId`, `brandName` — Brand ID and name
- `vendorCode` — Manufacturer/vendor code
- `accessoriesCount`, `discussionsCount`, `documentationsCount`, `servicesCount`, `videosCount` — Per-section content counters
- `colorVariants` — Sibling products in other colors, each with its own `id`, `productUrl`, `color`, `isAvailable`, and `imageUrl`
- `variantGroups` — Every variant axis the product exposes (colour, storage, etc.), each with its sibling-product options — not just colour

Product details also opportunistically include the following, when Citilink's own page loads
them in time:

- `ratingBreakdown` — Star-by-star opinion histogram: `[{stars, count, percentage}, ...]`
- `topReview` — Citilink's own featured customer opinion — `text`, `pros`, `cons`, `rating`, `date`, `authorNickname`, `verifiedPurchase`, `likes`, `dislikes`
- `relatedProducts` — "Bought together" complementary products (same fields as search results)
- `similarProducts` — "Similar products" alternatives (same fields as search results)
- `courierDelivery` — Fastest courier option — `price` (RUB), `eta`, `type`
- `pickupStoresAvailable` — Number of pickup points with stock on the earliest available day

### Output: per-review (mode = `reviews`)

- `productId` — Citilink product ID the review belongs to
- `reviewId` — Citilink's own review ID
- `title` — Review headline
- `content` — Full review body (plain text/markdown as authored, including any embedded image links)
- `viewsCount` — Number of times the review has been viewed
- `createdAt`, `modifiedAt` — Timestamps (`modifiedAt` only present when it differs from `createdAt`)
- `authorSuid` — Author's public site ID
- `authorNickname` — Author's display nickname, if set
- `likes`, `dislikes` — Helpful-vote counts (only present when non-zero)
- `sourceUrl`, `scrapedAt`, `recordType` — Standard metadata

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byCategory` / `productDetails` / `reviews` |
| `searchQuery` | string | `iphone` | Free-text keyword (mode=search) |
| `category` | string | – | Category slug (`smartfony`), catalog path, or full URL (mode=byCategory) |
| `productIds` | array | `[]` | Product IDs or full product URLs (mode=productDetails, reviews) |
| `maxReviewsPerProduct` | int | `20` | Cap on reviews fetched per product ID (1-200, mode=reviews) |
| `sortBy` | string | `relevance` | `relevance` / `priceAsc` / `priceDesc` / `discount` / `rating` / `opinions` / `reviews` (mode=search, byCategory) |
| `minPrice` | int | – | Drop products cheaper than this, RUB (mode=search, byCategory) |
| `maxPrice` | int | – | Drop products more expensive than this, RUB (mode=search, byCategory) |
| `minRating` | number | – | Drop products rated below this, 0-5 scale (mode=search, byCategory) |
| `inStockOnly` | boolean | `false` | Only return purchasable products (mode=search, byCategory) |
| `maxItems` | int | `10` | Hard cap on emitted records (1-500) |
| `proxyConfiguration` | object | AUTO group | Apify proxy — required; the default AUTO (datacenter) group is sufficient |

#### How sorting works

When `sortBy=relevance` (the default), results are returned in Citilink's own order. For any
other `sortBy` value, the actor gathers a wider window of results in relevance order, sorts that
window by the requested key, then truncates to `maxItems`. This means non-relevance sorts reorder
the *fetched* window rather than Citilink's entire catalog — for the most accurate top-N on a very
broad category, narrow the search with a keyword or price filter first.

### Example: search with price and rating filters

```json
{
  "mode": "search",
  "searchQuery": "ноутбук",
  "minPrice": 30000,
  "maxPrice": 100000,
  "minRating": 4,
  "sortBy": "priceAsc",
  "maxItems": 50
}
````

### Example: browse a category in stock only

```json
{
  "mode": "byCategory",
  "category": "smartfony",
  "inStockOnly": true,
  "sortBy": "discount",
  "maxItems": 100
}
```

### Example: fetch full product details

```json
{
  "mode": "productDetails",
  "productIds": [
    "2143346",
    "https://www.citilink.ru/product/televizor-samsung-qe65q80dauxru-65-4k-ultra-hd-3840x2160-2135640/"
  ],
  "maxItems": 10
}
```

### Example: fetch customer reviews

```json
{
  "mode": "reviews",
  "productIds": ["2143346"],
  "maxReviewsPerProduct": 50
}
```

### Use cases

- Track pricing and discounts on specific product categories (e.g. all `smartfony` under
  50,000 RUB).
- Monitor stock availability for a watchlist of products by ID.
- Build a price-comparison feed of Citilink search results for a set of keywords.
- Pull full specifications for a batch of products to enrich your own catalog.
- Analyze full-text customer reviews for a set of products (sentiment, common complaints,
  helpful-vote counts) beyond the star-rating summary.

### Other Russian marketplace actors by CrawlerBros

| Actor | URL |
|---|---|
| Citilink Scraper - Russian Electronics Store Products (this actor) | <https://apify.com/crawlerbros/citilink-scraper> |
| DNS-Shop Scraper | <https://apify.com/crawlerbros/dns-shop-scraper> |
| Eldorado Scraper | <https://apify.com/crawlerbros/eldorado-scraper> |
| ETM Electrical Equipment Scraper | <https://apify.com/crawlerbros/etm-scraper> |
| Holodilnik.ru Scraper | <https://apify.com/crawlerbros/holodilnik-scraper> |
| Lemanapro Scraper | <https://apify.com/crawlerbros/lemanapro-scraper> |
| Magnit Market (mm.ru) Scraper | <https://apify.com/crawlerbros/magnit-market-scraper> |
| Maxidom Scraper | <https://apify.com/crawlerbros/maxidom-scraper> |
| Megamarket.ru Scraper | <https://apify.com/crawlerbros/megamarket-scraper> |
| M.Video Scraper | <https://apify.com/crawlerbros/mvideo-scraper> |
| Onlinetrade.ru Scraper | <https://apify.com/crawlerbros/onlinetrade-scraper> |
| Ozon Scraper - Products, Categories & Search | <https://apify.com/crawlerbros/ozon-scraper> |
| Petrovich Building Materials Scraper | <https://apify.com/crawlerbros/petrovich-scraper> |
| Regard Scraper | <https://apify.com/crawlerbros/regard-scraper> |
| Russkiy Svet (rs24.ru) Electrical Equipment Scraper | <https://apify.com/crawlerbros/russkiysvet-scraper> |
| Technopark.ru Scraper - Products, Categories & Search | <https://apify.com/crawlerbros/technopark-scraper> |
| VseInstrumenti.ru Scraper | <https://apify.com/crawlerbros/vseinstrumenti-scraper> |
| Wildberries Scraper | <https://apify.com/crawlerbros/wildberries-scraper> |
| X-Com Shop Scraper | <https://apify.com/crawlerbros/xcom-shop-scraper> |
| Yandex Market Pro Scraper | <https://apify.com/crawlerbros/yandex-pro-scraper> |

### FAQ

**Do I need a Citilink account or API key?**
No. The actor scrapes publicly available product data with no authentication.

**Why does this actor require a proxy?**
Citilink blocks automated requests without a working proxy session. The default AUTO
(datacenter) proxy group is sufficient — residential proxy is not required.

**Why is `sortBy` not a perfect global sort?**
See "How sorting works" above — it's applied across the fetched result window, not Citilink's
full catalog, to keep run times predictable.

**Can I search in Russian?**
Yes — `searchQuery` and `category` both accept Cyrillic text/slugs directly.

**Why do some listing records have fewer specs than product-detail records?**
Search/category results include only the handful of "short" specs Citilink shows on the
listing card. Use `mode=productDetails` for the full specification list.

**What's the difference between `topReview`/`ratingBreakdown` and `mode=reviews`?**
`topReview` and `ratingBreakdown` (in `mode=productDetails`) summarize the star-rating "opinions"
customers leave when rating a product. `mode=reviews` fetches Citilink's separate, longer-form
written reviews (with a title and full body text) — a smaller, distinct pool of content some
products don't have at all.

**Why don't `ratingBreakdown`, `topReview`, `relatedProducts`, `similarProducts`, or
`courierDelivery` appear on every product?**
These sections load on the product page after the core content, and Citilink doesn't always
render them in time. When that happens the core record (name, price, specs, images, etc.) is
still returned in full — only the enrichment fields are omitted, never filled with placeholder
data.

**Why don't `productUrl` links open with a plain script or `curl` request?**
Citilink's product and category pages require a real browser session to load; a script-only
request without a browser is blocked. The URLs themselves are correct and open normally in any
browser. Product image URLs (`cdn.citilink.ru/...`) are on a separate, unprotected host and load
directly anywhere.

**Is this actor affiliated with Citilink?**
No, this is a third-party actor that reads publicly available data from citilink.ru.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `searchQuery` (type: `string`):

Free-text keyword search (mode=search). Example: `iphone`, `ноутбук`, `телевизор`.

## `category` (type: `string`):

A Citilink category slug (e.g. `smartfony`), a catalog path (`/catalog/smartfony/`), or a full category URL (`https://www.citilink.ru/catalog/smartfony/`). Find slugs by browsing citilink.ru/catalog/.

## `productIds` (type: `array`):

Citilink product IDs (e.g. `2143346`) or full product URLs (e.g. `https://www.citilink.ru/product/smartfon-apple-iphone-17-a3520-256gb-purpurnyi-3g-4g-1sim-6-3-1206x262-2143346/`).

## `maxReviewsPerProduct` (type: `integer`):

Cap on full-text customer reviews fetched per product ID (mode=reviews). Distinct from the star-rating opinion summary already included in mode=productDetails.

## `sortBy` (type: `string`):

How to order results before truncating to Max items. Applied by the actor across the fetched result window (search/byCategory modes only) — see README for details.

## `minPrice` (type: `integer`):

Drop products cheaper than this (Russian rubles).

## `maxPrice` (type: `integer`):

Drop products more expensive than this (Russian rubles).

## `minRating` (type: `number`):

Drop products rated below this (0-5 scale).

## `inStockOnly` (type: `boolean`):

Only emit products currently available for purchase.

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

Hard cap on emitted records.

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

Citilink is protected by the QRATOR anti-bot service, which requires a real browser session. The default AUTO (datacenter) proxy group works for this challenge; residential proxy is not required.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "iphone",
  "category": "smartfony",
  "productIds": [],
  "maxReviewsPerProduct": 20,
  "sortBy": "relevance",
  "inStockOnly": false,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `products` (type: `string`):

Dataset containing all scraped Citilink products.

# 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 = {
    "mode": "search",
    "searchQuery": "iphone",
    "category": "smartfony",
    "productIds": [],
    "maxReviewsPerProduct": 20,
    "sortBy": "relevance",
    "inStockOnly": false,
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/citilink-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 = {
    "mode": "search",
    "searchQuery": "iphone",
    "category": "smartfony",
    "productIds": [],
    "maxReviewsPerProduct": 20,
    "sortBy": "relevance",
    "inStockOnly": False,
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/citilink-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 '{
  "mode": "search",
  "searchQuery": "iphone",
  "category": "smartfony",
  "productIds": [],
  "maxReviewsPerProduct": 20,
  "sortBy": "relevance",
  "inStockOnly": false,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/citilink-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Citilink Scraper - Russian Electronics Store Products",
        "description": "Scrape Citilink.ru, one of Russia's largest electronics and appliance retailers. Search products by keyword, browse any category, or fetch full product details - pricing, ratings, specifications, images, and stock status.",
        "version": "1.0",
        "x-build-id": "uduBNUHbFExEYMvWj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~citilink-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-citilink-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/crawlerbros~citilink-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-citilink-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/crawlerbros~citilink-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-citilink-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": [
                    "mode",
                    "proxyConfiguration"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byCategory",
                            "productDetails",
                            "reviews"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text keyword search (mode=search). Example: `iphone`, `ноутбук`, `телевизор`.",
                        "default": "iphone"
                    },
                    "category": {
                        "title": "Category (mode=byCategory)",
                        "type": "string",
                        "description": "A Citilink category slug (e.g. `smartfony`), a catalog path (`/catalog/smartfony/`), or a full category URL (`https://www.citilink.ru/catalog/smartfony/`). Find slugs by browsing citilink.ru/catalog/."
                    },
                    "productIds": {
                        "title": "Product IDs or URLs (mode=productDetails / mode=reviews)",
                        "type": "array",
                        "description": "Citilink product IDs (e.g. `2143346`) or full product URLs (e.g. `https://www.citilink.ru/product/smartfon-apple-iphone-17-a3520-256gb-purpurnyi-3g-4g-1sim-6-3-1206x262-2143346/`).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max reviews per product (mode=reviews)",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Cap on full-text customer reviews fetched per product ID (mode=reviews). Distinct from the star-rating opinion summary already included in mode=productDetails.",
                        "default": 20
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "priceAsc",
                            "priceDesc",
                            "discount",
                            "rating",
                            "opinions",
                            "reviews"
                        ],
                        "type": "string",
                        "description": "How to order results before truncating to Max items. Applied by the actor across the fetched result window (search/byCategory modes only) — see README for details.",
                        "default": "relevance"
                    },
                    "minPrice": {
                        "title": "Min price (RUB)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop products cheaper than this (Russian rubles)."
                    },
                    "maxPrice": {
                        "title": "Max price (RUB)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop products more expensive than this (Russian rubles)."
                    },
                    "minRating": {
                        "title": "Min rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Drop products rated below this (0-5 scale)."
                    },
                    "inStockOnly": {
                        "title": "In stock only",
                        "type": "boolean",
                        "description": "Only emit products currently available for purchase.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Citilink is protected by the QRATOR anti-bot service, which requires a real browser session. The default AUTO (datacenter) proxy group works for this challenge; residential proxy is not required.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
