# Mercari Japan Scraper | Listings Prices Sellers (`lentic_clockss/mercari-scraper`) Actor

Scrape Mercari Japan (jp.mercari.com) — keyword search, categories, brands, item PDP & sellers. Extract itemId, JPY prices, titles, images, brand, shipping. Export Excel/CSV/JSON for resale research & price tracking.

- **URL**: https://apify.com/lentic\_clockss/mercari-scraper.md
- **Developed by:** [kane liu](https://apify.com/lentic_clockss) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

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

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

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

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

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

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

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

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

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


# README

## Mercari Japan Scraper | Listings Prices Sellers

**Scrape Mercari Japan product listings, keyword search, categories, brands, item detail pages, and seller profiles — then download structured C2C marketplace data as Excel, CSV, or JSON.**

Use this Actor as a practical **Mercari JP data API** for resale research, price tracking, and secondhand assortment monitoring on [jp.mercari.com](https://jp.mercari.com/). Choose a mode, set filters, and get Dataset rows with `itemId`, JPY prices, titles, images, brand, seller, and shipping.

- Scrape **Mercari Japan search**, **category & brand PLPs**, **item PDP**, **seller profiles**, and the **category taxonomy** (depth 2+)
- Host: **`jp.mercari.com` only** (Mercari US `www.mercari.com` is out of scope)
- Extract **itemId, title, price (JPY), currency, imageUrl, brand / brandId, sellerId, shippingFee, listingType, availability**
- Optional **PDP enrich** (`enrichDetails`) via JSON-LD Product + description / shipping / brand links
- Filter by **on_sale / sold_out**, **priceMin / priceMax**, optional **itemConditionId**
- Paginate with verified **`page_token`** chain; sort: recommended / newest / price ascending
- Export to **Excel / CSV / JSON**, or connect Make, n8n, Zapier, Python, or the Apify API
- **Pay per event** — Actor start + each Dataset result; **platform usage is included** (you do not pay separate Apify compute on top)

> **Unofficial tool.** This Actor is not affiliated with, endorsed by, or sponsored by Mercari, Inc. It collects publicly reachable listing and seller surfaces and does **not** log in, checkout, place bids/orders, or access private accounts. Mercari US and login-only surfaces (e.g. マイリスト) are out of scope.

---

### What does the Mercari Japan Scraper do?

[Mercari Japan Scraper](https://apify.com/lentic_clockss/mercari-scraper) lets you **extract structured listing and seller data from [Mercari Japan](https://jp.mercari.com/)** without running your own proxy and browser fleet. Give it a keyword, `categoryId`, `brandId`, item id (`m…`), or seller id, then start a run.

Under the hood, the Actor:

1. Validates your input (mode, keyword / category / brand / item / seller, filters)
2. Enforces free-tier caps when you are on a free Apify plan
3. Calls a managed Cloud Run worker that fetches Mercari JP with JP residential egress
4. Parses hydrated SERP `item-cell` cards and PDP JSON-LD Product
5. Pushes Dataset rows ready for Excel / CSV / JSON export
6. Writes `RUN_SUMMARY` (and `ERROR_SUMMARY` on failure) to the key-value store

You run it like any other Apify Actor — schedule it, call it from the API, or plug it into automations.

---

### What Mercari Japan data can I extract?

| Data | Search | Category / Brand | Item PDP | Seller | Categories |
| --- | :---: | :---: | :---: | :---: | :---: |
| itemId / URL | ✅ | ✅ | ✅ | ✅ | — |
| Title / name | ✅ | ✅ | ✅ | ✅ | category name |
| Price / currency (JPY) | ✅ | ✅ | ✅ | ✅ | — |
| imageUrl / images | ✅ | ✅ | ✅ | ✅ | — |
| brand / brandId | enrich | enrich | ✅ | — | — |
| sellerId / sellerName | enrich | enrich | ✅ | ✅ | — |
| shippingFee / listingType | enrich | enrich | ✅ | — | — |
| availability / description | enrich | enrich | ✅ | — | — |
| categoryId / path | — | ✅ | ✅ | — | ✅ (tree) |
| identityVerified / badges | — | — | — | ✅ | — |

---

### Why scrape Mercari Japan?

Mercari Japan is one of the largest C2C marketplaces for secondhand goods — fashion, electronics, games, tickets, and more. Teams scrape Mercari JP for **price monitoring**, **resale sourcing**, **competitor research**, and **sold / on-sale assortment tracking**:

- Monitor **keyword search** and **category PLPs** (including non-3C verticals like fashion `3088`)
- Track **JPY prices**, on-sale vs sold stickers, brands, and shipping (“送料込み”)
- Pull **seller profiles** with identity-verification badges when available
- Map the **category taxonomy** (depth 2–3) for assortment planning
- Enrich listings with **PDP JSON-LD** (price, brand, availability, description)
- Feed BI dashboards, pricing tools, Google Sheets, BigQuery, or AI agents with clean rows

Compared with keyword-only Mercari scrapers, this Actor covers **search + category + brand + item PDP + seller + taxonomy** on **jp.mercari.com** in one input surface.

---

### How to scrape Mercari Japan (no code required)

1. Create a free [Apify](https://apify.com/) account
2. Open [Mercari Japan Scraper](https://apify.com/lentic_clockss/mercari-scraper)
3. Choose a **mode**: `search`, `category`, `brand`, `item`, `seller`, or `categories`
4. Enter a **keyword**, **categoryId** (e.g. `7` phones, `3088` fashion), **brandId**, **itemId** (`m…`), or **sellerId**
5. *(Optional)* Set `sort`, `status=on_sale`, `priceMin` / `priceMax`, `itemConditionId`, `enrichDetails`, `maxResults`, `taxonomyDepth`
6. Click **Start** and download the Dataset as JSON, CSV, Excel, or JSONL

Start with `maxResults: 5–15` to verify the query, then scale up.

---

### How much does it cost to scrape Mercari Japan?

This Actor uses **pay-per-event** pricing. You are charged for:

| Event | Price |
| --- | --- |
| Actor Start (`apify-actor-start`) | **$0.005** per start |
| Result (`apify-default-dataset-item`) | **$3.00 / 1,000** results (**$0.003** each) |

**Platform usage costs are included** — you do **not** pay separate Apify compute/proxy usage for this Actor on top of the event prices above (**User pays platform usage costs = No**).

#### Example cost estimates

| Results collected | Approx. event cost* |
| --- | ---: |
| 100 | ~$0.31 |
| 1,000 | ~$3.01 |
| 10,000 | ~$30.01 |

\*Assumes one Actor start at default memory billing for start events, plus `$0.003` per Dataset item. Exact start billing can scale with allocated memory (one start event per GB, minimum one).

#### Free plan limits

On a **free Apify plan**, this Actor enforces developer limits of **10 runs** and **200 results per run**. Upgrade to a paid Apify plan for unlimited runs (event prices still apply).

---

### Input examples

#### Keyword search (on sale)

```json
{
  "mode": "search",
  "keyword": "airpods",
  "status": "on_sale",
  "maxResults": 40,
  "sort": "price_asc"
}
````

#### Category PLP (fashion)

```json
{
  "mode": "category",
  "categoryId": "3088",
  "status": "on_sale",
  "maxResults": 30,
  "enrichDetails": true
}
```

#### Brand PLP

```json
{
  "mode": "brand",
  "brandId": "3272",
  "maxResults": 40
}
```

#### Item PDP

```json
{
  "mode": "item",
  "itemId": "m60491956645"
}
```

#### Seller profile

```json
{
  "mode": "seller",
  "sellerId": "504225586",
  "maxResults": 50
}
```

#### Category taxonomy

```json
{
  "mode": "categories",
  "taxonomyDepth": 2,
  "maxResults": 200
}
```

***

### Coverage matrix

| Dimension | Coverage |
| --- | --- |
| Host | `jp.mercari.com` |
| Waived | `www.mercari.com` (US Cloudflare); `/brands` CSR index; `api.mercari.jp` as primary API |
| Modes | `search` · `category` · `brand` · `item` · `seller` · `categories` |
| Taxonomy | Live tops + crawl depth 1–3 (`taxonomyDepth`) |
| Sort | Verified: `recommended` · `created_time_desc` · `price_asc` |
| Filters | `status` · `priceMin`/`priceMax` · `categoryId` · `brandId` · `itemConditionId` · `pageToken` |
| Enrich | PDP JSON-LD + description / shipping / brandId / listingType |
| Identity | `itemId` (`m` + digits) |

***

### Output example

```json
{
  "recordType": "item",
  "itemId": "m60491956645",
  "title": "Apple iPhone SE 第2世代 64GB",
  "price": 9577,
  "currency": "JPY",
  "imageUrl": "https://static.mercdn.net/…",
  "brand": "Apple",
  "brandId": "3272",
  "sellerId": "504225586",
  "shippingFee": "送料込み",
  "shippingIncluded": true,
  "listingType": "buy_it_now",
  "url": "https://jp.mercari.com/item/m60491956645",
  "country": "JP",
  "source": "jp.mercari.com"
}
```

***

### Tips for best results

- Prefer **`status=on_sale`** when you only need buyable inventory
- Use **`enrichDetails: true`** sparingly — each enrich opens PDPs (slower, richer fields)
- For fashion / non-electronics, try **`categoryId=3088`** (ファッション) or taxonomy mode first
- Keep **`maxResults`** modest on free plans (capped at **200** per run)
- Default memory is **1024 MB** — enough for this thin HTTPS Actor

***

### FAQ

**Is this an official Mercari API?**\
No. It is an unofficial scraper of public Mercari Japan pages.

**Does it support Mercari US?**\
No. `www.mercari.com` is behind a separate Cloudflare wall and is waived.

**Why do some seller runs return zero listings?**\
Seller grids are often empty under bot HTML; the worker retries with a Chrome UA for identity fields, but listing grids may still be empty.

**What about sort / item condition filters?**\
Verified sort codes are forwarded; some bot SSR responses ignore sort/condition effects. Price range and `status=on_sale` are the most reliable filters.

**Can I use this with n8n / Make / Zapier?**\
Yes — run the Actor via the Apify API or native Apify integrations and map Dataset items downstream.

***

### Runtime

| Setting | Value |
| --- | --- |
| Default memory | **1024 MB** |
| Proxy | Worker-owned JP residential (`WORKER_PROVIDES_PROXY=1`) |
| Worker | Managed Cloud Run (`mercari-com`) |

***

### Legal & ethics

Use this Actor only for lawful purposes and in line with Mercari’s terms, applicable laws, and your own compliance policy. Prefer public listing data; minimize personal data; do not use the Actor to harass sellers or circumvent access controls. You are responsible for how you store and process the results.

# Actor input Schema

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

search | category | brand | item | seller | categories

## `keyword` (type: `string`):

Keyword for mode=search

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

Optional list; first used if keyword empty

## `categoryId` (type: `string`):

Mercari category\_id e.g. 7 (スマホ) or 3088 (ファッション). Live tops from /categories.

## `brandId` (type: `string`):

Mercari brand\_id for mode=brand

## `itemId` (type: `string`):

Item id like m60491956645 for mode=item

## `sellerId` (type: `string`):

Numeric user id for mode=seller

## `pageToken` (type: `string`):

Pagination cursor (e.g. v1:1)

## `sort` (type: `string`):

Verified only: recommended | created\_time\_desc | price\_asc

## `status` (type: `string`):

e.g. on\_sale

## `priceMin` (type: `number`):

Optional minimum price filter (JPY, URL price\_min=)

## `priceMax` (type: `number`):

Optional maximum price filter (JPY, URL price\_max=)

## `itemConditionId` (type: `string`):

Forwarded as item\_condition\_id (Googlebot SSR may ignore; use for Chrome-aligned experiments)

## `taxonomyDepth` (type: `integer`):

For mode=categories: BFS depth under /categories (1–4, default 3)

## `maxResults` (type: `integer`):

Maximum rows (free plan capped at 200)

## `enrichDetails` (type: `boolean`):

Open PDPs for JSON-LD Product enrichment on list modes

## `startUrls` (type: `array`):

Optional jp.mercari.com URLs

## `workerBaseUrl` (type: `string`):

Optional HTTPS allowlisted Cloud Run URL override

## Actor input object example

```json
{
  "mode": "search",
  "sort": "recommended",
  "taxonomyDepth": 3,
  "maxResults": 50,
  "enrichDetails": false
}
```

# Actor output Schema

## `results` (type: `string`):

Normalized Etsy listing / shop / category rows from the default dataset.

## `runSummary` (type: `string`):

Structured summary record stored in the default key-value store.

## `inputEcho` (type: `string`):

Normalized input saved at run start.

## `errorSummary` (type: `string`):

Present when a failed run stores structured terminal error information.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("lentic_clockss/mercari-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("lentic_clockss/mercari-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 '{}' |
apify call lentic_clockss/mercari-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mercari Japan Scraper | Listings Prices Sellers",
        "description": "Scrape Mercari Japan (jp.mercari.com) — keyword search, categories, brands, item PDP & sellers. Extract itemId, JPY prices, titles, images, brand, shipping. Export Excel/CSV/JSON for resale research & price tracking.",
        "version": "0.1",
        "x-build-id": "oMCRm8o1u9Nh0kM76"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lentic_clockss~mercari-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lentic_clockss-mercari-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/lentic_clockss~mercari-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lentic_clockss-mercari-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/lentic_clockss~mercari-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lentic_clockss-mercari-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "category",
                            "brand",
                            "item",
                            "seller",
                            "categories"
                        ],
                        "type": "string",
                        "description": "search | category | brand | item | seller | categories",
                        "default": "search"
                    },
                    "keyword": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Keyword for mode=search"
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Optional list; first used if keyword empty",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryId": {
                        "title": "Category ID",
                        "type": "string",
                        "description": "Mercari category_id e.g. 7 (スマホ) or 3088 (ファッション). Live tops from /categories."
                    },
                    "brandId": {
                        "title": "Brand ID",
                        "type": "string",
                        "description": "Mercari brand_id for mode=brand"
                    },
                    "itemId": {
                        "title": "Item ID",
                        "type": "string",
                        "description": "Item id like m60491956645 for mode=item"
                    },
                    "sellerId": {
                        "title": "Seller / user ID",
                        "type": "string",
                        "description": "Numeric user id for mode=seller"
                    },
                    "pageToken": {
                        "title": "Page token",
                        "type": "string",
                        "description": "Pagination cursor (e.g. v1:1)"
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "recommended",
                            "created_time_desc",
                            "price_asc"
                        ],
                        "type": "string",
                        "description": "Verified only: recommended | created_time_desc | price_asc",
                        "default": "recommended"
                    },
                    "status": {
                        "title": "Listing status",
                        "type": "string",
                        "description": "e.g. on_sale"
                    },
                    "priceMin": {
                        "title": "Min price (JPY)",
                        "type": "number",
                        "description": "Optional minimum price filter (JPY, URL price_min=)"
                    },
                    "priceMax": {
                        "title": "Max price (JPY)",
                        "type": "number",
                        "description": "Optional maximum price filter (JPY, URL price_max=)"
                    },
                    "itemConditionId": {
                        "title": "Item condition ID",
                        "type": "string",
                        "description": "Forwarded as item_condition_id (Googlebot SSR may ignore; use for Chrome-aligned experiments)"
                    },
                    "taxonomyDepth": {
                        "title": "Taxonomy depth",
                        "minimum": 1,
                        "maximum": 4,
                        "type": "integer",
                        "description": "For mode=categories: BFS depth under /categories (1–4, default 3)",
                        "default": 3
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum rows (free plan capped at 200)",
                        "default": 50
                    },
                    "enrichDetails": {
                        "title": "Enrich item details",
                        "type": "boolean",
                        "description": "Open PDPs for JSON-LD Product enrichment on list modes",
                        "default": false
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional jp.mercari.com URLs",
                        "items": {
                            "type": "string"
                        }
                    },
                    "workerBaseUrl": {
                        "title": "Worker base URL override",
                        "type": "string",
                        "description": "Optional HTTPS allowlisted Cloud Run URL override"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
