# Yandex Reverse Image Search API (`johnvc/yandex-reverse-image-search`) Actor

Search Yandex by image. Give an image URL and get every page where it appears online, visually similar images, other sizes, matching shop products, and image tags as clean JSON. Crop-box targeting, 6 regional domains, pay per result.

- **URL**: https://apify.com/johnvc/yandex-reverse-image-search.md
- **Developed by:** [John](https://apify.com/johnvc) (community)
- **Categories:** Developer tools, SEO tools
- **Stats:** 5 total users, 2 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.00001 / result

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

Search by image instead of by keywords. Give this API the URL of any image and it searches Yandex's reverse image engine (the same one behind yandex.com/images) to find every page where the image appears online, visually similar images, other sizes and resolutions of the same image, products that match the image, and descriptive tags. Pay per result, with a hard cap you control.

Yandex is widely regarded as one of the strongest reverse image engines on the web, especially for faces, places, and content that Western engines miss. This actor gives you that power as a clean JSON API.

### What this API returns

Each result is one dataset row, tagged with a `result_type` field so you can filter:

| result_type | What it is | On by default |
|-------------|------------|:-------------:|
| `matching_page` | A page where the image (or a close match) appears online: title, link, snippet, source | ✅ |
| `similar_image` | A visually similar image from across the web: thumbnail, link | ✅ |
| `image_size` | Another resolution of the same image, categorized large / medium / small | ❌ |
| `image_tag` | A suggested search term describing what is in the image | ❌ |
| `shopping_result` | An e-commerce product matching the image, with price where available | ❌ |
| `knowledge_graph` | Entity card when the image contains a recognizable person, place, or brand | ❌ |

Every row also carries the query image URL, the Yandex domain used, the crop box (if any), and a search timestamp.

### Use cases

- **Find where your images are used**: track unauthorized use of product photos, artwork, or brand assets across the web.
- **Brand protection and counterfeit detection**: enable shopping matches to find marketplaces selling products that look like yours.
- **Image provenance and fact-checking**: find earlier and higher-resolution versions of an image to trace where it first appeared.
- **Face and person search research**: Yandex's reverse image engine is known for strong face matching (use responsibly and lawfully).
- **Duplicate and similar image discovery**: build datasets of visually similar images for ML or content curation.
- **Source hunting**: find the original, full-resolution version of a compressed or cropped image.

### Quick start

The fastest possible run, just paste an image URL:

```json
{
  "image_url": "https://substack-post-media.s3.amazonaws.com/public/images/edbfb2cd-ebcb-4527-bec7-5315c182278f_445x445.png"
}
````

Search only part of the image with a crop box (fractions of width and height, left;top;right;bottom):

```json
{
  "image_url": "https://example.com/group-photo.jpg",
  "crop": "0.1;0.2;0.5;0.8",
  "include_similar_images": true
}
```

Everything on, capped at 100 rows:

```json
{
  "image_url": "https://example.com/product.jpg",
  "include_matching_pages": true,
  "include_similar_images": true,
  "include_image_sizes": true,
  "include_image_tags": true,
  "include_shopping_results": true,
  "include_knowledge_graph": true,
  "max_results": 100
}
```

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `image_url` | `string` | ✅ | - | Public http(s) URL of the image to search by. Yandex fetches it, so it must be reachable from the internet (direct image link, no login or redirect). |
| `crop` | `string` | ❌ | (none) | Crop the image before searching: four `;`-separated fractions 0-1 in the order left;top;right;bottom, e.g. `0.1;0.2;0.9;0.8`. |
| `include_matching_pages` | `boolean` | ❌ | `true` | Pages where the image appears online (result\_type `matching_page`). |
| `include_similar_images` | `boolean` | ❌ | `true` | Visually similar images (result\_type `similar_image`). |
| `include_image_sizes` | `boolean` | ❌ | `false` | Other resolutions of the same image (result\_type `image_size`). |
| `include_image_tags` | `boolean` | ❌ | `false` | Descriptive tags for the image content (result\_type `image_tag`). |
| `include_shopping_results` | `boolean` | ❌ | `false` | Matching products with prices (result\_type `shopping_result`). |
| `include_knowledge_graph` | `boolean` | ❌ | `false` | Entity card for recognizable subjects (result\_type `knowledge_graph`). |
| `yandex_domain` | `string` | ❌ | `"yandex.com"` | Regional domain: `yandex.com`, `yandex.ru`, `yandex.by`, `yandex.kz`, `yandex.uz`, `yandex.com.tr`. |
| `max_results` | `integer` | ❌ | `0` | Hard cap on rows returned and billed. `0` = everything found. Set `20` for a cheap first run. |

### Example output row

```json
{
  "result_type": "matching_page",
  "position": 27,
  "title": "Central Illustration Agency Illustration portfolio: Matt Taylor",
  "link": "https://tr.pinterest.com/pin/matt-taylor-digital-illustration-illustrator-graphic-poster-art-car-scenery-bold--826762444071832079/",
  "thumbnail": "https://avatars.mds.yandex.net/i?id=592d913ed53e1f78fdd0804bd7064417b709bafb-5437458-images-thumbs&n=13&w=296&h=180",
  "original": "https://i.pinimg.com/736x/9e/b1/f7/9eb1f76ee45eb01706be89b8748a911b.jpg",
  "source": "tr.pinterest.com",
  "snippet": "After graduating from Buckinghamshire University he rolled straight into a successful ten year illustration career.",
  "image_url": "https://substack-post-media.s3.amazonaws.com/public/images/edbfb2cd-ebcb-4527-bec7-5315c182278f_445x445.png",
  "yandex_domain": "yandex.com",
  "crop": "",
  "search_timestamp": "2026-07-05T12:00:00"
}
```

Two dataset views are available in Apify Console and via API: **Overview** (all rows, typed) and **Visual results** (thumbnail-forward).

### Pricing

This actor uses pay-per-event billing: you are charged one `result_returned` event per dataset row. You control cost two ways:

1. **Result-type toggles**: only the sections you enable produce rows. The default (matching pages + similar images) covers the two most common reverse image questions.
2. **`max_results` cap**: a hard ceiling on rows returned and billed per run.

A search that legitimately finds nothing still pushes one `no_results` summary row so billing stays transparent. Invalid input and upstream failures do not produce billable rows.

The current per-result price is shown on the [Apify Store listing](https://apify.com/johnvc/yandex-reverse-image-search?fpr=9n7kx3). New users get Apify's free trial credit, which covers many test runs.

### How to get started

1. [View on Apify Store](https://apify.com/johnvc/yandex-reverse-image-search?fpr=9n7kx3) and click **Try for free**.
2. Paste an image URL into the input form and run.
3. Read the results from the dataset (JSON, CSV, or Excel), or call the actor from the [Apify API](https://docs.apify.com/api/v2) in your own code.

### 🔌 Use this API from Claude (MCP)

Add this actor as a tool in [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial), [Claude Cowork](https://claude.ai/referral/uIlpa7nPLg) (free trial), or any other MCP client, via the hosted Apify MCP server. Use this actor-specific URL:

https://mcp.apify.com/?tools=actors,docs,johnvc/yandex-reverse-image-search

Setup walkthrough:

https://www.youtube.com/watch?v=jREWahDGhJM

Apify MCP integration docs: https://docs.apify.com/platform/integrations/mcp

### FAQ

#### How is billing calculated?

One dataset row = one billed result. Enable only the result types you need and set `max_results` to cap any run. An empty search pushes a single summary row; failed runs bill nothing.

#### What images work best?

Publicly reachable, reasonably sized images (300px+ on the short side). Yandex fetches the URL you provide, so private, localhost, or login-protected URLs will not work. If you only care about part of an image (one face in a group photo, one product on a shelf), use the `crop` parameter.

#### How is this different from a normal image search?

A normal image search takes keywords and returns images. Reverse image search takes an image and returns where it appears, what looks like it, and what it contains. For keyword-based Yandex image search, see the [Yandex Search Scraper API](https://apify.com/johnvc/Scrape-Yandex?fpr=9n7kx3), which also covers web results, ads, and the knowledge graph.

#### Which Yandex domain should I use?

`yandex.com` (the default) works for most cases. Regional domains like `yandex.ru` can surface more results for images that circulate mainly on the Russian-language web.

#### Is it legal to reverse image search a person?

Laws differ by jurisdiction, and platform terms apply. This tool returns publicly indexed data only; you are responsible for using it lawfully and ethically, especially for images of people.

### Featured Tasks

Ready-to-run examples that show this API solving a specific problem. Each opens its own setup so you can run it on your account in one click.

- [Reverse image search in Claude via MCP](https://apify.com/johnvc/yandex-reverse-image-search/examples/reverse-image-search-in-claude-via-mcp?fpr=9n7kx3) - let Claude reverse-search any image through Yandex live in the conversation via MCP.
- [Find where an image appears online with Yandex](https://apify.com/johnvc/yandex-reverse-image-search/examples/find-where-an-image-appears-online-with-yandex?fpr=9n7kx3) - every page where an image appears, with source and snippet, as JSON.
- [Trace an image to its original source with Yandex](https://apify.com/johnvc/yandex-reverse-image-search/examples/trace-an-image-to-its-original-source-with-yandex?fpr=9n7kx3) - find an image's original source and every page using it.
- [Find visually similar images from an image URL](https://apify.com/johnvc/yandex-reverse-image-search/examples/find-visually-similar-images-from-an-image-url?fpr=9n7kx3) - visually similar images from across the web, with thumbnail, full-size URL, and source.
- [Find products from an image with Yandex](https://apify.com/johnvc/yandex-reverse-image-search/examples/find-products-from-an-image-with-yandex?fpr=9n7kx3) - visually similar products and shop listings from a product image.
- [Reverse image search with Yandex, results as JSON](https://apify.com/johnvc/yandex-reverse-image-search/examples/reverse-image-search-with-yandex-results-as-json?fpr=9n7kx3) - matching pages, similar images, and more, as structured JSON, no API key setup.

Last Updated: 2026.07.10

# Actor input Schema

## `image_url` (type: `string`):

Provide the public http(s) URL of the image to search by. Yandex fetches this URL, so it must be reachable from the internet (no localhost or private links). Example: `https://substack-post-media.s3.amazonaws.com/public/images/edbfb2cd-ebcb-4527-bec7-5315c182278f_445x445.png`.

## `crop` (type: `string`):

Optionally crop the image before searching, as four ';'-separated fractions between 0 and 1 in the order left;top;right;bottom. Example: `0.1;0.2;0.9;0.8` searches only the middle of the image. Leave blank to search the whole image.

## `include_matching_pages` (type: `boolean`):

Return pages where this image (or a close match) appears online, with page title, link, and snippet. Rows with result\_type 'matching\_page'. On by default.

## `include_similar_images` (type: `boolean`):

Return visually similar images from across the web, with thumbnails and links. Rows with result\_type 'similar\_image'. On by default.

## `include_image_sizes` (type: `boolean`):

Return other resolutions of the same image, categorized large / medium / small. Rows with result\_type 'image\_size'. Off by default.

## `include_image_tags` (type: `boolean`):

Return suggested search terms describing what is in the image. Rows with result\_type 'image\_tag'. Off by default.

## `include_shopping_results` (type: `boolean`):

Return e-commerce products that match the image content, with prices where available. Rows with result\_type 'shopping\_result'. Off by default.

## `include_knowledge_graph` (type: `boolean`):

Return the entity card when the image contains a recognizable subject (a person, landmark, product, or brand). One row with result\_type 'knowledge\_graph'. Off by default.

## `yandex_domain` (type: `string`):

The regional Yandex domain to search from. Defaults to 'yandex.com'. Results can differ by region.

## `max_results` (type: `integer`):

Cap the total number of result rows returned (and billed) by this run. 0 (the default) returns everything the search found for your selected result types. Set a small number like 20 for a low-cost first run.

## Actor input object example

```json
{
  "image_url": "https://substack-post-media.s3.amazonaws.com/public/images/edbfb2cd-ebcb-4527-bec7-5315c182278f_445x445.png",
  "include_matching_pages": true,
  "include_similar_images": true,
  "include_image_sizes": false,
  "include_image_tags": false,
  "include_shopping_results": false,
  "include_knowledge_graph": false,
  "yandex_domain": "yandex.com",
  "max_results": 50
}
```

# Actor output Schema

## `allResults` (type: `string`):

Every result row from this run, tagged with result\_type

## `overview` (type: `string`):

Tabular overview of all results

## `visualResults` (type: `string`):

Thumbnail-forward view of found images and pages

# 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 = {
    "image_url": "https://substack-post-media.s3.amazonaws.com/public/images/edbfb2cd-ebcb-4527-bec7-5315c182278f_445x445.png",
    "max_results": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnvc/yandex-reverse-image-search").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 = {
    "image_url": "https://substack-post-media.s3.amazonaws.com/public/images/edbfb2cd-ebcb-4527-bec7-5315c182278f_445x445.png",
    "max_results": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("johnvc/yandex-reverse-image-search").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 '{
  "image_url": "https://substack-post-media.s3.amazonaws.com/public/images/edbfb2cd-ebcb-4527-bec7-5315c182278f_445x445.png",
  "max_results": 50
}' |
apify call johnvc/yandex-reverse-image-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yandex Reverse Image Search API",
        "description": "Search Yandex by image. Give an image URL and get every page where it appears online, visually similar images, other sizes, matching shop products, and image tags as clean JSON. Crop-box targeting, 6 regional domains, pay per result.",
        "version": "0.0",
        "x-build-id": "2QFMcpdYEgGfE8Fvl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/johnvc~yandex-reverse-image-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-johnvc-yandex-reverse-image-search",
                "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/johnvc~yandex-reverse-image-search/runs": {
            "post": {
                "operationId": "runs-sync-johnvc-yandex-reverse-image-search",
                "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/johnvc~yandex-reverse-image-search/run-sync": {
            "post": {
                "operationId": "run-sync-johnvc-yandex-reverse-image-search",
                "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": [
                    "image_url"
                ],
                "properties": {
                    "image_url": {
                        "title": "Image URL",
                        "type": "string",
                        "description": "Provide the public http(s) URL of the image to search by. Yandex fetches this URL, so it must be reachable from the internet (no localhost or private links). Example: `https://substack-post-media.s3.amazonaws.com/public/images/edbfb2cd-ebcb-4527-bec7-5315c182278f_445x445.png`."
                    },
                    "crop": {
                        "title": "Crop box",
                        "type": "string",
                        "description": "Optionally crop the image before searching, as four ';'-separated fractions between 0 and 1 in the order left;top;right;bottom. Example: `0.1;0.2;0.9;0.8` searches only the middle of the image. Leave blank to search the whole image."
                    },
                    "include_matching_pages": {
                        "title": "Matching pages",
                        "type": "boolean",
                        "description": "Return pages where this image (or a close match) appears online, with page title, link, and snippet. Rows with result_type 'matching_page'. On by default.",
                        "default": true
                    },
                    "include_similar_images": {
                        "title": "Similar images",
                        "type": "boolean",
                        "description": "Return visually similar images from across the web, with thumbnails and links. Rows with result_type 'similar_image'. On by default.",
                        "default": true
                    },
                    "include_image_sizes": {
                        "title": "Other sizes",
                        "type": "boolean",
                        "description": "Return other resolutions of the same image, categorized large / medium / small. Rows with result_type 'image_size'. Off by default.",
                        "default": false
                    },
                    "include_image_tags": {
                        "title": "Image tags",
                        "type": "boolean",
                        "description": "Return suggested search terms describing what is in the image. Rows with result_type 'image_tag'. Off by default.",
                        "default": false
                    },
                    "include_shopping_results": {
                        "title": "Shopping matches",
                        "type": "boolean",
                        "description": "Return e-commerce products that match the image content, with prices where available. Rows with result_type 'shopping_result'. Off by default.",
                        "default": false
                    },
                    "include_knowledge_graph": {
                        "title": "Knowledge graph",
                        "type": "boolean",
                        "description": "Return the entity card when the image contains a recognizable subject (a person, landmark, product, or brand). One row with result_type 'knowledge_graph'. Off by default.",
                        "default": false
                    },
                    "yandex_domain": {
                        "title": "Yandex Domain",
                        "enum": [
                            "yandex.com",
                            "yandex.ru",
                            "yandex.by",
                            "yandex.kz",
                            "yandex.uz",
                            "yandex.com.tr"
                        ],
                        "type": "string",
                        "description": "The regional Yandex domain to search from. Defaults to 'yandex.com'. Results can differ by region.",
                        "default": "yandex.com"
                    },
                    "max_results": {
                        "title": "Maximum results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap the total number of result rows returned (and billed) by this run. 0 (the default) returns everything the search found for your selected result types. Set a small number like 20 for a low-cost first run.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
