# Gmarket KR  $1💰 URL Keyword and Review Scraper (`abotapi/gmarket-global-scraper`) Actor

Scrape product listings and customer reviews from Gmarket.co.kr into clean JSON datasets. Supports keyword search, product URLs, or review-only mode by product ID. Lightweight, free-tier friendly, and runs without a browser.

- **URL**: https://apify.com/abotapi/gmarket-global-scraper.md
- **Developed by:** [AbotAPI](https://apify.com/abotapi) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 3 total users, 2 monthly users, 91.7% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Gmarket Global Scraper

> Sample shape below is illustrative; values are placeholders, not from a live listing.

Pull product listings AND customer reviews from Gmarket Global (the English-language storefront of one of Korea's biggest marketplaces) into a clean JSON dataset. Two modes: keyword search or URL paste. One toggle flips the same flow from "one record per product" to "one record per review." Detail enrichment is on by default and adds the full seller disclosure (business name, manager, customer-service phone, business registration, e-commerce registration).

### Why this scraper

* 25+ product fields per record, with optional detail enrichment that adds the legally-mandated Korean seller info (company name, manager name, customer-service phone, business registration number, e-commerce sales registration).
* Flip "Reviews only" to scrape reviews of every matching product instead of the products themselves.
* English titles by default (the global storefront serves English).
* KRW and USD prices side by side, plus original-vs-sale price and discount percent.
* Every record also carries a `raw` block with the verbatim upstream API response, so no field is ever silently dropped.
* Datacenter proxy works out of the box on the free Apify plan.

### Data you get

#### Product records (default)

| Field | Example |
| --- | --- |
| goodsCode | "0000000001" |
| title | "Sample Product Title" |
| linkUrl | "https://mg.gmarket.co.kr/Item?goodscode=0000000001" |
| imageUrl | "https://gdimg.gmarket.co.kr/0000000001/still/280?ver=0" |
| additionalImages | ["https://gdimg.gmarket.co.kr/.../shop_img/000/000/0000000001.jpg"] |
| sellPriceKrw | 22800 |
| originalPriceKrw | "22,800" |
| salePriceKrw | "22,800" |
| currencyPrice | "$15.75" |
| discountRate | "0" |
| isFreeShipping | true |
| deliveryInfo | "Free" |
| deliveryFee | "0" |
| sellerCustNo | "000000000" |
| miniShopHandle | "samplestore" |
| miniShopUrl | "https://mg.gmarket.co.kr/samplestore" |
| categoryCodeL | "100000000" |
| categoryCodeM | "200000000" |
| categoryCodeS | "300000000" |
| overseaDeliveryAvailable | true |
| isBigSmile | false |
| isAdult | false |
| translation.english | true |
| translation.chinese | true |
| translation.japanese | false |
| raw | `{ ...full upstream Item JSON... }` |
| scrapedAt | "2026-01-01T00:00:00.000Z" |

When `fetchDetails` is on (the default), each record also carries:

| Field | Example |
| --- | --- |
| descriptionText | "Up to 3,000 chars of cleaned product description." |
| brand | "SampleBrand" |
| sellerCompanyName | "Sample Trading Co., Ltd." |
| sellerManagerName | "John Doe" |
| sellerPhone | "02-0000-0000" |
| sellerBusinessNumber | "000-00-00000" |
| sellerEcommerceNumber | "0000-Seoul-0000" |
| sellerInfo | `{ ...full upstream SellerInfo JSON: 15 fields... }` |

#### Review records (when `reviewsOnly` is on)

The actor still uses your keyword or URL input to discover products, but pushes one record per review instead of one per product.

| Field | Example |
| --- | --- |
| productGoodsCode | "0000000001" |
| productLinkUrl | "https://mg.gmarket.co.kr/Item?goodscode=0000000001" |
| reviewId | "100000000" |
| authorNickname | "abc****" (Gmarket-masked) |
| authorLoginId | "abc1234" (the un-masked login, passed through verbatim) |
| authorCustNo | "0000000000" |
| authorCountryCode | "KR" |
| rating | 9 |
| ratingMax | 10 |
| deliveryRating | 5 |
| title | "Sample review title" |
| comment | "Sample comment body" |
| titleEnglish | "Sample title translated" |
| commentEnglish | "Sample comment translated" |
| reviewDate | "2026-01-01T00:00:00.000Z" |
| reviewDateText | "2026.01.01" |
| hasPhotos | true |
| photoUrls | ["https://bampic.gmarket.co.kr/..."] |
| variantInfo | "Color: Black [1ea]" |
| sellerReply | null |
| sellerReplyDate | null |
| isPowerReviewer | true |
| readCount | 0 |
| raw | `{ ...full upstream review JSON, 40 fields... }` |
| scrapedAt | "2026-01-01T00:00:00.000Z" |

### How to use

Keyword search, default settings (detail enrichment on, 1 page):

```json
{
  "mode": "search",
  "keywords": ["laptop"]
}
````

Keyword search with price band, oversea-only, multi-keyword, deeper pagination:

```json
{
  "mode": "search",
  "keywords": ["headphones", "earbuds"],
  "minPrice": 10000,
  "maxPrice": 100000,
  "overseaDeliveryOnly": true,
  "maxPages": 3
}
```

URL mode (paste any Gmarket Global search URL with whatever filters you want):

```json
{
  "mode": "url",
  "urls": ["https://mg.gmarket.co.kr/Search/Search?keyword=phone&minPrice=50000&maxPrice=500000"],
  "maxPages": 2
}
```

Reviews only (pulls reviews of every product matching your search; caps total reviews at maxListings):

```json
{
  "mode": "search",
  "keywords": ["laptop"],
  "reviewsOnly": true,
  "maxReviewsPerProduct": 20,
  "maxListings": 100
}
```

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| mode | enum | "search" | "search" uses keywords + filters; "url" uses pasted search-result URLs |
| keywords | array of strings | \["laptop"] | One or more product keywords; English or Korean both work. Search mode only |
| minPrice | integer | 0 | Min sale price in KRW. 0 = no minimum |
| maxPrice | integer | 0 | Max sale price in KRW. 0 = no maximum |
| overseaDeliveryOnly | boolean | false | Restrict to items that ship outside Korea |
| bigSmileOnly | boolean | false | Restrict to BigSmile sitewide promotion items |
| urls | array of strings | \[...] | One entry per search. URL mode only |
| reviewsOnly | boolean | false | Push one record per review instead of one per product. Uses the same search/URL flow to discover products first |
| maxReviewsPerProduct | integer | 50 | Reviews-only mode: stop after N reviews per product (20 per page) |
| maxPages | integer | 1 | Pages to walk per keyword / URL (60 items per page). Increase for deeper scrapes |
| maxListings | integer | 0 | Cap on TOTAL records output (products or reviews depending on `reviewsOnly`). 0 = unlimited |
| fetchDetails | boolean | true | Fetch product detail pages to populate description, brand, and the full seller disclosure. Turn off for a leaner, faster scrape |
| proxy | proxy | Apify Datacenter | Network. Datacenter works fine; residential rarely needed |

### Output example (product, with fetchDetails: true)

```json
{
  "goodsCode": "0000000001",
  "title": "Sample Product Title",
  "linkUrl": "https://mg.gmarket.co.kr/Item?goodscode=0000000001",
  "imageUrl": "https://gdimg.gmarket.co.kr/0000000001/still/280?ver=0",
  "sellPriceKrw": 22800,
  "currencyPrice": "$15.75",
  "discountRate": "0",
  "sellerCompanyName": "Sample Trading Co., Ltd.",
  "sellerManagerName": "John Doe",
  "sellerPhone": "02-0000-0000",
  "sellerBusinessNumber": "000-00-00000",
  "sellerEcommerceNumber": "0000-Seoul-0000",
  "sellerInfo": {
    "CompanyName": "Sample Trading Co., Ltd.",
    "ManagerName": "John Doe",
    "HelpDeskStartDate": "10",
    "HelpDeskEndDate": "16",
    "HelpDeskTelNo": "02-0000-0000",
    "CompanyNo": "000-00-00000",
    "EcomerceNo": "0000-Seoul-0000",
    "SellerGrade": "A1",
    "DealerSatisGrade": "AA"
  },
  "descriptionText": "Sample product description text.",
  "brand": "SampleBrand",
  "overseaDeliveryAvailable": true,
  "translation": { "english": true, "chinese": true, "japanese": false },
  "scrapedAt": "2026-01-01T00:00:00.000Z"
}
```

### Plan requirement

Works on any Apify plan, including the Free plan, because the default proxy is Apify Datacenter. If you ever see zero results from Apify Datacenter, switch the proxy to Apify Residential (Starter plan or higher) and try again.

# Actor input Schema

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

Pick how you want to drive the scrape. 'Keyword search' uses your keywords + filters; 'Paste URLs' uses Gmarket Global search-result URLs you already have.

## `keywords` (type: `array`):

One or more product keywords to search for (English or Korean both work). One run = one search per keyword × applied filters. Only used when mode is 'Keyword search'.

## `minPrice` (type: `integer`):

Minimum sale price in Korean Won. Leave 0 for no minimum. Example: 10000 (≈ $7 USD).

## `maxPrice` (type: `integer`):

Maximum sale price in Korean Won. Leave 0 for no maximum. Example: 100000 (≈ $70 USD).

## `overseaDeliveryOnly` (type: `boolean`):

When on, returns only items that ship outside Korea. Verified to narrow results by ~75% on broad queries.

## `bigSmileOnly` (type: `boolean`):

When on, returns only items participating in the BigSmile sitewide promotion.

## `urls` (type: `array`):

One or more Gmarket Global search-result URLs (must contain /Search/Search?keyword=...). Filter fields above are ignored in this mode; the URL's own query parameters are the filters. Forward pagination starts from the page in the URL.

## `reviewsOnly` (type: `boolean`):

When on, the actor still uses your keyword search or pasted URLs to discover products, but pushes one record per REVIEW instead of one record per product. Pair with maxReviewsPerProduct to cap how deep to walk each product.

## `maxReviewsPerProduct` (type: `integer`):

Only applies when 'Reviews only' is on. Stop after this many reviews per product. The API serves 20 per page; 50 = up to 3 pages each. Set 0 to walk every review the product has. Reviews come back in Gmarket's default order (typically featured first; the storefront does not expose a sort control).

## `maxPages` (type: `integer`):

How many pages to walk per keyword (or per URL). The API serves 60 items per page, so 1 page returns up to 60 products. Increase for deeper scrapes.

## `maxListings` (type: `integer`):

Stop the whole run once this many unique records have been collected. When 'Reviews only' is off this counts products; when on it counts reviews across all products. Set 0 to disable.

## `fetchDetails` (type: `boolean`):

When on, makes one extra fetch per item to capture description text, brand, and full seller info (company name, manager, customer-service phone, business number, e-commerce sales registration). Turn off for a faster, leaner scrape with only the search-listing fields.

## `proxy` (type: `object`):

Apify Datacenter is the default and is free-tier compatible. Residential is rarely needed for this site.

## Actor input object example

```json
{
  "mode": "search",
  "keywords": [
    "laptop"
  ],
  "minPrice": 0,
  "maxPrice": 0,
  "overseaDeliveryOnly": false,
  "bigSmileOnly": false,
  "urls": [
    "https://mg.gmarket.co.kr/Search/Search?keyword=laptop"
  ],
  "reviewsOnly": false,
  "maxReviewsPerProduct": 50,
  "maxPages": 1,
  "maxListings": 0,
  "fetchDetails": true,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `reviews` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "keywords": [
        "laptop"
    ],
    "urls": [
        "https://mg.gmarket.co.kr/Search/Search?keyword=laptop"
    ],
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/gmarket-global-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 = {
    "keywords": ["laptop"],
    "urls": ["https://mg.gmarket.co.kr/Search/Search?keyword=laptop"],
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/gmarket-global-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 '{
  "keywords": [
    "laptop"
  ],
  "urls": [
    "https://mg.gmarket.co.kr/Search/Search?keyword=laptop"
  ],
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/gmarket-global-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gmarket KR  $1💰 URL Keyword and Review Scraper",
        "description": "Scrape product listings and customer reviews from Gmarket.co.kr into clean JSON datasets. Supports keyword search, product URLs, or review-only mode by product ID. Lightweight, free-tier friendly, and runs without a browser.",
        "version": "1.0",
        "x-build-id": "bV4Wtu93D2TUQz72Q"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~gmarket-global-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-gmarket-global-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/abotapi~gmarket-global-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-gmarket-global-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/abotapi~gmarket-global-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-gmarket-global-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",
                            "url"
                        ],
                        "type": "string",
                        "description": "Pick how you want to drive the scrape. 'Keyword search' uses your keywords + filters; 'Paste URLs' uses Gmarket Global search-result URLs you already have.",
                        "default": "search"
                    },
                    "keywords": {
                        "title": "🔎 Keywords",
                        "type": "array",
                        "description": "One or more product keywords to search for (English or Korean both work). One run = one search per keyword × applied filters. Only used when mode is 'Keyword search'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minPrice": {
                        "title": "Minimum price (KRW)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum sale price in Korean Won. Leave 0 for no minimum. Example: 10000 (≈ $7 USD).",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "Maximum price (KRW)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum sale price in Korean Won. Leave 0 for no maximum. Example: 100000 (≈ $70 USD).",
                        "default": 0
                    },
                    "overseaDeliveryOnly": {
                        "title": "Oversea delivery only",
                        "type": "boolean",
                        "description": "When on, returns only items that ship outside Korea. Verified to narrow results by ~75% on broad queries.",
                        "default": false
                    },
                    "bigSmileOnly": {
                        "title": "BigSmile promotion only",
                        "type": "boolean",
                        "description": "When on, returns only items participating in the BigSmile sitewide promotion.",
                        "default": false
                    },
                    "urls": {
                        "title": "🔗 URLs",
                        "type": "array",
                        "description": "One or more Gmarket Global search-result URLs (must contain /Search/Search?keyword=...). Filter fields above are ignored in this mode; the URL's own query parameters are the filters. Forward pagination starts from the page in the URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "reviewsOnly": {
                        "title": "💬 Reviews only",
                        "type": "boolean",
                        "description": "When on, the actor still uses your keyword search or pasted URLs to discover products, but pushes one record per REVIEW instead of one record per product. Pair with maxReviewsPerProduct to cap how deep to walk each product.",
                        "default": false
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max reviews per product",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Only applies when 'Reviews only' is on. Stop after this many reviews per product. The API serves 20 per page; 50 = up to 3 pages each. Set 0 to walk every review the product has. Reviews come back in Gmarket's default order (typically featured first; the storefront does not expose a sort control).",
                        "default": 50
                    },
                    "maxPages": {
                        "title": "Max pages per search",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many pages to walk per keyword (or per URL). The API serves 60 items per page, so 1 page returns up to 60 products. Increase for deeper scrapes.",
                        "default": 1
                    },
                    "maxListings": {
                        "title": "Max total records",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop the whole run once this many unique records have been collected. When 'Reviews only' is off this counts products; when on it counts reviews across all products. Set 0 to disable.",
                        "default": 0
                    },
                    "fetchDetails": {
                        "title": "Fetch detail pages (richer; default)",
                        "type": "boolean",
                        "description": "When on, makes one extra fetch per item to capture description text, brand, and full seller info (company name, manager, customer-service phone, business number, e-commerce sales registration). Turn off for a faster, leaner scrape with only the search-listing fields.",
                        "default": true
                    },
                    "proxy": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Apify Datacenter is the default and is free-tier compatible. Residential is rarely needed for this site."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```