# Shopify App Store Scraper (`khadinakbar/shopify-app-store-scraper`) Actor

Scrape Shopify App Store apps, pricing plans, ratings, and merchant reviews. MCP/API-ready.

- **URL**: https://apify.com/khadinakbar/shopify-app-store-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, Developer tools, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 app scrapeds

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Shopify App Store Scraper

Scrape the **Shopify App Store** (apps.shopify.com) at scale — app metadata, pricing plans, ratings, and merchant reviews — from a search query, a category, or a direct app URL. One actor, four auto-detected modes. Built HTTP-only (fast, no browser), MCP-ready, and priced pay-per-event so you only pay for the data you keep.

### What you can do with it

| You want… | Give it… | You get back |
|---|---|---|
| Discover apps in a niche | a **search query** (e.g. `email marketing`) | App cards: name, developer, rating, review count, pricing badge, icon, URL |
| Map a whole category | a **category URL** (`/categories/<slug>`) | The category's curated app list (same card fields) |
| Full intel on one app | an **app URL** (`/klaviyo-email-marketing`) | Description, developer, rating, total reviews, **pricing plans** (name, price, features, extra charges), categories, works-with, languages, launch date, Built-for-Shopify badge |
| Mine merchant reviews | an **app URL** + `Also scrape reviews` (or a `/reviews` URL) | One record per review: star rating, full text, store name, country, usage duration, posted date, **developer reply** |

The **mode is auto-detected** from each input, so you can mix a search query, a category, and a handful of app URLs in one run.

### Pricing — pay per event

| Event | Price |
|---|---|
| Actor start | $0.00005 |
| App scraped (listing card **or** full detail) | **$0.005** per app |
| Review scraped | **$0.002** per review |

A typical run of 50 apps from a search costs ~$0.25. Pulling 500 reviews of one app costs ~$1.00. Every run prints its cost cap up front and the actual billed amount at the end. Hard caps (`Max apps per query/category`, `Max reviews per app`) keep spend predictable.

### Example input

Discover apps + their reviews from a search:

```json
{
  "queries": ["email marketing", "upsell cross sell"],
  "maxApps": 50,
  "enrichDetails": true,
  "scrapeReviews": true,
  "maxReviews": 200
}
````

Full detail + reviews for specific apps:

```json
{
  "startUrls": [
    { "url": "https://apps.shopify.com/klaviyo-email-marketing" },
    { "url": "https://apps.shopify.com/judgeme-product-reviews" }
  ],
  "scrapeReviews": true,
  "maxReviews": 500,
  "reviewSort": "most_recent"
}
```

Only 1-star complaints for one app:

```json
{
  "startUrls": [{ "url": "https://apps.shopify.com/klaviyo-email-marketing/reviews" }],
  "reviewRating": 1,
  "maxReviews": 300
}
```

### Output

#### App record

```json
{
  "recordType": "app",
  "appName": "Klaviyo: Email Marketing & SMS",
  "appSlug": "klaviyo-email-marketing",
  "appUrl": "https://apps.shopify.com/klaviyo-email-marketing",
  "developer": "Klaviyo",
  "developerUrl": "https://apps.shopify.com/partners/klaviyo",
  "rating": 4.7,
  "reviewsCount": 2879,
  "pricingBadge": "Free to install",
  "priceFrom": "Free to install",
  "pricingPlans": [
    { "name": "SMS", "price": "$15/month", "additionalCharges": "Up to 1250 SMS/MMS credits.", "features": ["Multi-channel flows", "SMS AI", "..."] }
  ],
  "category": "Email marketing",
  "categories": ["Email marketing", "SMS campaigns", "Pop-ups"],
  "worksWith": ["Checkout", "Customer accounts"],
  "languages": ["English", "French", "Spanish"],
  "launchedAt": "September 20, 2012",
  "builtForShopify": false,
  "iconUrl": "https://cdn.shopify.com/.../icon.png",
  "scrapedAt": "2026-06-17T02:00:00.000Z"
}
```

#### Review record

```json
{
  "recordType": "review",
  "appName": "Klaviyo: Email Marketing & SMS",
  "appSlug": "klaviyo-email-marketing",
  "reviewId": "2204756",
  "rating": 1,
  "reviewBody": "Extremely unhappy. Last year my monthly price went from 80usd to 150usd...",
  "storeName": "North Ones",
  "country": "Sweden",
  "usageDuration": "Almost 6 years using the app",
  "postedAt": "May 15, 2026",
  "developerReply": "We hear you and appreciate you sharing this openly...",
  "developerReplyAt": "June 4, 2026",
  "scrapedAt": "2026-06-17T02:00:00.000Z"
}
```

### Input options

| Field | Type | Default | Notes |
|---|---|---|---|
| `queries` | string\[] | — | Search keywords, one niche per line |
| `startUrls` | url\[] | — | App / category / reviews / search URLs (mode auto-detected) |
| `mode` | enum | `auto` | Force `search` / `category` / `app_detail` / `reviews` |
| `scrapeReviews` | bool | `false` | Also paginate each app's reviews |
| `enrichDetails` | bool | `false` | Visit each search/category app's detail page for full metadata |
| `maxApps` | int | `50` | Cap apps per query/category |
| `maxReviews` | int | `100` | Cap reviews per app |
| `reviewSort` | enum | `most_recent` | `highest_rating` / `lowest_rating` / `most_helpful` |
| `reviewRating` | int | `0` | Only reviews with this exact star rating (1–5); 0 = all |
| `country` | string | `US` | Proxy egress country (ISO alpha-2) |

### Use it from an AI agent (MCP)

This actor is MCP-ready. Exposed via Apify MCP as `apify--shopify-app-store-scraper`, an agent can call it with a single app URL or search query and get back clean, flat JSON — ideal for "summarize what merchants say about app X" or "list the top email-marketing apps and their pricing."

### FAQ

**How many apps does a category return?** Category pages are a curated set (~40 apps). For exhaustive coverage of a niche, use a **search query** instead — search paginates through every matching app.

**Are install counts available?** No. Shopify does not expose install counts on the App Store; ratings and review counts are the public popularity signals.

**Does it need a login or cookies?** No. All data is public; the actor is HTTP-only and uses Apify Proxy (AUTO) by default.

**Why pay-per-event?** You pay for apps and reviews actually returned, not for compute time. Failed/empty runs cost nothing beyond the tiny start fee.

### Notes & legal

This actor collects **publicly available** information from apps.shopify.com. Use the data in compliance with the Shopify App Store terms, applicable laws, and privacy regulations (GDPR/CCPA). Review text and store names are user-generated public content; do not use scraped data to spam merchants or for any purpose that violates applicable law. You are responsible for how you use the output. Not affiliated with or endorsed by Shopify Inc.

# Actor input Schema

## `queries` (type: `array`):

Free-text keywords searched on the Shopify App Store, one app niche per line (e.g. 'email marketing', 'product reviews'). Each query returns a paginated list of matching app cards. Leave empty if you are passing app, category, or review URLs in 'Start URLs' instead. NOT an app URL — to scrape one specific app use 'Start URLs'.

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

Direct apps.shopify.com URLs; the mode is auto-detected per URL. App page (apps.shopify.com/klaviyo-email-marketing) returns full app detail; a /reviews URL returns merchant reviews; a /categories/<slug> URL returns the category app list; a /search?q= URL runs a search. Use this for precise targets instead of free-text 'Search queries'.

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

Forces a scraping mode instead of auto-detecting from the URL. 'auto' (default) detects search vs category vs app\_detail vs reviews from each input. Set explicitly only to override detection (e.g. force 'reviews' on a bare app URL). Most users should leave this on 'auto'.

## `scrapeReviews` (type: `boolean`):

When scraping app detail pages (or apps found via search/category with 'Enrich details' on), also paginate that app's merchant reviews and emit one record per review. Adds review-scraped charges. Defaults to false. Ignored when the input is already a /reviews URL.

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

For search and category modes, visit each app's detail page to add full metadata (description, pricing plans, developer, works-with, languages) instead of just the listing card. Slower and adds one app-scraped charge per app. Defaults to false (fast card-level listing only).

## `maxApps` (type: `integer`):

Hard cap on how many apps to return per search query or category, across pagination. Caps the app-scraped charge so cost stays predictable. Defaults to 50; set 0 or leave default for typical runs. Does not limit reviews — use 'Max reviews per app' for that.

## `maxReviews` (type: `integer`):

Hard cap on reviews scraped per app (10 reviews per page). Caps the review-scraped charge. Defaults to 100. Only applies when scraping reviews (a /reviews URL, or 'Also scrape reviews' enabled).

## `reviewSort` (type: `string`):

Order reviews are returned in when scraping reviews. 'most\_recent' (default) is newest first; 'highest\_rating' / 'lowest\_rating' sort by stars; 'most\_helpful' uses Shopify's helpfulness ranking. Ignored outside review scraping.

## `reviewRating` (type: `integer`):

Only scrape reviews with this exact star rating (1-5). Leave at 0 (default) to scrape all ratings. Useful for pulling only 1-star complaints or 5-star praise. Ignored outside review scraping.

## `country` (type: `string`):

Two-letter country code for the Apify residential/datacenter proxy egress (e.g. 'US', 'GB'). Affects geo-targeted pricing/currency shown on listings. Defaults to 'US'. Uppercase ISO-3166 alpha-2.

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

Maximum parallel requests. Defaults to 10. Lower it (e.g. 5) for very large jobs (thousands of apps) if you hit rate-limit (HTTP 429) blocks — slower but steadier. Raising it rarely helps and risks more blocks.

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

Apify proxy settings. Defaults to Apify Proxy (AUTO) which is sufficient — apps.shopify.com is not aggressively bot-protected. Override only if you need a specific proxy group or country.

## Actor input object example

```json
{
  "queries": [
    "email marketing",
    "upsell cross sell"
  ],
  "startUrls": [
    {
      "url": "https://apps.shopify.com/klaviyo-email-marketing"
    }
  ],
  "mode": "auto",
  "scrapeReviews": false,
  "enrichDetails": false,
  "maxApps": 50,
  "maxReviews": 100,
  "reviewSort": "most_recent",
  "reviewRating": 0,
  "country": "US",
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

App and review records scraped from the Shopify App Store.

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

Counts and estimated cost for this run.

# 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 = {
    "queries": [
        "email marketing"
    ],
    "maxApps": 50,
    "maxReviews": 100,
    "country": "US",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/shopify-app-store-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 = {
    "queries": ["email marketing"],
    "maxApps": 50,
    "maxReviews": 100,
    "country": "US",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/shopify-app-store-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 '{
  "queries": [
    "email marketing"
  ],
  "maxApps": 50,
  "maxReviews": 100,
  "country": "US",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call khadinakbar/shopify-app-store-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify App Store Scraper",
        "description": "Scrape Shopify App Store apps, pricing plans, ratings, and merchant reviews. MCP/API-ready.",
        "version": "0.1",
        "x-build-id": "sWmF2c0vgU6Oln9Ub"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~shopify-app-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-shopify-app-store-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/khadinakbar~shopify-app-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-shopify-app-store-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/khadinakbar~shopify-app-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-shopify-app-store-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": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Free-text keywords searched on the Shopify App Store, one app niche per line (e.g. 'email marketing', 'product reviews'). Each query returns a paginated list of matching app cards. Leave empty if you are passing app, category, or review URLs in 'Start URLs' instead. NOT an app URL — to scrape one specific app use 'Start URLs'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Direct apps.shopify.com URLs; the mode is auto-detected per URL. App page (apps.shopify.com/klaviyo-email-marketing) returns full app detail; a /reviews URL returns merchant reviews; a /categories/<slug> URL returns the category app list; a /search?q= URL runs a search. Use this for precise targets instead of free-text 'Search queries'.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "auto",
                            "search",
                            "category",
                            "app_detail",
                            "reviews"
                        ],
                        "type": "string",
                        "description": "Forces a scraping mode instead of auto-detecting from the URL. 'auto' (default) detects search vs category vs app_detail vs reviews from each input. Set explicitly only to override detection (e.g. force 'reviews' on a bare app URL). Most users should leave this on 'auto'.",
                        "default": "auto"
                    },
                    "scrapeReviews": {
                        "title": "Also scrape reviews for each app",
                        "type": "boolean",
                        "description": "When scraping app detail pages (or apps found via search/category with 'Enrich details' on), also paginate that app's merchant reviews and emit one record per review. Adds review-scraped charges. Defaults to false. Ignored when the input is already a /reviews URL.",
                        "default": false
                    },
                    "enrichDetails": {
                        "title": "Enrich search/category results with full detail",
                        "type": "boolean",
                        "description": "For search and category modes, visit each app's detail page to add full metadata (description, pricing plans, developer, works-with, languages) instead of just the listing card. Slower and adds one app-scraped charge per app. Defaults to false (fast card-level listing only).",
                        "default": false
                    },
                    "maxApps": {
                        "title": "Max apps per query/category",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap on how many apps to return per search query or category, across pagination. Caps the app-scraped charge so cost stays predictable. Defaults to 50; set 0 or leave default for typical runs. Does not limit reviews — use 'Max reviews per app' for that.",
                        "default": 50
                    },
                    "maxReviews": {
                        "title": "Max reviews per app",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Hard cap on reviews scraped per app (10 reviews per page). Caps the review-scraped charge. Defaults to 100. Only applies when scraping reviews (a /reviews URL, or 'Also scrape reviews' enabled).",
                        "default": 100
                    },
                    "reviewSort": {
                        "title": "Review sort order",
                        "enum": [
                            "most_recent",
                            "highest_rating",
                            "lowest_rating",
                            "most_helpful"
                        ],
                        "type": "string",
                        "description": "Order reviews are returned in when scraping reviews. 'most_recent' (default) is newest first; 'highest_rating' / 'lowest_rating' sort by stars; 'most_helpful' uses Shopify's helpfulness ranking. Ignored outside review scraping.",
                        "default": "most_recent"
                    },
                    "reviewRating": {
                        "title": "Filter reviews by star rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only scrape reviews with this exact star rating (1-5). Leave at 0 (default) to scrape all ratings. Useful for pulling only 1-star complaints or 5-star praise. Ignored outside review scraping.",
                        "default": 0
                    },
                    "country": {
                        "title": "Proxy country",
                        "type": "string",
                        "description": "Two-letter country code for the Apify residential/datacenter proxy egress (e.g. 'US', 'GB'). Affects geo-targeted pricing/currency shown on listings. Defaults to 'US'. Uppercase ISO-3166 alpha-2.",
                        "default": "US"
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum parallel requests. Defaults to 10. Lower it (e.g. 5) for very large jobs (thousands of apps) if you hit rate-limit (HTTP 429) blocks — slower but steadier. Raising it rarely helps and risks more blocks.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Defaults to Apify Proxy (AUTO) which is sufficient — apps.shopify.com is not aggressively bot-protected. Override only if you need a specific proxy group or country.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
