# Yandex Reverse Image Search Scraper (Яндекс) (`getascraper/yandex-reverse-image-scraper`) Actor

Reverse image search on Yandex at scale. Submit image URLs, get similar images, source pages, tags and other sizes as JSON. No login. Pay per result.

- **URL**: https://apify.com/getascraper/yandex-reverse-image-scraper.md
- **Developed by:** [GetAScraper](https://apify.com/getascraper) (community)
- **Categories:** Developer tools, SEO tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.30 / 1,000 image matches

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 Reverse Image Scraper: Яндекс Картинки

<table width="100%">
<tr>
<td style="padding:24px 28px;background:#FFECE8;border:1px solid #FBD0C6;border-top:4px solid #FC3F1D;border-radius:12px">
<span style="font-size:23px;font-weight:800;color:#1C1917;line-height:1.3">Trace a whole batch of images across Yandex in one run</span><br>
<span style="font-size:15px;color:#57534E;line-height:1.6">Give the Actor a list of image URLs and get back every match Yandex Images finds for each one: visually similar photos, the pages that use the image, best-guess tags, other-size copies, and shopping matches when they exist.</span>
</td>
</tr>
</table>

<table width="100%">
<tr>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #FBD0C6;border-radius:10px 0 0 10px;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#C42D10">📦 A batch, not one at a time</span><br>
<span style="font-size:12px;color:#57534E">Feed a list of image URLs and every result row stays tagged to its source image</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #FBD0C6;border-left:none;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#C42D10">🔎 Five kinds of matches</span><br>
<span style="font-size:12px;color:#57534E">Similar images, matching pages, tags, other sizes, and shopping results in one dataset</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #FBD0C6;border-left:none;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#C42D10">🔓 No login, clean output</span><br>
<span style="font-size:12px;color:#57534E">No account and no sign-in, just structured rows ready to export</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #FBD0C6;border-left:none;border-radius:0 10px 10px 0;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#C42D10">✅ Only real data</span><br>
<span style="font-size:12px;color:#57534E">Missing values are left out, never a fake similarity score or filler</span>
</td>
</tr>
</table>

Yandex Reverse Image Scraper runs reverse image search on Yandex Images (Яндекс Картинки), Russia's largest search engine, for as many images as you want in a single run.

### 🔍 What does it do?

You hand the Actor a list of public image URLs. For each image, it asks Yandex Images what it knows about that picture and returns a clean row for every match it finds. Matches come in five categories:

- **Similar images**: other pictures that look like your image.
- **Matching pages**: web pages that actually use your image, with the page title, domain, and a short text snippet.
- **Text tags**: Yandex's best-guess labels for what the image shows.
- **Other sizes**: copies of the same image at different resolutions, grouped by small, medium, and large.
- **Shopping matches**: product listings tied to the image, when Yandex has them.

Every row is stamped with the input image it came from, so a run over 50 images stays easy to sort and attribute. The output is structured data you can download as JSON, CSV, or Excel, or pull straight into your own pipeline.

Most reverse image tools make you check pictures one at a time. This Actor takes the whole list at once, which is the difference between a coffee break and an afternoon when you have hundreds of images to trace.

### 🧑‍💼 Why use it?

**Brand protection teams** trace where a product photo shows up across the web to find counterfeit listings and unlicensed resellers, image by image, at scale.

**E-commerce sellers** check whether their own product shots have been lifted onto competitor or knockoff pages, without pasting each URL into a search box by hand.

**OSINT analysts and fact-checkers** verify where an image first appeared and which pages reuse it, building provenance for an investigation from real match data.

**SEO and stock-photo teams** map every page using a given image, so they can chase attribution, backlinks, or licensing.

Yandex often surfaces matches that Western reverse image engines miss, especially across Russian and CIS websites, so it is a strong second source when you need coverage beyond the usual tools.

### 🚀 How to use it

<table width="100%">
<tr>
<td style="padding:16px 14px;width:33%;background:#FFECE8;border:1px solid #FBD0C6;border-radius:10px 0 0 10px;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#FC3F1D;letter-spacing:1px">STEP 1</span><br>
<span style="font-size:14px;font-weight:700;color:#1C1917">Paste your image URLs</span><br>
<span style="font-size:12px;color:#57534E">Add one image link or a long list. One run covers them all.</span>
</td>
<td style="padding:16px 14px;width:33%;background:#FFECE8;border:1px solid #FBD0C6;border-left:none;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#FC3F1D;letter-spacing:1px">STEP 2</span><br>
<span style="font-size:14px;font-weight:700;color:#1C1917">Pick what to pull</span><br>
<span style="font-size:12px;color:#57534E">Toggle the match types you want and cap how many results per image.</span>
</td>
<td style="padding:16px 14px;width:33%;background:#FFECE8;border:1px solid #FBD0C6;border-left:none;border-radius:0 10px 10px 0;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#FC3F1D;letter-spacing:1px">STEP 3</span><br>
<span style="font-size:14px;font-weight:700;color:#1C1917">Export the matches</span><br>
<span style="font-size:12px;color:#57534E">Similar images, pages, tags, and sizes land in your dataset, ready to download.</span>
</td>
</tr>
</table>

1. Open Yandex Reverse Image Scraper on the Apify platform and click **Try for free** or **Start**.
2. Paste one or more public image URLs into **Image URLs**.
3. Turn the match categories you want on or off, and set a **Max results per image** cap if you want to keep runs small.
4. Click **Start**, then download your results as JSON, CSV, or Excel once the run finishes.

You can also schedule the Actor to run daily or weekly, so a watched set of images stays monitored without any manual work.

### ⚙️ Input

| Field | Type | Required | Description |
|---|---|---|---|
| Image URLs | array of URLs | Yes | One or more public image links to search on Yandex Images. Each URL is searched separately and every result row is tagged with its source image. |
| Max results per image | integer | No | Cap on how many matches to return per category, per image. Leave unset to return everything Yandex reports. |
| Include similar images | boolean | No | Return visually similar images for each input image. |
| Include matching pages | boolean | No | Return web pages that use the image, with page title, domain, and snippet. |
| Include tags | boolean | No | Return Yandex's best-guess text labels for the image. |
| Include other sizes | boolean | No | Return copies of the image at other resolutions, grouped small, medium, and large. |
| Include shopping matches | boolean | No | Return product listings tied to the image, when Yandex has them. |
| Proxy configuration | object | No | Proxy used to reach Yandex. The default setting works out of the box. |

### 📤 Output

Every run produces one row per match, tagged with the input image it belongs to. Example:

```json
[
  {
    "inputImageUrl": "https://example.com/product-photo.jpg",
    "matchType": "matching_page",
    "title": "Winter Down Jacket, Navy: Online Store",
    "url": "https://shop.example.ru/catalog/down-jacket-navy",
    "imageUrl": "https://avatars.mds.yandex.net/get-images/123/orig",
    "width": 1200,
    "height": 1600,
    "sourceDomain": "shop.example.ru",
    "description": "Navy down jacket, sizes S to XXL, free shipping across Russia.",
    "scrapedAt": "2026-07-09T10:22:41.508Z"
  },
  {
    "inputImageUrl": "https://example.com/product-photo.jpg",
    "matchType": "similar_image",
    "title": "Down jacket navy blue",
    "url": "https://images.example.net/item/98213",
    "imageUrl": "https://avatars.mds.yandex.net/get-images/456/orig",
    "width": 800,
    "height": 1067,
    "scrapedAt": "2026-07-09T10:22:41.512Z"
  }
]
````

You can download the dataset in JSON, CSV, Excel, HTML, or XML from the Apify platform, or pull it through the API into your own workflow.

### 📋 Data table

| Field | Type | Description |
|---|---|---|
| Source image URL | text | The input image this row of matches came from. |
| Match type | enum | The kind of match: similar image, matching page, tag, other size, or shopping match. |
| Title | text | Title of the matched result, such as a page title or product name. |
| Link | text | URL of the match: the page that uses the image, a similar image, a tag search, or a product listing. |
| Image URL | text | Direct link to the matched image file. |
| Width | integer | Pixel width of the matched image. |
| Height | integer | Pixel height of the matched image. |
| Source domain | text | Domain of the page that uses the image, for matching-page rows. |
| Description | text | Short text snippet from the page that uses the image, for matching-page rows. |
| Size group | enum | For other-size rows, whether the copy is small, medium, or large. |
| Collected at | text | Timestamp of when the match was found. |

Fields that Yandex does not report for a given match are left out of that row rather than filled with a placeholder, so every value in your dataset is real. There is no invented similarity or confidence score, because Yandex does not publish one.

### 💰 Pricing

Yandex Reverse Image Scraper is pay per result. You only pay for the matches actually returned, and an image that has no matches costs nothing. There is no subscription and no minimum spend.

### ⭐ Enjoying Yandex Reverse Image Scraper?

<table width="100%">
<tr>
<td style="padding:20px 24px 14px;background:#FFECE8;border:1px solid #FBD0C6;border-left:5px solid #FC3F1D;border-radius:10px 10px 0 0">
<span style="font-size:20px;letter-spacing:4px">⭐ ⭐ ⭐ ⭐ ⭐</span><br>
<span style="font-size:17px;font-weight:800;color:#1C1917">If this Actor saved you from checking images one by one, tell us about it.</span><br>
<span style="font-size:14px;color:#57534E">A 5-star rating takes 10 seconds and helps other brand-protection and OSINT teams find this Actor. Your feedback also tells us what to build next.</span>
</td>
</tr>
<tr>
<td style="padding:0;background:#FC3F1D;border:1px solid #FBD0C6;border-top:none;border-radius:0 0 10px 10px;text-align:center">
<a href="https://apify.com/getascraper/yandex-reverse-image-scraper/reviews" style="display:block;padding:13px 16px;color:#FFFFFF;text-decoration:none;font-weight:800;font-size:15px;letter-spacing:0.3px">★&nbsp;&nbsp;Rate this Actor on Apify</a>
</td>
</tr>
</table>

### 💡 Tips for better runs

- Use a direct link to the image file, ending in .jpg, .png, or .webp, rather than a link to the page it sits on.
- Turn off the match categories you do not need to keep runs lean and results focused.
- Set a Max results per image cap on exploratory runs, then raise it once you know how many matches a typical image returns.
- Run the same set of images on a schedule to watch for new pages that start using your photos over time.

### ❓ FAQ

**Как сделать поиск по картинке в Яндексе сразу для нескольких изображений?**
Paste all of your image URLs into the Image URLs field and start one run. The Actor searches each image on Yandex Images separately and returns every match, with each row tagged to the source image, so you never have to search them one at a time.

**Поиск по картинке Яндекс: можно ли найти, на каких сайтах используется изображение?**
Yes. Keep the matching pages category turned on and the Actor returns the web pages that use each image, along with the page title, the domain, and a short text snippet from the page.

**Why are some fields missing from a row?**
Yandex does not report every detail for every match. Rather than guess or insert a placeholder, the Actor leaves those fields out of the row so your data stays accurate. It also does not add any similarity or confidence score, because Yandex does not provide one.

**Is this legal?**
The Actor only reads public reverse image search results that any visitor can see on Yandex Images. It does not access accounts or collect personal data. Review Yandex's terms of service if you plan to use the data commercially at scale.

Found an issue or want a feature added? Open a ticket from the Issues tab on this Actor's page, or reach out for a custom version built around your exact workflow.

# Actor input Schema

## `imageUrls` (type: `array`):

One or more public HTTP(S) image URLs to reverse-search on Yandex Images. Not a file upload - each entry must be a direct link to an image.

## `maxResultsPerImage` (type: `integer`):

Maximum number of rows returned per enabled category (similar images, matching pages, tags, other sizes) for each input image.

## `includeSimilarImages` (type: `boolean`):

Visually similar images found elsewhere on the web.

## `includeMatchingPages` (type: `boolean`):

Web pages that contain this exact image.

## `includeTags` (type: `boolean`):

Yandex's best-guess text labels describing what's in the image.

## `includeOtherSizes` (type: `boolean`):

The same image found at other resolutions on other pages.

## `includeShoppingMatches` (type: `boolean`):

Product listings Yandex Market matches to this image, when present. Not every image has shopping matches - this category is frequently empty.

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

Datacenter proxy (the default) is confirmed to work for this target. Switch to Residential only if a run starts hitting blocks.

## Actor input object example

```json
{
  "imageUrls": [
    "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg"
  ],
  "maxResultsPerImage": 20,
  "includeSimilarImages": true,
  "includeMatchingPages": true,
  "includeTags": true,
  "includeOtherSizes": true,
  "includeShoppingMatches": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "imageUrls": [
        "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg"
    ],
    "maxResultsPerImage": 20,
    "includeSimilarImages": true,
    "includeMatchingPages": true,
    "includeTags": true,
    "includeOtherSizes": true,
    "includeShoppingMatches": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("getascraper/yandex-reverse-image-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 = {
    "imageUrls": ["https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg"],
    "maxResultsPerImage": 20,
    "includeSimilarImages": True,
    "includeMatchingPages": True,
    "includeTags": True,
    "includeOtherSizes": True,
    "includeShoppingMatches": True,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("getascraper/yandex-reverse-image-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 '{
  "imageUrls": [
    "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg"
  ],
  "maxResultsPerImage": 20,
  "includeSimilarImages": true,
  "includeMatchingPages": true,
  "includeTags": true,
  "includeOtherSizes": true,
  "includeShoppingMatches": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call getascraper/yandex-reverse-image-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yandex Reverse Image Search Scraper (Яндекс)",
        "description": "Reverse image search on Yandex at scale. Submit image URLs, get similar images, source pages, tags and other sizes as JSON. No login. Pay per result.",
        "version": "0.1",
        "x-build-id": "0VhZrecXIsxmeu8jT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/getascraper~yandex-reverse-image-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-getascraper-yandex-reverse-image-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/getascraper~yandex-reverse-image-scraper/runs": {
            "post": {
                "operationId": "runs-sync-getascraper-yandex-reverse-image-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/getascraper~yandex-reverse-image-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-getascraper-yandex-reverse-image-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",
                "properties": {
                    "imageUrls": {
                        "title": "Image URLs",
                        "type": "array",
                        "description": "One or more public HTTP(S) image URLs to reverse-search on Yandex Images. Not a file upload - each entry must be a direct link to an image.",
                        "default": [
                            "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerImage": {
                        "title": "Max results per category, per image",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of rows returned per enabled category (similar images, matching pages, tags, other sizes) for each input image.",
                        "default": 20
                    },
                    "includeSimilarImages": {
                        "title": "Include similar images",
                        "type": "boolean",
                        "description": "Visually similar images found elsewhere on the web.",
                        "default": true
                    },
                    "includeMatchingPages": {
                        "title": "Include matching pages",
                        "type": "boolean",
                        "description": "Web pages that contain this exact image.",
                        "default": true
                    },
                    "includeTags": {
                        "title": "Include tags",
                        "type": "boolean",
                        "description": "Yandex's best-guess text labels describing what's in the image.",
                        "default": true
                    },
                    "includeOtherSizes": {
                        "title": "Include other-size duplicates",
                        "type": "boolean",
                        "description": "The same image found at other resolutions on other pages.",
                        "default": true
                    },
                    "includeShoppingMatches": {
                        "title": "Include shopping matches",
                        "type": "boolean",
                        "description": "Product listings Yandex Market matches to this image, when present. Not every image has shopping matches - this category is frequently empty.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Datacenter proxy (the default) is confirmed to work for this target. Switch to Residential only if a run starts hitting blocks.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
