# Imenik Serbia Scraper (`crawlerbros/imenik-rs-scraper`) Actor

Scrape imenik.rs, Serbia's business directory. Search by keyword, browse by city or category, and extract business name, address, phone, email, website, working hours, rating, and description.

- **URL**: https://apify.com/crawlerbros/imenik-rs-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Lead generation, Other
- **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

## Imenik Serbia Scraper - imenik.rs Business Directory

Scrape **imenik.rs** — Serbia's business directory. Search any keyword, browse every business in a Serbian city or town, or browse an entire business category, and get name, full address, phone, email, website, working hours, rating, and description. No login, no cookies, no API key required.

### What this actor does

- **Three modes:** `search` (free-text keyword), `byCity` (every business in a city/town), `byCategory` (every business in a category)
- **49 curated cities/towns** to pick from, or type any of imenik.rs's ~594 registered locations directly (diacritics-insensitive, Cyrillic input also supported and transliterated)
- **24 top-level business categories**, or type any of ~376 subcategories directly (e.g. "Auto servisi", "Advokati", "Frizerski saloni")
- **Combine filters** — `byCity`/`byCategory` accept both `city` and `category` together (browse one category within one city); `search` additionally combines a free-text keyword with both
- **Sort by** relevance, rating, or name (A-Z)
- **Filter by** minimum star rating (1-5)
- **Rich records from a single pass** — imenik.rs's own listing pages already carry address, phone, category, and rating for most businesses; this actor also visits each business's own page (bounded concurrency) to fill in website, email, working hours, description, and photo
- **Empty fields are omitted** — you only ever see fields that were actually found for a business

### Output per business

- `businessName` — business name
- `category` — business category or subcategory (from the active filter or the business's own listing)
- `city`, `street`, `fullAddress` — parsed from imenik.rs's own address field
- `latitude`, `longitude` — geocoded map coordinates of the business address
- `phone`, `email`, `website`
- `workingHours` — free-text opening hours as published by the business
- `description` — business description / about text
- `rating` — average star rating (0-5), when the business has received votes
- `ratingCount` — number of votes behind the average rating
- `tags` — list of business-specific tags published on imenik.rs (e.g. brand specializations like "Honda servis", "Riblji restoran") — only present when the business tagged itself
- `amenities` — list of published amenities (e.g. Parking, Wi-Fi, air conditioning, wheelchair access) — only present for businesses that publish this (mostly hospitality/venue listings)
- `priceRange` — published price range (e.g. "21-30 €") — only present for businesses that publish this
- `photos` — gallery of additional photos beyond the cover image, when the business uploaded any
- `videoUrl` — embedded promotional video, when the business added one
- `imageUrl` — business cover photo (only when the business uploaded a real photo, not imenik.rs's default placeholder)
- `sourceUrl` — canonical imenik.rs page for the business
- `recordType: "business"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string (select) | `search` | `search` (keyword), `byCity` (browse a city), or `byCategory` (browse a category) |
| `searchQuery` | string | `restoran` | Free-text keyword: business name, trade, or service. Only applies in mode=search (ignored in byCity/byCategory) |
| `city` | string (select) | – (no filter) | Pick one of 49 curated cities/towns (all modes, optional filter for search/byCategory) |
| `customCity` | string | – | Any Serbian city/town/village not in the curated list, overrides `city` |
| `category` | string (select) | – | Pick one of 24 top-level categories (all modes, optional filter for search/byCity) |
| `customSubcategory` | string | – | Any of ~376 subcategories not exposed above, overrides `category` |
| `sortBy` | string (select) | `relevance` | `relevance` / `rating` (highest first) / `name` (A-Z) — applied client-side across the fetched batch |
| `minRating` | integer | `0` (no minimum) | Only return businesses rated at least 1-5 stars |
| `maxItems` | integer | `20` | Hard cap on returned records (1-500) |

#### Example: search for "restoran" nationwide

```json
{
  "mode": "search",
  "searchQuery": "restoran",
  "maxItems": 20
}
````

#### Example: every business in Novi Sad rated 4+ stars, best first

```json
{
  "mode": "byCity",
  "city": "Novi Sad",
  "minRating": 4,
  "sortBy": "rating",
  "maxItems": 50
}
```

#### Example: pizzerias ("Picerije" subcategory) in Beograd

```json
{
  "mode": "byCategory",
  "category": "Restorani, Cafe",
  "customSubcategory": "Picerije",
  "city": "Beograd",
  "maxItems": 30
}
```

#### Example: browsing a town not in the curated city list

```json
{
  "mode": "byCity",
  "customCity": "Backa Topola",
  "maxItems": 20
}
```

### Use cases

- **Local lead generation** — build a prospect list of Serbian businesses by trade and city for B2B outreach
- **Market research** — measure business density and average ratings for a category across Serbian cities
- **Directory aggregation** — feed structured Serbian business data into your own local-search product
- **Competitor mapping** — see who else operates in a category and city, with ratings and contact info

### Limitations

- **Category filtering follows imenik.rs's own (broader-than-exact) matching.** When you filter by `category`/`customSubcategory`, imenik.rs itself sometimes returns businesses tagged with a closely related subcategory rather than only the exact one requested (verified directly against the live site, independent of this actor's request-building) -- e.g. filtering by "Auto servisi" (car repair shops) can also surface a business primarily tagged "Auto delovi" (car parts) if it's cross-listed. The `category` output field always reflects the business's own listed category, so you can still filter/verify client-side after the run if you need an exact match.

- **`amenities`/`priceRange`/`photos`/`videoUrl` are published by only a subset of businesses.** These fields are mostly used by hospitality/venue-type listings (restaurants, hotels, event spaces) on imenik.rs; most other business types simply don't have them, so they're omitted rather than returned empty.

- **`latitude`/`longitude` require a resolvable address.** imenik.rs geocodes each business's address field itself; on the rare listing where imenik.rs couldn't geocode the address, coordinates are omitted.

- **`website`/`email`/`workingHours`/`description`/`imageUrl` depend on what the business published.** imenik.rs only shows these when the business itself filled them in; a bare "Website" link pointing back at imenik.rs itself (the site's own placeholder when no real site was provided) and the site's default cover photo are both detected and omitted rather than returned as fake data.

- **`sortBy` is applied client-side.** imenik.rs's listing pages don't expose a server-side sort parameter, so `rating`/`name` sorting is applied across the batch of records this run actually fetched, not the entire city/category.

- **`minRating` is applied client-side.** A business with no rating yet (no votes received) is excluded once `minRating` is set above 0, since there is no rating to compare against.

- **No Cyrillic locale on the live site.** imenik.rs itself only serves Serbian Latin script (no `/sr`, `/cyr`, or Cyrillic-locale variant was found). `customCity`/`customSubcategory` inputs typed in Cyrillic are automatically transliterated to Latin before matching, so both scripts work as input even though output text is always Latin, matching the source site.

- **Address field ordering is inconsistent at the source.** Most imenik.rs listings write addresses as "Street, City" but a minority write "City, Street"; this actor resolves the ambiguity against imenik.rs's own list of ~594 registered locations rather than assuming a fixed order.

### FAQ

**What data source does this actor use?**
It reads the publicly available search, city, and category listing pages, and individual business pages, on imenik.rs, Serbia's business directory. No account or API key is needed.

**Is this affiliated with imenik.rs?**
No. This is an independent, third-party actor that reads publicly accessible pages.

**Why do some businesses have no rating, phone, or website?**
imenik.rs only shows a rating once a business has received at least one vote, and only shows contact details a business itself provided. Fields with no data are simply omitted from the record rather than shown as empty or null.

**Can I search for a city or category not in the dropdown lists?**
Yes — use `customCity` for any of imenik.rs's ~594 registered locations (typos in diacritics are tolerated, e.g. "Backa Topola" matches "Bačka Topola") or `customSubcategory` for any of its ~376 subcategories (e.g. "Veterinari", "Auto servisi", "Frizerski saloni"). Both take priority over the dropdown fields when set.

**Can I combine a city and a category in the same run?**
Yes, in every mode. For example `mode: "byCity"` with both `city` and `category` set returns only businesses in that city that also belong to that category.

**Does this actor need a proxy or login?**
No — imenik.rs's listing and business pages are served without any anti-bot challenge, so this actor runs entirely on Apify's free plan with no proxy and no credentials.

# Actor input Schema

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

What to fetch: free-text keyword search, browse all businesses in a city, or browse all businesses in a category.

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

Free-text keyword: a business name, trade, or service, e.g. "restoran", "advokat", "auto servis". Can be combined with City and Category below to narrow results.

## `city` (type: `string`):

A curated list of Serbia's major cities and towns. Required for mode=byCity; optional filter for search/byCategory. Leave as "No city filter" together with 'Custom city' below for nationwide results.

## `customCity` (type: `string`):

Any Serbian city, town, or village not in the curated list above, matched against imenik.rs's own ~594 registered locations (diacritics-insensitive, e.g. "Backa Topola" matches "Bačka Topola"). Takes priority over 'City' when set.

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

One of imenik.rs's 24 top-level business categories. Required for mode=byCategory; optional filter for search/byCity. Leave as "No category filter" together with 'Custom subcategory' below for all categories.

## `customSubcategory` (type: `string`):

Any of imenik.rs's ~376 subcategories not exposed above, matched by exact Serbian name (diacritics-insensitive), e.g. "Auto servisi", "Advokati", "Frizerski saloni", "Veterinari". Takes priority over 'Category' when set. See the README for the full subcategory list.

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

How to order results after fetching. imenik.rs itself only returns relevance/listing order; 'rating' and 'name' are applied client-side across the fetched batch.

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

Only return businesses rated at least this many stars, e.g. 4 for 4.0+. 0 means no minimum. Businesses with no rating are excluded once this is set above 0.

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

Hard cap on the number of business records to return.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "restoran",
  "city": "",
  "category": "",
  "sortBy": "relevance",
  "minRating": 0,
  "maxItems": 20
}
```

# Actor output Schema

## `businesses` (type: `string`):

Dataset containing all scraped imenik.rs business records.

# 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": "restoran",
    "city": "",
    "category": "",
    "sortBy": "relevance",
    "minRating": 0,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/imenik-rs-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": "restoran",
    "city": "",
    "category": "",
    "sortBy": "relevance",
    "minRating": 0,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/imenik-rs-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": "restoran",
  "city": "",
  "category": "",
  "sortBy": "relevance",
  "minRating": 0,
  "maxItems": 20
}' |
apify call crawlerbros/imenik-rs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Imenik Serbia Scraper",
        "description": "Scrape imenik.rs, Serbia's business directory. Search by keyword, browse by city or category, and extract business name, address, phone, email, website, working hours, rating, and description.",
        "version": "1.0",
        "x-build-id": "vnz5od48F09jyjbyL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~imenik-rs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-imenik-rs-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~imenik-rs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-imenik-rs-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~imenik-rs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-imenik-rs-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"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byCity",
                            "byCategory"
                        ],
                        "type": "string",
                        "description": "What to fetch: free-text keyword search, browse all businesses in a city, or browse all businesses in a category.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free-text keyword: a business name, trade, or service, e.g. \"restoran\", \"advokat\", \"auto servis\". Can be combined with City and Category below to narrow results.",
                        "default": "restoran"
                    },
                    "city": {
                        "title": "City (mode=byCity)",
                        "enum": [
                            "",
                            "Beograd",
                            "Novi Sad",
                            "Niš",
                            "Kragujevac",
                            "Subotica",
                            "Zrenjanin",
                            "Pančevo",
                            "Čačak",
                            "Kraljevo",
                            "Novi Pazar",
                            "Leskovac",
                            "Vranje",
                            "Šabac",
                            "Sombor",
                            "Požarevac",
                            "Pirot",
                            "Zaječar",
                            "Kruševac",
                            "Valjevo",
                            "Užice",
                            "Vršac",
                            "Bor",
                            "Prokuplje",
                            "Smederevo",
                            "Sremska Mitrovica",
                            "Loznica",
                            "Jagodina",
                            "Vrbas",
                            "Inđija",
                            "Ruma",
                            "Senta",
                            "Kikinda",
                            "Bačka Palanka",
                            "Sremski Karlovci",
                            "Aranđelovac",
                            "Gornji Milanovac",
                            "Paraćin",
                            "Trstenik",
                            "Vrnjačka Banja",
                            "Sjenica",
                            "Tutin",
                            "Priboj",
                            "Ivanjica",
                            "Sokobanja",
                            "Bečej",
                            "Temerin",
                            "Stara Pazova",
                            "Pećinci"
                        ],
                        "type": "string",
                        "description": "A curated list of Serbia's major cities and towns. Required for mode=byCity; optional filter for search/byCategory. Leave as \"No city filter\" together with 'Custom city' below for nationwide results.",
                        "default": ""
                    },
                    "customCity": {
                        "title": "Custom city (overrides selection above)",
                        "type": "string",
                        "description": "Any Serbian city, town, or village not in the curated list above, matched against imenik.rs's own ~594 registered locations (diacritics-insensitive, e.g. \"Backa Topola\" matches \"Bačka Topola\"). Takes priority over 'City' when set."
                    },
                    "category": {
                        "title": "Category (mode=byCategory)",
                        "enum": [
                            "",
                            "Automobili",
                            "Deca, Bebe",
                            "Država i društvo",
                            "Građevinarstvo",
                            "Hoteli, Putovanja",
                            "Hrana, Piće",
                            "Industrija",
                            "Kuća, Bašta",
                            "Kućni ljubimci",
                            "Kultura, Zabava",
                            "Lepota, Spa",
                            "Mašine, Alati",
                            "Medicina, Zdravlje",
                            "Mediji, Marketing",
                            "Odeća, Moda",
                            "Poljoprivreda",
                            "Poslovni svet",
                            "Restorani, Cafe",
                            "Servisi, usluge",
                            "Škole, Fakulteti",
                            "Sport, Fitness",
                            "Tehnika, Elektronika",
                            "Transport, Špedicija",
                            "Trgovina"
                        ],
                        "type": "string",
                        "description": "One of imenik.rs's 24 top-level business categories. Required for mode=byCategory; optional filter for search/byCity. Leave as \"No category filter\" together with 'Custom subcategory' below for all categories.",
                        "default": ""
                    },
                    "customSubcategory": {
                        "title": "Custom subcategory (overrides selection above)",
                        "type": "string",
                        "description": "Any of imenik.rs's ~376 subcategories not exposed above, matched by exact Serbian name (diacritics-insensitive), e.g. \"Auto servisi\", \"Advokati\", \"Frizerski saloni\", \"Veterinari\". Takes priority over 'Category' when set. See the README for the full subcategory list."
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "rating",
                            "name"
                        ],
                        "type": "string",
                        "description": "How to order results after fetching. imenik.rs itself only returns relevance/listing order; 'rating' and 'name' are applied client-side across the fetched batch.",
                        "default": "relevance"
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only return businesses rated at least this many stars, e.g. 4 for 4.0+. 0 means no minimum. Businesses with no rating are excluded once this is set above 0.",
                        "default": 0
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on the number of business records to return.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
