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

Scrape the Shopify App Store for app metadata, pricing tiers, ratings, reviews, and Built-for-Shopify badges. Designed for delta-tracking — daily price drops, rating shifts, and badge wins.

- **URL**: https://apify.com/alwaysprimedev/shopify-app-store-scraper.md
- **Developed by:** [Always Prime](https://apify.com/alwaysprimedev) (community)
- **Categories:** Automation, SEO tools, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 apps

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

## 🛍️ Shopify App Store Scraper — App Intelligence + Reviews + Pricing Tracker

> ⚡️ Structured app, pricing-tier and review data from **apps.shopify.com** — fast, complete, ready for delta-tracking.

[![Built for Apify](https://img.shields.io/badge/Built%20for-Apify-blue)](https://apify.com)
[![Python 3.11](https://img.shields.io/badge/python-3.11-blue.svg)](https://www.python.org/)
[![Output: JSON / CSV / Excel](https://img.shields.io/badge/output-JSON%20%7C%20CSV%20%7C%20Excel-green)]()

Pull every public field from the Shopify App Store at scale: app name, developer, rating, full review history, every pricing tier, "Built for Shopify" badge status, screenshots, supported languages, integrations, and launch date. Daily delta-runs catch price drops, rating shifts, and new badge wins the moment they happen.

---

### 🚀 Why this scraper

- 📦 **All 19,000+ apps** discoverable via the public sitemap — full coverage, not just the curated browse pages
- 💰 **Every pricing tier** parsed individually (name, price, billing, features) — not just the headline price label
- ⭐ **Full review history** with merchant store name, country, usage duration, and developer reply
- 🏷️ **"Built for Shopify" badge** flagged on each app — track which apps qualified this week
- 🤖 **Incremental mode** — pass a `since` date and only re-scrape apps that changed (sitemap `lastmod`)
- 🧱 **Stable selectors** built on Shopify's own `data-app-card-*` and `data-merchant-review` attributes
- 🛡️ **Polite by default** — concurrency 5, jittered backoff, fingerprint rotation, never overruns the site

---

### ⏱️ Quick start

1. Click **Try for free** above ▶️
2. Pick a discovery mode (full sitemap, by category, or specific URLs)
3. Hit **Start** 🟢
4. Download the dataset as JSON, CSV, or Excel — or query it via Apify API

That's it. No API key, no proxy setup, no scraper tuning.

---

### 🧰 Input

| Field | Default | What it does |
|---|---|---|
| `discoveryMode` | `categories` | `sitemap` (all 19k+ apps) / `categories` (curated subset per Shopify category) / `startUrls` (your own list) |
| `categories` | `["finding-products"]` | One or more of the 7 top-level Shopify categories — only used for `categories` mode |
| `startUrls` | — | Specific app URLs to monitor — only used for `startUrls` mode |
| `scrapeReviews` | `false` | Also scrape every review on every app (paginated) |
| `since` | — | Incremental: only scrape apps whose sitemap `lastmod` ≥ this date |
| `maxItems` | `50` | Total cap (apps + reviews counted together). Set `0` for unlimited |
| `maxReviewsPerApp` | `100` | Per-app cap on reviews. Set `0` to scrape full review history per app |
| `concurrency` | `5` | Parallel page fetches. Hard cap 25 |

---

### 📊 Sample output

#### App record

```json
{
  "type": "app",
  "url": "https://apps.shopify.com/klaviyo-email-marketing",
  "handle": "klaviyo-email-marketing",
  "id": "klaviyo-email-marketing",
  "name": "Klaviyo: Email Marketing & SMS",
  "tagline": "AI marketing and customer service automation for email marketing, SMS, and WhatsApp to grow faster.",
  "description": "Klaviyo is a leading email and sms marketing app for Shopify. Improve your marketing ROI with our templates to deliver personalized email and sms campaigns.",
  "developer": "Klaviyo",
  "developer_url": "https://apps.shopify.com/partners/klaviyo",
  "developer_email": "support@klaviyo.com",
  "icon_url": "https://cdn.shopify.com/app-store/listing_images/5edd9000b933a8fa88c152d1e498531f/icon/CP6B2OOv3PYCEAE=.png",
  "screenshots": [
    "https://cdn.shopify.com/app-store/listing_images/5edd9000b933a8fa88c152d1e498531f/desktop_screenshot/CJa736LdpJEDEAE=.png",
    "https://cdn.shopify.com/app-store/listing_images/5edd9000b933a8fa88c152d1e498531f/desktop_screenshot/CNGT_KLdpJEDEAE=.png",
    "https://cdn.shopify.com/app-store/listing_images/5edd9000b933a8fa88c152d1e498531f/desktop_screenshot/CNHU6KLdpJEDEAE=.png"
  ],
  "rating": 4.6,
  "reviews_count": 2700,
  "price_label": "Free to install",
  "pricing_tiers": [
    {
      "name": "Free",
      "price_label": "Free to install",
      "additional_charges": "Free forever for up to 250 contacts.",
      "features": ["Sync Shopify data", "Templates for Email/SMS", "Forms & push notifications", "Segmentation & personalization", "A/B testing"]
    },
    {
      "name": "SMS",
      "price_label": "$15/month",
      "additional_charges": null,
      "features": ["1,250 SMS/MMS credits", "Two-way conversations", "Quiet hours"]
    }
  ],
  "languages": ["English", "French", "Spanish", "German", "Portuguese (Brazil)", "Korean", "Italian", "Polish", "Swedish", "Dutch"],
  "works_with": ["Checkout", "Shopify Flow", "Loyalty programs"],
  "launched_at": "2014-12-09",
  "built_for_shopify": false,
  "featured_in": ["Best email marketing apps", "Top SMS marketing"],
  "scraped_at": "2026-05-10T17:30:00+00:00"
}
````

#### Review record

```json
{
  "type": "review",
  "id": "2186957",
  "app_handle": "klaviyo-email-marketing",
  "url": "https://apps.shopify.com/klaviyo-email-marketing/reviews?#review-2186957",
  "rating": 5,
  "posted_at": "2026-05-02",
  "body": "We use Klaviyo for more than 5 years and it did help us recover the carts left by sending a series of abandoned cart emails…",
  "store_name": "iSmart Home Gadgets",
  "store_country": "Hong Kong SAR",
  "usage_duration": "Over 5 years using the app",
  "developer_reply": null,
  "scraped_at": "2026-05-10T17:30:00+00:00"
}
```

***

### 🎯 Use cases

| Who | What for |
|---|---|
| 🛠️ **Shopify app developers** (~30K active) | Competitive intelligence — rivals' pricing changes, rating shifts, "Built for Shopify" wins |
| 🏢 **E-commerce agencies** | Build curated app shortlists for clients filtered by rating, language support, integrations |
| 📈 **Vendor-intelligence platforms** (BuiltWith, Similarweb-style) | Continuous Shopify ecosystem dataset for your product |
| 💼 **VC / M\&A analysts** | Diligence on app businesses — pricing model, install base proxy via reviews\_count, growth via lastmod |
| 🧪 **ML / data teams** | Training corpora for pricing models, review sentiment, app-categorization classifiers |
| 📰 **Market researchers & journalists** | "Top 100 apps by rating", "Average price/month per category", trend pieces |

***

### 💡 Tips & tricks

- 🔁 **Daily delta runs**: schedule with `discoveryMode = sitemap` and `since = yesterday`. Only refreshes apps that changed.
- 🧮 **Pricing-only runs**: keep `scrapeReviews = false` to keep cost minimal — pricing tiers are part of every app record.
- 🔍 **Watchlist mode**: use `discoveryMode = startUrls` with a list of competitor app URLs for a focused intel run.
- 📅 **Full review history**: set `maxReviewsPerApp = 0` and `maxItems = 0` (caution — Klaviyo alone has 2,700 reviews / 270 pages).
- 🧹 **Filter in dataset views**: the dataset has two views ("Apps" and "Reviews") that pre-filter the unified stream by record type.

***

### ❓ FAQ

**How fresh is the data?**
Every run is live. The Shopify sitemap publishes daily `lastmod` dates per app — pair it with the `since` input for true incremental tracking.

**Does this work without an Apify proxy?**
Yes. Datacenter IPs work out of the box. The actor uses TLS fingerprint rotation and never triggers Cloudflare challenges.

**Can it scrape search results by query?**
No — that endpoint is Disallow-ed in the public `robots.txt`. Use category browsing or the full sitemap instead.

**What about apps with multi-language listings?**
The actor follows the canonical `apps.shopify.com/{handle}` path which serves English; the `languages` field still lists every language the app itself supports.

**How do I track "Built for Shopify" badge changes?**
Run daily with `discoveryMode = sitemap`, store the `built_for_shopify` field, and diff against yesterday's snapshot. New `true`s = badge wins this week.

**Pricing model?**
Pay-per-event: a small charge per scraped app, per scraped review, and per pricing-tier snapshot. Free actor starts give you ~50 records to test before any spend.

***

### 📦 What's inside each record

App records (`type: "app"`): url, handle, name, tagline, description, developer, developer\_url, developer\_email, icon\_url, screenshots\[], rating, reviews\_count, price\_label, pricing\_tiers\[{name, price\_label, additional\_charges, features\[]}], languages\[], works\_with\[], launched\_at, built\_for\_shopify, featured\_in\[], scraped\_at.

Review records (`type: "review"`): id, app\_handle, url, rating, posted\_at, body, store\_name, store\_country, usage\_duration, developer\_reply{replied\_at, body}, scraped\_at.

# Actor input Schema

## `discoveryMode` (type: `string`):

How to find apps to scrape. 'sitemap' walks every app in the public sitemap (best for full coverage and incremental runs). 'categories' scrapes only apps that appear in the chosen Shopify category pages (~30-44 curated apps per category). 'startUrls' scrapes a hand-picked list of app pages.

## `categories` (type: `array`):

Used when discoveryMode = 'categories'. Choose one or more top-level Shopify App Store categories. Leave empty to fall back to the full sitemap.

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

Used when discoveryMode = 'startUrls'. Provide one or more app detail page URLs (e.g. https://apps.shopify.com/klaviyo-email-marketing). Use this to monitor a fixed set of apps or competitors.

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

When enabled, paginates every app's review pages and pushes one record per review (with rating, author store, country, posted date, body, and developer reply). Disable for cheap app-only runs.

## `since` (type: `string`):

Optional ISO timestamp. When set with discoveryMode = 'sitemap', only apps whose sitemap lastmod date is on or after this date are scraped — perfect for daily delta runs that only refresh apps which changed.

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

Hard cap on total dataset size. Counts both apps and reviews together. Set to 0 for unlimited.

## `maxReviewsPerApp` (type: `integer`):

Per-app cap on reviews scraped, independent of the overall maxItems. Set to 0 for unlimited (will paginate the entire review history for each app — slow but complete).

## `concurrency` (type: `integer`):

Number of app pages fetched in parallel. Default 3 is polite for datacenter IPs (Shopify rate-limits aggressive bursts). With a residential proxy you can safely raise to 10-15. Hard cap is 25.

## Actor input object example

```json
{
  "discoveryMode": "categories",
  "categories": [
    "finding-products"
  ],
  "startUrls": [
    {
      "url": "https://apps.shopify.com/klaviyo-email-marketing"
    },
    {
      "url": "https://apps.shopify.com/judgeme"
    }
  ],
  "scrapeReviews": false,
  "maxItems": 50,
  "maxReviewsPerApp": 100,
  "concurrency": 3
}
```

# Actor output Schema

## `apps` (type: `string`):

Full dataset as line-delimited JSON.

## `appsCsv` (type: `string`):

Same data as a single CSV — open in Excel, Numbers, Google Sheets.

## `appsXlsx` (type: `string`):

XLSX export.

## `consoleView` (type: `string`):

Browse the dataset interactively in the Apify Console.

# 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 = {
    "categories": [
        "finding-products"
    ],
    "startUrls": [
        {
            "url": "https://apps.shopify.com/klaviyo-email-marketing"
        },
        {
            "url": "https://apps.shopify.com/judgeme"
        }
    ],
    "maxItems": 50,
    "maxReviewsPerApp": 100,
    "concurrency": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("alwaysprimedev/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 = {
    "categories": ["finding-products"],
    "startUrls": [
        { "url": "https://apps.shopify.com/klaviyo-email-marketing" },
        { "url": "https://apps.shopify.com/judgeme" },
    ],
    "maxItems": 50,
    "maxReviewsPerApp": 100,
    "concurrency": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("alwaysprimedev/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 '{
  "categories": [
    "finding-products"
  ],
  "startUrls": [
    {
      "url": "https://apps.shopify.com/klaviyo-email-marketing"
    },
    {
      "url": "https://apps.shopify.com/judgeme"
    }
  ],
  "maxItems": 50,
  "maxReviewsPerApp": 100,
  "concurrency": 3
}' |
apify call alwaysprimedev/shopify-app-store-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=alwaysprimedev/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 the Shopify App Store for app metadata, pricing tiers, ratings, reviews, and Built-for-Shopify badges. Designed for delta-tracking — daily price drops, rating shifts, and badge wins.",
        "version": "0.1",
        "x-build-id": "PuYGB1A5ggkw2egJz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/alwaysprimedev~shopify-app-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-alwaysprimedev-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/alwaysprimedev~shopify-app-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-alwaysprimedev-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/alwaysprimedev~shopify-app-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-alwaysprimedev-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": {
                    "discoveryMode": {
                        "title": "Discovery mode",
                        "enum": [
                            "sitemap",
                            "categories",
                            "startUrls"
                        ],
                        "type": "string",
                        "description": "How to find apps to scrape. 'sitemap' walks every app in the public sitemap (best for full coverage and incremental runs). 'categories' scrapes only apps that appear in the chosen Shopify category pages (~30-44 curated apps per category). 'startUrls' scrapes a hand-picked list of app pages.",
                        "default": "categories"
                    },
                    "categories": {
                        "title": "Categories",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Used when discoveryMode = 'categories'. Choose one or more top-level Shopify App Store categories. Leave empty to fall back to the full sitemap.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "sales-channels",
                                "finding-products",
                                "selling-products",
                                "orders-and-shipping",
                                "store-design",
                                "marketing-and-conversion",
                                "store-management"
                            ],
                            "enumTitles": [
                                "Sales channels",
                                "Finding products",
                                "Selling products",
                                "Orders and shipping",
                                "Store design",
                                "Marketing and conversion",
                                "Store management"
                            ]
                        }
                    },
                    "startUrls": {
                        "title": "Specific app URLs",
                        "type": "array",
                        "description": "Used when discoveryMode = 'startUrls'. Provide one or more app detail page URLs (e.g. https://apps.shopify.com/klaviyo-email-marketing). Use this to monitor a fixed set of apps or competitors.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "scrapeReviews": {
                        "title": "Scrape reviews",
                        "type": "boolean",
                        "description": "When enabled, paginates every app's review pages and pushes one record per review (with rating, author store, country, posted date, body, and developer reply). Disable for cheap app-only runs.",
                        "default": false
                    },
                    "since": {
                        "title": "Since (incremental mode)",
                        "type": "string",
                        "description": "Optional ISO timestamp. When set with discoveryMode = 'sitemap', only apps whose sitemap lastmod date is on or after this date are scraped — perfect for daily delta runs that only refresh apps which changed."
                    },
                    "maxItems": {
                        "title": "Max records (overall cap)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on total dataset size. Counts both apps and reviews together. Set to 0 for unlimited.",
                        "default": 50
                    },
                    "maxReviewsPerApp": {
                        "title": "Max reviews per app",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Per-app cap on reviews scraped, independent of the overall maxItems. Set to 0 for unlimited (will paginate the entire review history for each app — slow but complete).",
                        "default": 100
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "Number of app pages fetched in parallel. Default 3 is polite for datacenter IPs (Shopify rate-limits aggressive bursts). With a residential proxy you can safely raise to 10-15. Hard cap is 25.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```