# Mercari Scraper - Listings, Sold Comps, Sellers (`sourabhbgp/mercari-scraper`) Actor

Scrape Mercari (Mercari Japan) listings, sold prices, item details, and seller profiles. Search by keyword, category, or brand, pull sold comps for resale pricing, and get likes, comments, ratings, and English translation. Pay per result, no subscription.

- **URL**: https://apify.com/sourabhbgp/mercari-scraper.md
- **Developed by:** [Sourabh Kumar](https://apify.com/sourabhbgp) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

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

### Mercari scraper: listings, sold prices, item details & sellers

Pull live and sold listings, full item details, and seller profiles from Mercari Japan in one actor. Search by keyword, category, or brand, or paste item and seller URLs. No login, proxy, or browser setup.

**$5 per 1,000 results. Flat for every mode. No meaningful per-run fee.**

Covers jp.mercari.com, with native Japanese text and optional English translation.

### Why this scraper?

- 💴 **Sold prices, not just active listings:** flip one switch to pull sold comps for pricing research and resale.
- ⭐ **Seller intelligence on every profile:** star rating, rating counts, follower count, total sales, and trust badges.
- ❤️ **Likes and full comment threads:** item detail returns like counts, comment counts, and the actual buyer comments.
- 🗂️ **One actor, three modes:** search, item detail, and seller, instead of stitching together separate scrapers.
- ⚡ **HTTP-only and fast:** no headless browser, no proxy juggling, no flaky page loads.
- 🌐 **English translation built in:** get the Japanese title and description plus an English version on request.
- 🧾 **You only pay for rows you keep:** billing is per delivered record, so capped runs never charge for nothing.

### What data can you extract?

<table>
  <tr><td>🆔 Item ID & URL</td><td>📝 Title & description</td><td>💴 Price (JPY)</td><td>🏷️ Brand</td></tr>
  <tr><td>📦 Condition</td><td>📐 Size</td><td>🗂️ Category breadcrumb</td><td>🚚 Shipping payer</td></tr>
  <tr><td>✅ On sale / sold</td><td>❤️ Like count</td><td>💬 Comment threads</td><td>🖼️ Photos</td></tr>
  <tr><td>⭐ Seller rating</td><td>👥 Follower count</td><td>🛍️ Items sold</td><td>🎖️ Seller badges</td></tr>
</table>

### Scraping modes

#### 🔍 Search: keyword, category, brand, and sold comps

Find listings by keyword, or paste a Mercari search, category, or brand URL. Set `status` to `sold_out` to pull sold comps for pricing research, or `all` to get both.

```json
{ "mode": "search", "keyword": "nike", "status": "on_sale", "sort": "created", "maxItems": 100 }
````

Sold comps:

```json
{ "mode": "search", "keyword": "nike air max", "status": "sold_out", "maxItems": 200 }
```

#### 📦 Item detail: likes, comments, full description

Paste item URLs or IDs. Returns the rich record: description, like count, comment threads, category breadcrumb, size, shipping method, the seller's rating and sales count, and an optional English translation.

```json
{ "mode": "item", "itemUrls": ["https://jp.mercari.com/item/m39120191169"], "includeTranslation": true }
```

#### 🧑‍💼 Seller: profile, ratings, and listings

Paste seller URLs or numeric IDs. Returns rating breakdown, follower count, total sales, badges, and optionally the seller's active and sold listings.

```json
{ "mode": "seller", "sellerUrls": ["474702850"], "includeListings": true, "listingStatus": "both", "maxItemsPerSeller": 50 }
```

### How to scrape Mercari Japan: step by step

1. [Create a free Apify account](https://console.apify.com/sign-up). Takes 30 seconds, no card needed.
2. Open [Mercari Scraper](https://console.apify.com/actors/OWKSRCO6uZOeT0bFr?addFromActorId=OWKSRCO6uZOeT0bFr) in the Apify Console.
3. Pick a mode and paste a keyword, or item/seller URLs.
4. Click **Start**. Most runs finish in under a minute.
5. Export as JSON, CSV, or Excel, or fetch via API.

### How much does Mercari Scraper cost?

You pay **$5 for 1,000 results**, flat across all three modes. The Apify Free plan includes $5 in monthly credits, about 1,000 results. The $29/month Starter plan covers roughly 5,800 results a month. There is no meaningful per-run fee and no subscription lock-in.

### Input

```json
{
  "mode": "search",
  "keyword": "nike",
  "status": "on_sale",
  "sort": "created",
  "order": "desc",
  "priceMin": 2000,
  "priceMax": 20000,
  "maxItems": 100
}
```

| Field | Type | Default | Notes |
|---|---|---|---|
| `mode` | string | `search` | `search`, `item`, or `seller`. |
| `keyword` | string | none | Search term (search mode). |
| `startUrls` | array | none | Search, category, or brand URLs (search mode). |
| `itemUrls` | array | none | Item URLs or IDs (item mode). |
| `sellerUrls` | array | none | Seller URLs or numeric IDs (seller mode). |
| `status` | string | `on_sale` | `on_sale`, `sold_out` (comps), or `all`. |
| `sort` | string | `score` | `score`, `created`, `price`, or `likes`. |
| `priceMin` / `priceMax` | integer | none | Price range in JPY. |
| `includeTranslation` | boolean | `false` | Add English title and description (item mode). |
| `includeListings` | boolean | `true` | Fetch the seller's items (seller mode). |
| `listingStatus` | string | `active` | `active`, `sold`, or `both` (seller mode). |
| `maxItems` | integer | `100` | Cap on records for the run. |

### Output

Search / item record:

```json
{
  "recordType": "item",
  "id": "m39120191169",
  "url": "https://jp.mercari.com/item/m39120191169",
  "name": "NIKE スニーカー ホワイト ブラック ゴールド",
  "price": 3600,
  "currency": "JPY",
  "status": "ITEM_STATUS_ON_SALE",
  "isSold": false,
  "condition": { "id": "2", "name": "Almost new" },
  "brand": { "id": "857", "name": "NIKE" },
  "sizes": [{ "id": "11", "name": "27cm" }],
  "categoryBreadcrumb": ["Fashion", "Men's Fashion", "Shoes", "Sneakers"],
  "numLikes": 4,
  "numComments": 2,
  "comments": [{ "user": "...", "message": "...", "created": 1779990000 }],
  "description": "...",
  "shippingMethod": "RakuRaku Mercari Shipping",
  "sellerId": "791654963",
  "sellerName": "...",
  "sellerStarRating": 5,
  "sellerNumRatings": 211,
  "sellerNumSellItems": 171,
  "sellerIsOfficial": false,
  "translatedName": "NIKE Sneakers White Black Gold",
  "updated": 1780029726
}
```

Seller record:

```json
{
  "recordType": "seller",
  "sellerId": "474702850",
  "sellerName": "古着屋アリーヤ",
  "starRatingScore": 5,
  "numRatings": 12357,
  "ratings": { "good": 12237, "normal": 2, "bad": 118 },
  "followerCount": 6755,
  "numSellItems": 15379,
  "badges": [{ "id": "10004", "name": "Highly Rated" }],
  "isOfficial": false
}
```

### Use cases

- 💴 **Resale and arbitrage:** pull sold comps to price inventory and spot underpriced listings.
- 📊 **Brand and category research:** track price, condition, and supply for a brand across thousands of listings.
- 🧲 **Seller scouting:** surface high-rating, high-volume sellers with follower counts and trust badges.
- 📈 **Demand signals:** use like and comment counts to gauge interest in an item or category.
- 👟 **Sneaker and streetwear tracking:** monitor hype brands by size, condition, and sold price.
- 🗃️ **Catalog building:** collect structured item data with photos, sizes, and category breadcrumbs.

### Limitations

- **Mercari Japan only.** This actor covers jp.mercari.com, not the US Mercari site.
- **Sold time is approximate.** Sold listings carry a last-updated timestamp as a sold-time proxy; Mercari does not expose an exact sale date.
- **Search caps at 15,000 results** per query, the limit Mercari itself returns.
- **Seller listings cap at 120 per status** (active or sold) in a single run.
- **Likes and comments are in item-detail mode.** Search records carry a liked flag; the full like count and comment threads come from item mode.

### FAQ

#### How much does Mercari Scraper cost?

Mercari Scraper uses pay-per-result pricing. You pay **$5 for 1,000 results**. The Apify Free plan gives you $5 in usage credits a month, enough for around 1,000 results. If you run regularly, the $29/month Starter plan covers about 5,800 results.

No subscription lock-in. Pause whenever.

#### Is it legal to scrape Mercari?

Scraping public data is generally allowed in the US and most of the EU, as long as you don't collect personal data covered by GDPR or CCPA without a lawful basis. This actor only touches publicly accessible pages, but how you use the output is on you.

Apify's full breakdown: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

#### Can I integrate Mercari Scraper with other tools?

Push results into **Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, Google Drive**, and more. Apify treats every actor as a webhook source, so anything that consumes webhooks or pulls from an API works.

Full list: [Apify integrations](https://docs.apify.com/platform/integrations).

#### Can I use Mercari Scraper with the Apify API?

Yes. Every run is available via the Apify REST API:

```bash
curl -X POST "https://api.apify.com/v2/acts/sourabhbgp~mercari-scraper/runs?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode": "search", "keyword": "nike", "maxItems": 100}'
```

Docs: [Apify API reference](https://docs.apify.com/api/v2).

#### Can I use Mercari Scraper through an MCP Server?

Yes. Apify ships an MCP server that exposes every actor as a tool, so Claude Desktop, Cursor, and any other MCP-capable client can call Mercari Scraper. Setup: [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp).

### Your feedback

Bug, missing field, or odd behavior? Drop a note in the [Issues tab](https://console.apify.com/actors/OWKSRCO6uZOeT0bFr/issues). Reports go to a human and fixes usually ship the same week.

# Actor input Schema

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

What to scrape.

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

Keyword for search mode.

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

Mercari JP search, category, or brand URLs (search mode).

## `itemUrls` (type: `array`):

Mercari JP item URLs or IDs (item mode).

## `sellerUrls` (type: `array`):

Mercari JP seller profile URLs or numeric IDs (seller mode).

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

Filter by status. Use sold\_out for sold comps.

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

Sort order for search results.

## `order` (type: `string`):

Ascending or descending.

## `priceMin` (type: `integer`):

Minimum price filter in Japanese yen.

## `priceMax` (type: `integer`):

Maximum price filter in Japanese yen.

## `categoryId` (type: `array`):

Filter search by Mercari category IDs.

## `brandId` (type: `array`):

Filter search by Mercari brand IDs.

## `itemConditionId` (type: `array`):

Filter by item condition IDs, 1 (new) to 6 (poor).

## `shippingPayerId` (type: `array`):

Filter by who pays shipping: 1 seller, 2 buyer.

## `sizeId` (type: `array`):

Filter search by Mercari size IDs.

## `includeListings` (type: `boolean`):

Seller mode: also fetch the seller's items.

## `listingStatus` (type: `string`):

Which seller listings to fetch.

## `maxItemsPerSeller` (type: `integer`):

Cap on listings fetched per seller (max 120 per status).

## `includeTranslation` (type: `boolean`):

Item mode: add EN title/description.

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

Maximum records to return for the run.

## `maxConcurrency` (type: `integer`):

Parallel requests: item URLs, sellers, and search URLs run concurrently up to this limit.

## `useResidentialProxy` (type: `boolean`):

Escalate to JP residential on failure. Not normally needed.

## Actor input object example

```json
{
  "mode": "search",
  "keyword": "nike",
  "status": "on_sale",
  "sort": "score",
  "order": "desc",
  "includeListings": true,
  "listingStatus": "active",
  "maxItemsPerSeller": 50,
  "includeTranslation": false,
  "maxItems": 100,
  "maxConcurrency": 8,
  "useResidentialProxy": false
}
```

# Actor output Schema

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

View the scraped records in the dataset.

# 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("sourabhbgp/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("sourabhbgp/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 sourabhbgp/mercari-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mercari Scraper - Listings, Sold Comps, Sellers",
        "description": "Scrape Mercari (Mercari Japan) listings, sold prices, item details, and seller profiles. Search by keyword, category, or brand, pull sold comps for resale pricing, and get likes, comments, ratings, and English translation. Pay per result, no subscription.",
        "version": "0.0",
        "x-build-id": "570Hz71OOVRSl20ft"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sourabhbgp~mercari-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sourabhbgp-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/sourabhbgp~mercari-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sourabhbgp-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/sourabhbgp~mercari-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sourabhbgp-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "item",
                            "seller"
                        ],
                        "type": "string",
                        "description": "What to scrape.",
                        "default": "search"
                    },
                    "keyword": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Keyword for search mode.",
                        "default": "nike"
                    },
                    "startUrls": {
                        "title": "Search / category / brand URLs",
                        "type": "array",
                        "description": "Mercari JP search, category, or brand URLs (search mode).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "itemUrls": {
                        "title": "Item URLs or IDs",
                        "type": "array",
                        "description": "Mercari JP item URLs or IDs (item mode).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sellerUrls": {
                        "title": "Seller URLs or IDs",
                        "type": "array",
                        "description": "Mercari JP seller profile URLs or numeric IDs (seller mode).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "status": {
                        "title": "Listing status",
                        "enum": [
                            "on_sale",
                            "sold_out",
                            "all"
                        ],
                        "type": "string",
                        "description": "Filter by status. Use sold_out for sold comps.",
                        "default": "on_sale"
                    },
                    "sort": {
                        "title": "Sort by",
                        "enum": [
                            "score",
                            "created",
                            "price",
                            "likes"
                        ],
                        "type": "string",
                        "description": "Sort order for search results.",
                        "default": "score"
                    },
                    "order": {
                        "title": "Sort order",
                        "enum": [
                            "desc",
                            "asc"
                        ],
                        "type": "string",
                        "description": "Ascending or descending.",
                        "default": "desc"
                    },
                    "priceMin": {
                        "title": "Min price (JPY)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price filter in Japanese yen."
                    },
                    "priceMax": {
                        "title": "Max price (JPY)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price filter in Japanese yen."
                    },
                    "categoryId": {
                        "title": "Category IDs",
                        "type": "array",
                        "description": "Filter search by Mercari category IDs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "brandId": {
                        "title": "Brand IDs",
                        "type": "array",
                        "description": "Filter search by Mercari brand IDs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "itemConditionId": {
                        "title": "Condition IDs (1-6)",
                        "type": "array",
                        "description": "Filter by item condition IDs, 1 (new) to 6 (poor).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "shippingPayerId": {
                        "title": "Shipping payer IDs (1-2)",
                        "type": "array",
                        "description": "Filter by who pays shipping: 1 seller, 2 buyer.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sizeId": {
                        "title": "Size IDs",
                        "type": "array",
                        "description": "Filter search by Mercari size IDs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeListings": {
                        "title": "Include seller listings",
                        "type": "boolean",
                        "description": "Seller mode: also fetch the seller's items.",
                        "default": true
                    },
                    "listingStatus": {
                        "title": "Seller listing status",
                        "enum": [
                            "active",
                            "sold",
                            "both"
                        ],
                        "type": "string",
                        "description": "Which seller listings to fetch.",
                        "default": "active"
                    },
                    "maxItemsPerSeller": {
                        "title": "Max items per seller",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap on listings fetched per seller (max 120 per status).",
                        "default": 50
                    },
                    "includeTranslation": {
                        "title": "Include English translation",
                        "type": "boolean",
                        "description": "Item mode: add EN title/description.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum records to return for the run.",
                        "default": 100
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Parallel requests: item URLs, sellers, and search URLs run concurrently up to this limit.",
                        "default": 8
                    },
                    "useResidentialProxy": {
                        "title": "Use residential proxy fallback",
                        "type": "boolean",
                        "description": "Escalate to JP residential on failure. Not normally needed.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
