# Coupang Eats Scraper (`amit123/coupang-eats-scraper`) Actor

Extract restaurants, menus, prices, ratings, and delivery info from **Coupang Eats (쿠팡이츠)** — South Korea's #2 food delivery platform and one half of a fast-tightening duopoly that now controls ~88% of the Korean delivery market.

- **URL**: https://apify.com/amit123/coupang-eats-scraper.md
- **Developed by:** [Amit](https://apify.com/amit123) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.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

## 🍱 Coupang Eats Crawler

Extract restaurants, menus, prices, ratings, and delivery info from **Coupang Eats (쿠팡이츠)** — South Korea's #2 food delivery platform and one half of a fast-tightening duopoly that now controls ~88% of the Korean delivery market.

---

### 🌏 What is Coupang Eats?

Coupang Eats is the food-delivery arm of **Coupang**, Korea's largest e-commerce company (the "Amazon of Korea", NYSE-listed CPNG). Coupang Eats launched in 2019 as a third-place challenger to Baemin (Baedal Minjok) and Yogiyo. As of May 2026 it has overtaken Yogiyo and become the clear #2:

| Platform | Weekly Active Users (May 2026) | Market position |
|---|---|---|
| **Baemin** (Baedal Minjok) | ~12M | #1 |
| **Coupang Eats** | **8.45M** | **#2 — fast growing** |
| Yogiyo | ~2M | distant #3 |

Baemin + Coupang Eats together hold **88.3% of Korea's delivery app market** — the highest concentration on record. Korea is now effectively a duopoly, and Coupang Eats is the side that's still gaining share, largely because every Coupang Wow membership (Coupang's Amazon-Prime equivalent, ~15M subscribers paying ₩7,890/month) bundles free Eats delivery into the subscription.

The platform is **address-gated**: every search, category browse, and store ranking is computed relative to a delivery point (latitude + longitude). The same restaurant can rank #1 in Gangnam and not appear at all in Hongdae 8 km away.

#### 🇺🇸 US equivalent
- **DoorDash** — closest by market structure (the dominant scale player whose growth was unlocked by the DashPass subscription bundle).
- **Uber Eats** — closest by parent-company logic (a delivery service riding on top of a bigger consumer platform's logistics + payments + identity).

---

### 🚀 What does this actor do?

Extracts **restaurant listings and menus** from Coupang Eats. You can:

- Provide one or more **delivery addresses** (`addresses`) — required for search/category browsing because Coupang Eats results depend on the delivery location.
- Provide **search queries** (`searchQueries`) — Korean *or* English. Use Korean (`치킨`, `피자`, `떡볶이`) for the broadest results; English (`Starbucks`, `McDonald's`, `pizza`) works for global chains and cafes with English names.
- Provide **category IDs** (`categoryIds`) — browses each category at each address.
- Provide **direct store IDs** (`storeIds`) — fetches each store; no address required.
- Mix any combination in a single run.

You give it inputs, it returns the dataset.

---

### 🍗 Why this data matters (buyer personas)

Food-delivery data has more independent buyer personas than almost any other vertical — that's what makes it a high-margin scraping target.

| Buyer | What they use the data for | Refresh cadence |
|---|---|---|
| **Hedge fund / alt-data desks** | "How many restaurants did Coupang Eats add this quarter? Is Baemin pushing harder on discounting? Use weekly catalog deltas as a leading indicator on CPNG and on the privately held Baemin parent (Woowa/DH)." | Daily / weekly |
| **Restaurant brands & franchises** | "Where is BBQ Chicken under-distributed? What's our menu pricing vs Kyochon and bhc, per district?" | Daily |
| **Brand-protection / IP teams** | "Find restaurants illegally selling our trademarked menu items or impersonating our brand." | Daily |
| **F&B market-research firms** | "What's the average delivery fee in Gangnam vs Jeju? How often do new openings stick after 90 days?" | Weekly / monthly |
| **Restaurant SaaS (POS, ad tools)** | "Cold-call lists of independents on Coupang Eats sorted by review count — they're the ones doing volume." | Monthly |
| **Cross-border quick-commerce expansion teams** | DoorDash / Uber / Wolt strategy desks studying the Korean duopoly playbook (Wow-membership bundle). | Quarterly |
| **Logistics & last-mile** | Delivery time benchmarks per district + time-of-day; courier-supply intelligence. | Weekly |
| **Consumer-trend / agencies** | What cuisines are trending? Which delivery times are demanded most? Promotion-frequency analysis. | Weekly |

These personas pay separately, which lets you stack the same dataset into multiple revenue streams instead of competing on a single buyer.

---

### 🗾️ Example input

**Search by keyword at a single address (most common) — works in Korean *or* English:**
```json
{
  "addresses": [
    { "latitude": 37.4979, "longitude": 127.0276, "label": "Gangnam, Seoul" }
  ],
  "searchQueries": ["치킨", "피자", "Starbucks"],
  "maxPagesPerQuery": 1
}
````

**Browse categories across multiple districts:**

```json
{
  "addresses": [
    { "latitude": 37.4979, "longitude": 127.0276, "label": "Gangnam" },
    { "latitude": 37.5563, "longitude": 126.9236, "label": "Hongdae" },
    { "latitude": 35.1796, "longitude": 129.0756, "label": "Busan Seomyeon" }
  ],
  "categoryIds": ["1", "2", "3"],
  "maxPagesPerQuery": 3
}
```

**Direct store fetch by ID (no address required):**

```json
{
  "storeIds": ["461101", "837003"],
  "fetchMenu": true
}
```

**Mix everything:**

```json
{
  "addresses": [
    { "latitude": 37.4979, "longitude": 127.0276, "label": "Gangnam" }
  ],
  "searchQueries": ["치킨", "pizza"],
  "categoryIds": ["1"],
  "storeIds": ["461101"],
  "fetchMenu": true,
  "maxPagesPerQuery": 2
}
```

***

### 📦 What data do you get?

Every restaurant is returned with the following fields:

```json
{
  "store_id": "461101",
  "name": "BBQ치킨 강남점",
  "name_en": null,
  "categories": ["치킨", "한식"],
  "category_id": null,
  "rating_avg": 4.7,
  "rating_count": 1234,
  "review_count": 1234,
  "address": "서울 강남구 테헤란로 152",
  "address_road": "테헤란로 152",
  "lat": 37.4979,
  "lng": 127.0276,
  "phone": null,
  "delivery_fee_min": 0,
  "delivery_fee_max": 3000,
  "delivery_fee_text": "0원 ~ 3,000원",
  "delivery_time_min": 25,
  "delivery_time_max": 35,
  "minimum_order_amount": 15000,
  "currency": "KRW",
  "is_coupang_delivery": true,
  "is_wow_free_delivery": true,
  "is_open": true,
  "is_new": false,
  "is_promoted": false,
  "discount_badge": "20% 할인",
  "promotion_text": "신규 가입 5,000원 쿠폰",
  "thumbnail": "https://image.coupangcdn.com/.../bbq.jpg",
  "images": [],
  "hours": null,
  "menu_count": 12,
  "menu": [
    {
      "menu_item_id": "...",
      "name": "황금올리브 치킨",
      "price": 23000,
      "original_price": null,
      "description": "바삭한 후라이드 치킨",
      "thumbnail": "https://...",
      "is_signature": true,
      "is_popular": true,
      "options": []
    }
  ],
  "search_query": "치킨",
  "search_rank": 1,
  "search_address_label": "Gangnam",
  "search_lat": 37.4979,
  "search_lng": 127.0276,
  "store_url": "https://web.coupangeats.com/share?storeId=461101",
  "scraped_at": "2026-06-09T13:42:24.433Z"
}
```

#### Field reference

| Field | Type | Notes |
|---|---|---|
| `store_id` | string | Coupang Eats numeric store ID (the `storeId` in the share URL) |
| `name`, `name_en` | string | Restaurant name (Korean; English when available) |
| `categories` | array | Cuisine categories (치킨, 한식, 일식, etc.) |
| `category_id` | string | Set when the store was found via a category browse |
| `rating_avg` | number | Average review rating (0–5) |
| `rating_count` / `review_count` | number | Total review count |
| `address`, `address_road` | string | Full address and road-name address (도로명 주소) |
| `lat`, `lng` | number | Restaurant coordinates |
| `phone` | string | Phone (often null — many stores hide this) |
| `delivery_fee_min`, `delivery_fee_max` | number | Delivery fee range in KRW (varies by distance / promotions) |
| `delivery_fee_text` | string | Original humanised fee string when not numeric |
| `delivery_time_min`, `delivery_time_max` | number | Estimated delivery time in minutes |
| `minimum_order_amount` | number | Minimum order in KRW |
| `currency` | string | Always `"KRW"` |
| `is_coupang_delivery` | bool | True when delivered by Coupang's own fleet (쿠팡배달), not the restaurant's |
| `is_wow_free_delivery` | bool | True when the store qualifies for free delivery under a Coupang Wow membership |
| `is_open` | bool | Currently accepting orders |
| `is_new` | bool | Recently opened on the platform |
| `is_promoted` | bool | Paid placement (Coupang Eats ads) |
| `discount_badge` | string | E.g. `"20% 할인"` |
| `promotion_text` | string | Free-form promo text |
| `thumbnail` | string | Primary restaurant image URL |
| `images` | array | Additional images |
| `hours` | object | Operating hours per day-of-week (when available) |
| `menu_count` | number | Number of items in the menu (populated when `fetchMenu=true` or when listings inline the menu) |
| `menu` | array | Menu items with name, price, description, thumbnail, options |
| `search_query` | string | Set when the store was found via a search |
| `search_rank` | number | Position in the listing |
| `search_address_label`, `search_lat`, `search_lng` | string/number | The address slice this result was collected under |
| `store_url` | string | Public share URL — `https://web.coupangeats.com/share?storeId={store_id}` |
| `scraped_at` | string | ISO timestamp when the page was extracted |

***

### 🦖 How to use

1. Enter at least one input source — `addresses` + `searchQueries` / `categoryIds`, OR `storeIds`.
2. Optionally set `maxPagesPerQuery` (default `1`) and `fetchMenu` (default `false`).
3. Run the actor.
4. Download the results from the **Dataset** tab or fetch them via the **API**.

> **Note:** A run with 1 address × 3 queries × 1 page completes in under 10 seconds.

***

### 🔍 Key features

- **Fast** — most runs complete in seconds, not minutes.
- **Geo-aware search** — every search/category is anchored to a real delivery address, so rankings match what a Gangnam customer would actually see.
- **Three input modes** — keyword search, category browsing, and direct store fetch — mixable in one run.
- **Search in Korean or English** — Korean returns more results, English works great for global chains.
- **Structured output** — 40+ fields per restaurant, plus optional embedded menu array.
- **Automatic retries** — transient errors are retried with exponential backoff.

***

### 📋 Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `addresses` | array of `{latitude, longitude, label}` | `[]` | Delivery addresses to browse from. Required when using `searchQueries` or `categoryIds`. |
| `searchQueries` | array of strings | `[]` | Search keywords — Korean or English. Korean returns the broadest results; English works for global chains and English-named cafes. |
| `categoryIds` | array of strings | `[]` | Numeric Coupang Eats category IDs (e.g. `1` for chicken). |
| `storeIds` | array of strings | `[]` | Direct numeric store IDs — no address required. |
| `maxPagesPerQuery` | integer | `1` | Pages to walk per search/category at each address. Each page ≈ 20 stores. |
| `fetchMenu` | boolean | `false` | Attach the full menu and additional store fields to each discovered store. |
| `proxyConfiguration` | object | none | Optional. Not required for normal runs. |

#### Common address coordinates (for testing)

| District | Latitude | Longitude |
|---|---|---|
| Seoul — Gangnam Station | 37.4979 | 127.0276 |
| Seoul — Hongdae | 37.5563 | 126.9236 |
| Seoul — Itaewon | 37.5347 | 126.9947 |
| Seoul — Jongno | 37.5703 | 126.9824 |
| Busan — Seomyeon | 35.1796 | 129.0756 |
| Daegu — Dongseong-ro | 35.8693 | 128.5953 |
| Incheon — Songdo | 37.3831 | 126.6562 |
| Jeju City | 33.4996 | 126.5312 |

***

### 📩 Feedback

Found a bug or have ideas? Open an issue on the actor's Apify page — happy to improve it.

# Actor input Schema

## `addresses` (type: `array`):

Delivery addresses to browse from. Coupang Eats results depend on the delivery location — every search/category browse needs a delivery point. Each item: { latitude, longitude, label }. Example Seoul Gangnam: { "latitude": 37.4979, "longitude": 127.0276, "label": "Gangnam" }.

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

Search keywords — Korean or English. Korean (치킨, 피자, 떡볶이) returns the broadest results. English (Starbucks, McDonald's, pizza) works great for global chains and English-named cafes. Each query runs at each address.

## `categoryIds` (type: `array`):

Numeric Coupang Eats category IDs to browse at each address. Common starter: 1 (chicken).

## `storeIds` (type: `array`):

Numeric Coupang Eats store IDs. Returns the full store + menu. No address required.

## `maxPagesPerQuery` (type: `integer`):

Maximum number of result pages to collect per search/category at each address. Each page is roughly 20 stores. Default 1.

## `fetchMenu` (type: `boolean`):

If true, the actor attaches the full menu and additional store fields to each discovered restaurant. Slower but turns the dataset into a complete catalog.

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

Optional. Not required for normal runs.

## Actor input object example

```json
{
  "addresses": [
    {
      "latitude": 37.4979,
      "longitude": 127.0276,
      "label": "Gangnam, Seoul"
    }
  ],
  "searchQueries": [
    "치킨",
    "Starbucks"
  ],
  "maxPagesPerQuery": 1,
  "fetchMenu": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `restaurants` (type: `string`):

Flat dataset of restaurants. One row per restaurant per slice (address × search query / category). Includes name, address, GPS, rating, delivery fee, ETA, minimum order, and optional embedded menu when fetchMenu=true.

## `rawSamples` (type: `string`):

First-page raw JSON response of every search/category/store source. Useful for debugging or discovering category IDs.

# 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 = {
    "addresses": [
        {
            "latitude": 37.4979,
            "longitude": 127.0276,
            "label": "Gangnam, Seoul"
        }
    ],
    "searchQueries": [
        "치킨",
        "Starbucks"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("amit123/coupang-eats-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 = {
    "addresses": [{
            "latitude": 37.4979,
            "longitude": 127.0276,
            "label": "Gangnam, Seoul",
        }],
    "searchQueries": [
        "치킨",
        "Starbucks",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("amit123/coupang-eats-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 '{
  "addresses": [
    {
      "latitude": 37.4979,
      "longitude": 127.0276,
      "label": "Gangnam, Seoul"
    }
  ],
  "searchQueries": [
    "치킨",
    "Starbucks"
  ]
}' |
apify call amit123/coupang-eats-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Coupang Eats Scraper",
        "description": "Extract restaurants, menus, prices, ratings, and delivery info from **Coupang Eats (쿠팡이츠)** — South Korea's #2 food delivery platform and one half of a fast-tightening duopoly that now controls ~88% of the Korean delivery market.",
        "version": "0.0",
        "x-build-id": "iTI5jwSSX2fr40hnc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/amit123~coupang-eats-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-amit123-coupang-eats-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/amit123~coupang-eats-scraper/runs": {
            "post": {
                "operationId": "runs-sync-amit123-coupang-eats-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/amit123~coupang-eats-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-amit123-coupang-eats-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": {
                    "addresses": {
                        "title": "Addresses (lat/lng)",
                        "type": "array",
                        "description": "Delivery addresses to browse from. Coupang Eats results depend on the delivery location — every search/category browse needs a delivery point. Each item: { latitude, longitude, label }. Example Seoul Gangnam: { \"latitude\": 37.4979, \"longitude\": 127.0276, \"label\": \"Gangnam\" }."
                    },
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Search keywords — Korean or English. Korean (치킨, 피자, 떡볶이) returns the broadest results. English (Starbucks, McDonald's, pizza) works great for global chains and English-named cafes. Each query runs at each address.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryIds": {
                        "title": "Category IDs",
                        "type": "array",
                        "description": "Numeric Coupang Eats category IDs to browse at each address. Common starter: 1 (chicken).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "storeIds": {
                        "title": "Direct Store IDs",
                        "type": "array",
                        "description": "Numeric Coupang Eats store IDs. Returns the full store + menu. No address required.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPagesPerQuery": {
                        "title": "Max Pages Per Query",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of result pages to collect per search/category at each address. Each page is roughly 20 stores. Default 1.",
                        "default": 1
                    },
                    "fetchMenu": {
                        "title": "Fetch full menu per store",
                        "type": "boolean",
                        "description": "If true, the actor attaches the full menu and additional store fields to each discovered restaurant. Slower but turns the dataset into a complete catalog.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration (optional)",
                        "type": "object",
                        "description": "Optional. Not required for normal runs.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
