# Yandex Maps Lead Finder (`automation-lab/yandex-maps-lead-finder`) Actor

Scrape local businesses from Yandex Maps for lead generation — extract business name, address, phone, website, rating, and categories for CIS-market leads.

- **URL**: https://apify.com/automation-lab/yandex-maps-lead-finder.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Yandex Maps Lead Finder

Extract local business leads from **Yandex Maps** — the #1 mapping platform across Russia, Belarus, Kazakhstan, Uzbekistan, and the wider CIS region. Get structured contact data including business name, address, phone number, rating, review count, categories, and coordinates in a single run.

> 🗺️ **Why Yandex Maps?** Yandex Maps covers CIS markets far more comprehensively than Google Maps. If your customers or clients operate in Russia, Kazakhstan, or Ukraine, Yandex Maps is where local businesses list their contact details.

---

### What does this actor do?

Yandex Maps Lead Finder searches Yandex Maps for local businesses matching your query and extracts structured lead data from the results. You provide one or more search queries (like _"dentist almaty"_ or _"auto repair minsk"_) and the actor returns a clean, export-ready dataset with full contact information for every matching business.

**Extracted data per lead:**
| Field | Description |
|-------|-------------|
| `name` | Business name |
| `address` | Full street address |
| `country` | Country |
| `phone` | Primary phone number |
| `phones` | All phone numbers listed |
| `website` | Website URL (when available) |
| `rating` | Average star rating (1–5) |
| `reviewCount` | Number of user reviews |
| `ratingCount` | Number of ratings |
| `categories` | Business category tags (e.g. Restaurant, Dental Clinic) |
| `lat` / `lng` | GPS coordinates |
| `isOpen` | Current open/closed status |
| `workingHours` | Opening hours summary |
| `yandexUrl` | Direct link to the business on Yandex Maps |
| `orgId` | Yandex Maps organisation ID |
| `searchQuery` | The search query that returned this result |

---

### Who is it for?

#### 🏢 Sales & marketing teams targeting CIS markets
Building a prospect list for cold outreach? This actor gives you direct phone numbers and addresses for businesses in Russia, Kazakhstan, Belarus, and other CIS countries — the same data leads pay for in commercial databases.

#### 📍 Local SEO consultants & agencies
Monitor your client's local competitors, audit category coverage, or build citation reports by extracting all businesses in a given category and city in minutes.

#### 🛒 E-commerce & B2B businesses expanding into CIS
Identify local distributors, retail outlets, or service partners. Filter by category, city, and rating to find the highest-quality prospects fast.

#### 🔬 Market researchers & analysts
Map business density by category and geography, compare competitor concentration, or feed a CRM with enriched local business data for analysis.

#### 🤖 Data engineers & developers
Automate lead generation pipelines via the Apify API, integrate with CRMs (HubSpot, Salesforce), or trigger Zap workflows when new leads match a query.

---

### Why use this actor instead of manual research?

- ⚡ **100× faster than manual search** — extract 50 leads in seconds instead of hours
- 📊 **Structured, export-ready data** — CSV / JSON / Excel, ready for your CRM
- 🔄 **Schedule recurring runs** — refresh your lead list weekly with zero effort
- 🌍 **CIS coverage** — Yandex Maps has data for cities that aren't on Google Maps
- 🔌 **API & Zapier ready** — integrate with any tool in your stack

---

### How to use Yandex Maps Lead Finder

#### Step 1: Choose your search queries
Think about what you would type into the Yandex Maps search box. Good examples:
- `restaurants moscow` — restaurants in Moscow
- `dentist almaty` — dental clinics in Almaty, Kazakhstan
- `auto repair minsk` — car repair shops in Minsk, Belarus
- `hotel samarkand` — hotels in Samarkand, Uzbekistan
- `fitness gym tashkent` — gyms in Tashkent

#### Step 2: Set Max Leads
Start with **20–50** for a test run. Increase to 200–500 for a full campaign list.

#### Step 3: Choose language
Use `ru_RU` for Russian results (more complete coverage), `en_US` for English labels.

#### Step 4: Run and export
Click **Start** and wait for the run to complete. Export to CSV, JSON, or XLSX from the dataset tab.

---

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `searchQueries` | array | ✅ | — | List of search terms (e.g. `["restaurants moscow", "cafes spb"]`) |
| `maxLeads` | integer | ❌ | 50 | Max total leads to extract across all queries |
| `lang` | string | ❌ | `en_US` | Language for results (`en_US`, `ru_RU`, `kk_KZ`, etc.) |
| `proxyConfiguration` | object | ❌ | SHADER | Proxy settings — defaults to Apify datacenter proxy |
| `debugMode` | boolean | ❌ | false | Saves raw HTML to KV store for debugging |

#### Example input

```json
{
  "searchQueries": [
    "restaurants moscow",
    "dentist almaty",
    "hotel minsk"
  ],
  "maxLeads": 100,
  "lang": "en_US"
}
````

***

### Output format

Each item in the dataset represents one business lead:

```json
{
  "name": "Everest Continental",
  "address": "Moscow, 2nd Zvenigorodskaya Street, 13с4",
  "country": "Russian Federation",
  "phone": "+74991131383",
  "phones": ["+74991131383"],
  "website": null,
  "rating": 4.9,
  "reviewCount": 942,
  "ratingCount": 1476,
  "categories": ["Restaurant", "Hookah lounge", "Nightclub"],
  "lat": 55.762189,
  "lng": 37.554728,
  "isOpen": "open",
  "workingHours": "24 hr",
  "yandexUrl": "https://yandex.com/maps/org/everest_continental/6687013474/",
  "orgId": "6687013474",
  "searchQuery": "restaurants moscow"
}
```

***

### Tips for best results

🎯 **Be specific in your queries** — `italian restaurant kazan` returns better results than just `restaurant`.

🌆 **One city per query** — Yandex Maps searches are location-aware. Add the city name directly in the query for precise results.

📋 **Use multiple queries** — Run `cafes moscow`, `cafes spb`, `cafes kazan` in a single actor run to cover multiple cities.

🔢 **Start small** — Test with `maxLeads: 20` first to verify output quality before scaling to 500+.

🌐 **Try Russian queries** — For Russian cities, searching in Russian (e.g. `рестораны москва`) often returns more complete results. Use `lang: ru_RU` together with Russian search terms.

⭐ **Filter by rating in post-processing** — Export results and filter `rating >= 4.5` in Excel or your CRM to focus on high-quality prospects.

***

### Integrations

#### 📧 CRM integration (HubSpot / Salesforce)

Use the Apify → HubSpot or Apify → Salesforce Zap to automatically create contacts or leads from each exported business. Map `name` → Company Name, `phone` → Phone, `address` → Address.

#### 📊 Google Sheets auto-export

Connect the Apify Google Sheets integration to push results directly into a spreadsheet. Schedule weekly runs to keep your prospecting list fresh.

#### 🔁 Zapier + Make (Integromat) automation

Trigger a Zapier workflow on actor completion to send new leads to your email, Slack, or CRM. Useful for monitoring new businesses in your target category.

#### 🗺️ Combine with Google Maps Lead Finder

Running campaigns in mixed markets? Use [Google Maps Lead Finder](https://apify.com/automation-lab/google-maps-lead-finder) for Western markets and this actor for CIS markets. Merge the datasets for complete regional coverage.

***

### API usage

#### Node.js

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

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

const run = await client.actor('automation-lab/yandex-maps-lead-finder').call({
  searchQueries: ['restaurants moscow', 'cafes spb'],
  maxLeads: 100,
  lang: 'en_US',
});

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

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_API_TOKEN")

run = client.actor("automation-lab/yandex-maps-lead-finder").call(run_input={
    "searchQueries": ["restaurants moscow", "cafes spb"],
    "maxLeads": 100,
    "lang": "en_US",
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~yandex-maps-lead-finder/runs?token=YOUR_APIFY_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["restaurants moscow"],
    "maxLeads": 50,
    "lang": "en_US"
  }'
```

***

### Use with Claude (MCP)

Connect this actor directly to Claude via the **Apify MCP server**. Claude can then search Yandex Maps and return structured lead data in your conversation.

#### Claude Code / CLI

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/yandex-maps-lead-finder"
```

#### Claude Desktop / Cursor / VS Code

Add to your MCP config (`claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/mcp-server"],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_API_TOKEN",
        "ACTOR_SLUGS": "automation-lab/yandex-maps-lead-finder"
      }
    }
  }
}
```

#### Example Claude prompts

- *"Find 30 dentists in Almaty, Kazakhstan and export their phone numbers"*
- *"Search for auto repair shops in Minsk and give me a table with name, address, and rating"*
- *"Find the top-rated restaurants in Tashkent with at least 100 reviews"*

***

### How much does it cost to scrape Yandex Maps businesses?

This actor uses **Pay Per Event (PPE)** pricing — you only pay for results you actually get.

| Plan | Per business lead |
|------|-------------------|
| Free tier | $0.001 |
| Personal / BRONZE | $0.0009 |
| Team / SILVER | $0.0008 |
| Business / GOLD | $0.00065 |

**Example costs:**

- 50 leads ≈ **$0.06–0.10** (including run start fee)
- 200 leads ≈ **$0.21–0.25**
- 1,000 leads ≈ **$1.01–1.10**

The **free Apify plan** includes enough credits for several test runs to evaluate the data quality before committing to larger extractions.

***

### Supported regions and languages

Yandex Maps has strong coverage across the CIS region and beyond:

| Country | Coverage | Recommended language |
|---------|----------|---------------------|
| 🇷🇺 Russia | Excellent | `ru_RU` or `en_US` |
| 🇰🇿 Kazakhstan | Excellent | `kk_KZ` or `ru_RU` |
| 🇧🇾 Belarus | Excellent | `be_BY` or `ru_RU` |
| 🇺🇦 Ukraine | Good | `uk_UA` or `ru_RU` |
| 🇺🇿 Uzbekistan | Good | `ru_RU` |
| 🇦🇲 Armenia | Good | `ru_RU` |
| 🇬🇪 Georgia | Good | `ru_RU` |
| 🇹🇷 Turkey | Moderate | `tr_TR` |

For best coverage, use the local language of the target country in both the search query and the `lang` parameter.

***

### Legality: Is it legal to scrape Yandex Maps?

Scraping publicly visible business contact information — phone numbers, addresses, and categories that businesses themselves publish on Yandex Maps — is generally legal in most jurisdictions for B2B commercial purposes. Similar data is sold commercially by data brokers worldwide.

**Important notes:**

- Only public business data is collected (no private user data, no reviews scraped)
- This actor does not bypass any authentication or access controls
- Review Yandex's Terms of Service and your local data protection laws before using data for marketing
- GDPR/CCPA compliance is your responsibility when storing and processing this data

This actor is intended for **legitimate B2B lead generation, market research, and business analytics** — not for spam or harassment.

***

### FAQ

#### Can I get phone numbers for all businesses?

Most businesses on Yandex Maps include at least one phone number. The `phones` field contains all numbers listed. Businesses without a phone number will have `phone: null`.

#### Does this support CIS countries other than Russia?

Yes. Yandex Maps covers Russia, Kazakhstan, Belarus, Uzbekistan, Armenia, Georgia, and more. Just include the city name in your search query (e.g. `hotel yerevan`, `restaurant astana`).

#### How many results can I get per query?

The actor can extract up to several hundred results per search query through scroll-based pagination. For more results, use more specific queries or split by neighbourhood/district.

#### Why is `website` null for some businesses?

Not all businesses on Yandex Maps list a website URL. The `website` field is populated when available in the Yandex Maps page data; otherwise it returns null.

#### The actor returned fewer results than expected — why?

Yandex Maps may show fewer businesses for niche categories or smaller cities. Try broadening your search term, removing the city name, or searching in Russian for better coverage. Also verify your proxy is working correctly.

#### How do I get results in Russian?

Set `lang` to `ru_RU` and use Russian search terms (e.g. `рестораны москва`). This often returns more complete local data, especially for smaller cities.

***

### Related scrapers

- [Google Maps Lead Finder](https://apify.com/automation-lab/google-maps-lead-finder) — Same concept for Western markets
- [Google Maps Reviews Scraper](https://apify.com/automation-lab/google-maps-reviews-scraper) — Extract reviews from Google Maps businesses

# Actor input Schema

## `searchQueries` (type: `array`):

One or more Yandex Maps search queries. Examples: <code>restaurants moscow</code>, <code>dentist almaty</code>, <code>hotels saint petersburg</code>. Each query runs separately — use multiple queries to cover different cities or categories.

## `maxLeads` (type: `integer`):

Maximum total number of business leads to extract across all queries. Keep low for testing, raise for production runs.

## `lang` (type: `string`):

Language for results. Use <code>en\_US</code> for English, <code>ru\_RU</code> for Russian, <code>kk\_KZ</code> for Kazakh.

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

Proxy settings. Defaults to Apify datacenter proxies (SHADER group). Upgrade to residential for better reliability on restricted regions.

## `debugMode` (type: `boolean`):

Saves raw HTML to the key-value store for debugging. Only enable when troubleshooting.

## Actor input object example

```json
{
  "searchQueries": [
    "restaurants moscow"
  ],
  "maxLeads": 20,
  "lang": "en_US",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "SHADER"
    ]
  },
  "debugMode": false
}
```

# Actor output Schema

## `overview` (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 = {
    "searchQueries": [
        "restaurants moscow"
    ],
    "maxLeads": 20,
    "lang": "en_US",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "SHADER"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/yandex-maps-lead-finder").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 = {
    "searchQueries": ["restaurants moscow"],
    "maxLeads": 20,
    "lang": "en_US",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["SHADER"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/yandex-maps-lead-finder").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 '{
  "searchQueries": [
    "restaurants moscow"
  ],
  "maxLeads": 20,
  "lang": "en_US",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "SHADER"
    ]
  }
}' |
apify call automation-lab/yandex-maps-lead-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yandex Maps Lead Finder",
        "description": "Scrape local businesses from Yandex Maps for lead generation — extract business name, address, phone, website, rating, and categories for CIS-market leads.",
        "version": "0.1",
        "x-build-id": "ebuc1KuJjef9iwSTL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~yandex-maps-lead-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-yandex-maps-lead-finder",
                "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~yandex-maps-lead-finder/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-yandex-maps-lead-finder",
                "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~yandex-maps-lead-finder/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-yandex-maps-lead-finder",
                "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": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "🔍 Search queries",
                        "type": "array",
                        "description": "One or more Yandex Maps search queries. Examples: <code>restaurants moscow</code>, <code>dentist almaty</code>, <code>hotels saint petersburg</code>. Each query runs separately — use multiple queries to cover different cities or categories.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxLeads": {
                        "title": "📦 Max leads",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum total number of business leads to extract across all queries. Keep low for testing, raise for production runs.",
                        "default": 50
                    },
                    "lang": {
                        "title": "🌐 Language",
                        "enum": [
                            "en_US",
                            "ru_RU",
                            "uk_UA",
                            "kk_KZ",
                            "be_BY",
                            "tr_TR"
                        ],
                        "type": "string",
                        "description": "Language for results. Use <code>en_US</code> for English, <code>ru_RU</code> for Russian, <code>kk_KZ</code> for Kazakh.",
                        "default": "en_US"
                    },
                    "proxyConfiguration": {
                        "title": "🔒 Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Defaults to Apify datacenter proxies (SHADER group). Upgrade to residential for better reliability on restricted regions."
                    },
                    "debugMode": {
                        "title": "🐛 Debug mode",
                        "type": "boolean",
                        "description": "Saves raw HTML to the key-value store for debugging. Only enable when troubleshooting.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
