# Shopify Scraper - Products, Collections, Analysis (`prodiger/shopify-scraper`) Actor

Scrape products and collections from any Shopify-powered store. Pay-per-event pricing — only pay for the items you actually scrape. No API key needed.

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

## Pricing

Pay per event

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 Scraper (Pay-Per-Event)

**Shopify Scraper** is a high-fidelity crawler that extracts product and collection data from any [Shopify](https://www.shopify.com/)-powered store. This is the **Pay-Per-Event** edition — there is no monthly rental, no compute-unit guesswork, and no minimum spend. You pay only for the products and collections you actually scrape.

Use it on the Apify platform for scheduling, API access, dataset exports (JSON, CSV, Excel, HTML), residential proxy rotation, run monitoring, and integration with Make, Zapier, and 5000+ other tools.

### What does Shopify Scraper do?

Give it a Shopify store homepage, a collection URL, or an individual product URL — the actor classifies each input and hits Shopify's public storefront JSON endpoints (`/products.json`, `/collections.json`, `/products/<handle>.json`, `/recommendations/products.json`, `/search/suggest.json`). No API key or merchant authentication is required because every Shopify storefront serves these endpoints publicly.

The scraper extracts:

- Title, vendor, product type, tags, description (HTML and stripped plaintext)
- All variants with SKU, price, compare-at price, availability, and option values (size / color / etc.)
- All product images with dimensions and alt text
- Option matrices (e.g. Size × Color)
- Real-time stock status (`available`)
- Optional related-product recommendations per scraped product

Prices are normalized to **integer cents** (multiply by 100 to display) so financial totals never drift due to floating-point errors. `2000` means $20.00.

### Why use Shopify Scraper?

- **Market research** — Analyze competitor pricing, inventory depth, variant strategy, and copy.
- **Trend monitoring** — Track new product launches and stock changes across multiple brands daily.
- **Catalog aggregation** — Pull product data from many Shopify stores into a unified dataset.
- **Lead enrichment** — Augment your CRM with product-line data on Shopify-merchant prospects.
- **Pricing intelligence** — Watch promotional cycles, compare-at-price drops, and cross-store undercutting.

### How to use Shopify Scraper

1. **Verify the target is a Shopify store.** Open `https://<domain>/admin` (e.g. `https://gymshark.com/admin`). If you see a Shopify login page, the site is compatible.
2. **Click "Try for free"** on this actor's page.
3. **Add one or more Start URLs** in the input form. Homepages, collection pages, and product pages all work.
4. **Set "Max products per run"** to control your spend. The default 100 keeps test runs cheap.
5. **(Optional)** Provide a search query to find specific products inside a store, or set "Recommendations per product" to pull related items.
6. **Click "Save & Start"**. Watch the live log; results stream into the dataset as they're scraped.
7. **Export** as JSON, CSV, Excel, or HTML, or hit the Apify [Dataset API](https://docs.apify.com/api/v2#/reference/datasets) directly.

### Input

| Parameter                      | Type    | Required | Description                                                                                                                                      |
| ------------------------------ | ------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| `startUrls`                    | Array   | Yes      | Homepage, collection, single-product, or search URLs.                                                                                            |
| `query`                        | String  | No       | Search query — combined with a homepage URL, runs the store's predictive search and scrapes the matching products.                               |
| `maxRequestsPerCrawl`          | Integer | No       | Max products to emit per run. `0` = unlimited. Default `100`.                                                                                    |
| `maxRecommendationsPerProduct` | Integer | No       | Recommendations to fetch per product. `0` disables. Max `20`.                                                                                    |
| `currency`                     | String  | No       | 3-letter ISO code (e.g. `USD`, `EUR`). Forces the store to return prices in this currency when supported.                                        |
| `maxRequestRetries`            | Integer | No       | Retry budget for transient failures. Default `5`.                                                                                                |
| `proxyConfiguration`           | Object  | No       | Apify proxy. **Residential is the default and is strongly recommended** — datacenter IPs are often blocked by Cloudflare-fronted Shopify stores. |

#### Input examples

| Use case                           | Input JSON                                                                                                                     |
| ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| Scrape all products from a store   | `{ "startUrls": [{ "url": "https://kith.com" }], "maxRequestsPerCrawl": 0 }`                                                   |
| Scrape products from a collection  | `{ "startUrls": [{ "url": "https://kith.com/collections/kith-tops" }], "maxRequestsPerCrawl": 0 }`                             |
| Scrape a single product page       | `{ "startUrls": [{ "url": "https://kith.com/products/kith-williams-iii-hoodie-black" }] }`                                     |
| Search products by keyword         | `{ "startUrls": [{ "url": "https://kith.com" }], "query": "hoodie" }`                                                          |
| Fetch product with recommendations | `{ "startUrls": [{ "url": "https://kith.com/products/kith-williams-iii-hoodie-black" }], "maxRecommendationsPerProduct": 10 }` |
| Limit total scraped results        | `{ "startUrls": [{ "url": "https://kith.com" }], "maxRequestsPerCrawl": 100 }`                                                 |
| Force a specific currency          | `{ "startUrls": [{ "url": "https://kith.com" }], "currency": "EUR" }`                                                          |

### Output

All results land in the run's default dataset. Each record has a `type` field (`"product"` or `"collection"`) so a single dataset cleanly carries both.

#### Sample product record

```json
{
    "type": "product",
    "id": "8123456789012",
    "handle": "kith-williams-iii-hoodie-black",
    "title": "Kith Williams III Hoodie",
    "vendor": "Kith",
    "productType": "Hoodies",
    "tags": ["hoodie", "fleece", "ss26"],
    "url": "https://kith.com/products/kith-williams-iii-hoodie-black",
    "storeDomain": "kith.com",
    "currency": null,
    "price": 18000,
    "compareAtPrice": null,
    "available": true,
    "publishedAt": "2026-01-12T17:00:00-05:00",
    "updatedAt": "2026-04-10T09:14:22-04:00",
    "descriptionHtml": "<p>Heavyweight French-terry hoodie...</p>",
    "description": "Heavyweight French-terry hoodie...",
    "images": [
        {
            "id": "31234567890",
            "src": "https://cdn.shopify.com/s/files/.../front.jpg",
            "alt": null,
            "width": 2000,
            "height": 2500
        }
    ],
    "options": [
        { "name": "Size", "values": ["S", "M", "L", "XL"] },
        { "name": "Color", "values": ["Black"] }
    ],
    "variants": [
        {
            "id": "44123456789",
            "sku": "KH8000-001-S",
            "title": "S / Black",
            "price": 18000,
            "compareAtPrice": null,
            "available": true,
            "option1": "S",
            "option2": "Black",
            "option3": null
        }
    ],
    "isRecommendation": false,
    "recommendedFor": null,
    "scrapedAt": "2026-04-29T16:34:30.000Z"
}
````

#### Sample collection record

```json
{
    "type": "collection",
    "id": "456123789",
    "handle": "kith-tops",
    "title": "Kith Tops",
    "url": "https://kith.com/collections/kith-tops",
    "storeDomain": "kith.com",
    "descriptionHtml": "",
    "description": "",
    "publishedAt": null,
    "updatedAt": "2026-04-22T11:02:18-04:00",
    "productsCount": 184,
    "image": {
        "src": "https://cdn.shopify.com/s/files/.../tops-banner.jpg",
        "alt": null,
        "width": 1200,
        "height": 600
    },
    "scrapedAt": "2026-04-29T16:34:30.000Z"
}
```

You can download the dataset in JSON, JSONL, CSV, Excel, or HTML.

#### Data table

| Field              | Type     | Description                                            |
| ------------------ | -------- | ------------------------------------------------------ |
| `type`             | string   | `"product"` or `"collection"`                          |
| `id`               | string   | Shopify numeric ID, stringified                        |
| `handle`           | string   | Shopify URL-safe slug                                  |
| `title`            | string   | Display title                                          |
| `vendor`           | string   | Brand / vendor (products only)                         |
| `productType`      | string   | Product taxonomy (products only)                       |
| `tags`             | string\[] | Merchant-defined tags                                  |
| `price`            | integer  | Min variant price in cents (multiply ÷100)             |
| `compareAtPrice`   | integer  | Min variant compare-at price in cents                  |
| `available`        | boolean  | True if any variant is in stock                        |
| `variants`         | array    | Per-SKU details: id, sku, price, options, availability |
| `images`           | array    | All product images with src, dimensions, alt           |
| `options`          | array    | Variant axes (Size, Color, etc.)                       |
| `productsCount`    | integer  | Number of products in collection (collections only)    |
| `isRecommendation` | boolean  | True for products fetched via recommendations          |
| `recommendedFor`   | string   | Parent product ID when this is a recommendation        |

### Pricing / Cost estimation

This actor uses **Pay-Per-Event** pricing. There is no monthly rental — you pay only when records are emitted to the dataset.

| Event                    | Fired when                                      | Cost driver        |
| ------------------------ | ----------------------------------------------- | ------------------ |
| `actor-start`            | The run begins (handled automatically by Apify) | Per run            |
| `product-scraped`        | A product is written to the dataset             | Per product        |
| `collection-scraped`     | A collection metadata record is written         | Per collection     |
| `recommendation-scraped` | A recommended product is written                | Per recommendation |

Refer to the **Pricing** tab on this actor's listing for the current per-event rates.

**Cost levers:**

- `maxRequestsPerCrawl` is the hard ceiling on emitted products (and recommendations).
- Setting `maxRecommendationsPerProduct` to `0` (default) disables recommendation events entirely.
- A single-product URL run typically results in `1 × actor-start + 1 × product-scraped` plus optional recommendations.
- Failed runs (invalid input, no Shopify endpoints reachable) emit no product/collection events.

### Tips and advanced options

- **Use residential proxies.** Cloudflare-fronted stores 403 datacenter IPs aggressively. The default proxy group is `RESIDENTIAL` for this reason.
- **Pagination is automatic.** The actor walks `?page=N` until Shopify returns an empty `products` array. There's no need to set page bounds manually.
- **Currency selection.** Pass `currency: "EUR"` (or any 3-letter ISO code) to scrape localized prices, when supported by the store.
- **SKUs are not merged.** Some Shopify themes visually combine multiple SKUs onto a single product page. This scraper treats every SKU as its own variant — no SKU merging is performed.

### FAQ, disclaimers, and support

**Is this legal?** Scraping public product data is generally legal in most jurisdictions, but you are responsible for complying with the target site's Terms of Service, copyright on images and copy, and applicable data-protection laws (GDPR, CCPA). Don't scrape personal data and don't use scraped content in ways that violate the merchant's rights.

**Why are no products returned?** Either (a) the site isn't Shopify-based — verify with the `/admin` trick above — or (b) Cloudflare blocked the request. Switch to residential proxies and try again.

**Why is the price wrong?** Shopify returns prices as strings or integer cents depending on the endpoint. This actor normalizes everything to integer cents (×100). `1999` means `$19.99`. If your store supports multiple currencies, set the `currency` field to force a specific one.

**How do I report bugs or request features?** Open an issue on this actor's **Issues** tab on the Apify Store. We also build custom Shopify scraping pipelines on request — reach out via the Apify contact form.

# Actor input Schema

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

URLs to scrape. Accepts homepages (https://kith.com), collection pages (https://kith.com/collections/kith-tops), single product pages (https://kith.com/products/kith-williams-iii-hoodie-black), and search URLs (https://kith.com/search?q=hoodie). To verify a target is Shopify-based, navigate to https://<domain>/admin — if you see a Shopify login page, the site is compatible.

## `query` (type: `string`):

Optional. When provided alongside a homepage/collection/store URL in startUrls, the actor will run Shopify's predictive search for this query against that store and scrape the matching products instead of crawling the full catalog.

## `maxRequestsPerCrawl` (type: `integer`):

Maximum number of products to scrape across all sources combined. Set to 0 for unlimited (capped by Shopify's catalog size). Collection records are not counted.

## `maxRecommendationsPerProduct` (type: `integer`):

Number of related/recommended products to fetch for each scraped product. Set to 0 to disable. Each recommendation is emitted as its own product record and charged separately.

## `currency` (type: `string`):

Three-letter ISO currency code (e.g., USD, EUR, GBP). When set, ?currency=<code> is appended to scraped URLs so the store returns prices in that currency. Leave empty to use the store's default. The store must support the chosen currency.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for failed requests (429, 5xx, network errors).

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

Apify proxy. Residential proxies are highly recommended — many Shopify stores aggressively block datacenter ranges and Cloudflare gateways will return 403 without a clean IP.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://kith.com"
    }
  ],
  "maxRequestsPerCrawl": 100,
  "maxRecommendationsPerProduct": 0,
  "maxRequestRetries": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Scraped products and collections. Records are discriminated by the `type` field ('product' | 'collection').

# 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 = {
    "startUrls": [
        {
            "url": "https://kith.com"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("prodiger/shopify-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 = {
    "startUrls": [{ "url": "https://kith.com" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("prodiger/shopify-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 '{
  "startUrls": [
    {
      "url": "https://kith.com"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call prodiger/shopify-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify Scraper - Products, Collections, Analysis",
        "description": "Scrape products and collections from any Shopify-powered store. Pay-per-event pricing — only pay for the items you actually scrape. No API key needed.",
        "version": "0.1",
        "x-build-id": "r5GPSeEVKpc9MU11S"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/prodiger~shopify-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-prodiger-shopify-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/prodiger~shopify-scraper/runs": {
            "post": {
                "operationId": "runs-sync-prodiger-shopify-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/prodiger~shopify-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-prodiger-shopify-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "URLs to scrape. Accepts homepages (https://kith.com), collection pages (https://kith.com/collections/kith-tops), single product pages (https://kith.com/products/kith-williams-iii-hoodie-black), and search URLs (https://kith.com/search?q=hoodie). To verify a target is Shopify-based, navigate to https://<domain>/admin — if you see a Shopify login page, the site is compatible.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "query": {
                        "title": "Search query (optional)",
                        "type": "string",
                        "description": "Optional. When provided alongside a homepage/collection/store URL in startUrls, the actor will run Shopify's predictive search for this query against that store and scrape the matching products instead of crawling the full catalog."
                    },
                    "maxRequestsPerCrawl": {
                        "title": "Max products per run",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of products to scrape across all sources combined. Set to 0 for unlimited (capped by Shopify's catalog size). Collection records are not counted.",
                        "default": 100
                    },
                    "maxRecommendationsPerProduct": {
                        "title": "Recommendations per product",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of related/recommended products to fetch for each scraped product. Set to 0 to disable. Each recommendation is emitted as its own product record and charged separately.",
                        "default": 0
                    },
                    "currency": {
                        "title": "Currency override (optional)",
                        "pattern": "^[A-Za-z]{3}$",
                        "type": "string",
                        "description": "Three-letter ISO currency code (e.g., USD, EUR, GBP). When set, ?currency=<code> is appended to scraped URLs so the store returns prices in that currency. Leave empty to use the store's default. The store must support the chosen currency."
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for failed requests (429, 5xx, network errors).",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy. Residential proxies are highly recommended — many Shopify stores aggressively block datacenter ranges and Cloudflare gateways will return 403 without a clean IP.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```