# Storenvy Store Products Scraper (`automation-lab/storenvy-store-products-scraper`) Actor

Extract Storenvy catalogs with product prices, variants, SKUs, inventory, collections, images, availability, and public store metadata.

- **URL**: https://apify.com/automation-lab/storenvy-store-products-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are 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

## Storenvy Store Products Scraper

Extract complete public Storenvy catalogs without a browser, login, or manual copy-and-paste.

Provide one or more Storenvy storefront or product URLs and receive structured product, price, variant, inventory, collection, image, and store data. Export it as JSON, CSV, Excel, XML, or RSS, or connect the dataset to your own automation.

### What does Storenvy Store Products Scraper do?

Storenvy Store Products Scraper turns a public Storenvy storefront into analysis-ready product records.

It can:

- 🏪 scrape an entire public storefront catalog
- 🎯 extract one specific product by URL
- 💵 capture product and variant prices
- 📦 capture SKU, stock quantity, sold-out state, and availability
- 🏷️ collect marketplace categories, labels, and store collections
- 🖼️ return original product image URLs
- 🧭 attach public store identity, location, avatar, and marketplace URL
- 🔁 combine several storefronts in one run and remove duplicate products

The Actor uses Storenvy's public structured storefront endpoints. It does not need a browser or an account.

### Who is it for?

#### Ecommerce agencies

Build migration inventories, catalog audits, and client reports without copying each product manually.

#### Indie sellers and store operators

Back up public catalog details, verify inventory presentation, or prepare a move to another commerce platform.

#### Competitive intelligence teams

Schedule repeat runs to compare public prices, sales, inventory, and sold-out status across selected shops.

#### Developers and data teams

Feed normalized Storenvy product data into databases, dashboards, search indexes, enrichment jobs, or internal APIs.

#### Researchers

Study public indie-brand catalogs, assortment structure, categories, and price positioning.

### Why use this Storenvy scraper?

- **Structured output:** receive stable fields instead of parsing storefront HTML.
- **Variants included:** retain SKU, per-variant price, sale price, inventory, and status.
- **Store context included:** every row is self-contained and identifies its source store.
- **Simple scheduling:** run hourly, daily, or weekly from Apify Console.
- **Global limits:** control the total number of products and testing cost.
- **No duplicates:** repeated URLs for the same store/product emit one row.
- **Fail-closed behavior:** invalid domains and total extraction failures do not silently produce a misleading successful run.

### What data can I extract?

| Field | Description |
|---|---|
| `productId` | Storenvy product ID |
| `storeId` | Storenvy store ID |
| `name` | Product name |
| `description` | Public product description |
| `url`, `shortUrl` | Public product URLs |
| `status` | Product status reported by Storenvy |
| `price` | Product-level price |
| `onSale`, `preorder` | Sale and preorder flags |
| `soldOut`, `available` | Normalized availability flags |
| `marketplaceCategory` | Storenvy marketplace category slug |
| `labels` | Product labels, when available |
| `collections` | Collection IDs and names |
| `variants` | Variant IDs, names, SKU, prices, sale price, and inventory |
| `imageUrls` | Original product image URLs |
| `store` | Public store metadata |
| `scrapedAt` | UTC extraction timestamp |

### How to scrape a Storenvy catalog

1. Open the Actor input page.
2. Paste a custom storefront URL such as `https://storenvyou.storenvy.com`.
3. Set **Maximum products** to the catalog size you need.
4. Choose whether to include inactive and sold-out products.
5. Click **Start**.
6. Open the Dataset tab to preview or export your records.

For a single product, paste its full storefront product URL instead of the store homepage.

### Input

```json
{
  "startUrls": [
    { "url": "https://storenvyou.storenvy.com" }
  ],
  "maxItems": 50,
  "includeInactive": false,
  "includeSoldOut": true
}
````

#### Input fields

| Field | Type | Default | Meaning |
|---|---|---:|---|
| `startUrls` | array | required | Public custom Storenvy storefront or product URLs |
| `maxItems` | integer | `50` | Global product cap across all supplied URLs |
| `includeInactive` | boolean | `false` | Keep products whose status is not active |
| `includeSoldOut` | boolean | `true` | Keep products whose variants are sold out |

Use custom storefront URLs ending in `.storenvy.com`. Marketplace directory URLs under `www.storenvy.com/stores/...` are not accepted because they do not reliably identify the custom storefront hostname.

### Output example

```json
{
  "productId": 34470496,
  "storeId": 1036238,
  "name": "Harajuku poached Backpack",
  "url": "https://storenvyou.storenvy.com/products/34470496-harajuku-poached-backpack",
  "status": "active",
  "price": 25.7,
  "onSale": false,
  "preorder": false,
  "soldOut": false,
  "available": true,
  "marketplaceCategory": "womens-accessories-bags-purses-wallets",
  "collections": [{ "id": 1936366, "name": "Bags" }],
  "variants": [
    {
      "id": 163647013,
      "name": "Default",
      "sku": "",
      "price": 25.7,
      "inStock": 100,
      "soldOut": false,
      "status": "active"
    }
  ],
  "imageUrls": ["https://prod-cdn-01.storenvy.com/product_photos/.../file_original.jpg"],
  "store": {
    "id": 1036238,
    "name": "storenvyou",
    "url": "https://storenvyou.storenvy.com",
    "location": "Cedar Hill, TX"
  },
  "scrapedAt": "2026-07-22T00:00:00.000Z"
}
```

Exact fields depend on what the public store provides. Arrays remain arrays, numeric IDs and prices remain numbers, and availability flags remain booleans.

### Scrape individual Storenvy products

Use product URLs when you need targeted enrichment rather than a complete catalog:

```json
{
  "startUrls": [
    { "url": "https://storenvyou.storenvy.com/products/34470496-harajuku-poached-backpack" }
  ],
  "maxItems": 1,
  "includeInactive": true,
  "includeSoldOut": true
}
```

The Actor detects the numeric product ID and requests that product directly.

### Monitor Storenvy prices and inventory

Create an Apify schedule with a stable input containing your target storefronts. Export each run to a database or compare it with the prior dataset.

Useful change keys include:

- `storeId` + `productId` for product identity
- `price` and each variant's `price` or `salePrice`
- each variant's `inStock`, `percentAvailable`, and `soldOut`
- product-level `available`, `onSale`, and `status`

Keep `includeSoldOut` enabled when monitoring availability; otherwise sold-out records are intentionally filtered out.

### How much does it cost to scrape Storenvy products?

This Actor uses pay-per-event pricing:

- a small one-time **Start** charge per run
- one **Product extracted** charge for each dataset record
- lower per-product rates on higher Apify subscription tiers

At the BRONZE rate of `$0.000036889` per product plus a `$0.005` start, a 100-product catalog is approximately `$0.00869`. Your Console displays the exact current event prices before starting a run.

Use a low `maxItems` value for trials. You are not charged a product event for records filtered out before they are saved.

### Pagination and limits

Storefront catalogs are requested in pages of up to 50 products. Pagination stops when:

- the source returns the final short page
- the global `maxItems` cap is reached
- all supplied target URLs are processed

The cap applies to saved products, not raw products rejected by inactive or sold-out filters.

### Tips for reliable runs

- ✅ Use the storefront's custom `*.storenvy.com` URL.
- ✅ Start with `maxItems: 10` to confirm the store and output shape.
- ✅ Keep sold-out records for migration and monitoring workflows.
- ✅ Use product URLs for precise one-record lookups.
- ✅ Identify records by numeric `storeId` and `productId`, not names.
- ✅ Schedule conservatively; public inventory can change between runs.
- ❌ Do not provide login-only admin pages or unrelated marketplace URLs.

### Export and integrations

Apify datasets can be downloaded as JSON, CSV, Excel, XML, RSS, or HTML.

Common workflows include:

- **Google Sheets:** send a scheduled catalog snapshot to a reporting sheet.
- **Airtable:** maintain a public assortment and price-monitoring base.
- **Make:** trigger alerts when downstream comparison logic finds stock changes.
- **Zapier:** create notifications or CRM records from newly observed products.
- **Webhooks:** call your service after each successful Actor run.
- **BigQuery or Snowflake:** load periodic snapshots for catalog trend analysis.
- **Catalog migration:** map variant and image arrays into a destination platform's import schema.

### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/storenvy-store-products-scraper').call({
  startUrls: [{ url: 'https://storenvyou.storenvy.com' }],
  maxItems: 50,
  includeSoldOut: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/storenvy-store-products-scraper").call(run_input={
    "startUrls": [{"url": "https://storenvyou.storenvy.com"}],
    "maxItems": 50,
    "includeSoldOut": True,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### cURL API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~storenvy-store-products-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url":"https://storenvyou.storenvy.com"}],
    "maxItems": 10,
    "includeSoldOut": true
  }'
```

After the run succeeds, read records from its `defaultDatasetId` through the dataset API.

### Use with Apify MCP

Connect the Actor to AI clients through the actor-scoped endpoint `https://mcp.apify.com/?tools=automation-lab/storenvy-store-products-scraper`.

#### Claude Code

```bash
claude mcp add --transport http apify-storenvy "https://mcp.apify.com/?tools=automation-lab/storenvy-store-products-scraper"
```

#### Claude Desktop, Cursor, and VS Code

Add this MCP JSON block in the **Claude Desktop**, **Cursor**, or **VS Code** MCP settings and provide your Apify authentication as required by the client:

```json
{
  "mcpServers": {
    "apify-storenvy": {
      "url": "https://mcp.apify.com/?tools=automation-lab/storenvy-store-products-scraper"
    }
  }
}
```

Example prompts:

- "Extract the first 20 products from this Storenvy store and summarize its price range."
- "Check these Storenvy product URLs and list sold-out variants."
- "Compare the SKU inventory in this run with yesterday's dataset."

The Actor tool accepts the same JSON input shown above.

### Data quality and freshness

The output reflects public Storenvy data at extraction time. `scrapedAt` records that time in UTC.

Inventory quantities are values exposed by the storefront. They are not a guarantee that checkout will accept an order. Sellers can edit or remove records at any time, and cached storefront data may briefly lag seller changes.

Descriptions and labels are returned as published. Image links point to Storenvy's CDN and may expire or change if a seller replaces media.

### Limitations

- Only public custom Storenvy storefront and product URLs are supported.
- The Actor does not access merchant dashboards, orders, customers, analytics, or other private data.
- Marketplace directory URLs do not always reveal a custom storefront and are rejected.
- Currency is not explicitly returned by the observed public product JSON, so `price` is emitted without inventing a currency code.
- Product availability is derived from public product status and variant sold-out/inventory values.
- Source endpoint changes or temporary Storenvy outages can interrupt extraction.

### Is scraping Storenvy legal?

This Actor extracts publicly accessible storefront catalog data. Scraping legality depends on your location, purpose, contract, and the data involved.

Use the Actor responsibly:

- collect only data you have a lawful reason to process
- respect applicable terms, copyright, privacy, and database rules
- avoid excessive scheduling or requests
- do not use output for spam, harassment, or deceptive activity
- consult legal counsel for regulated or high-risk use cases

The Actor does not bypass authentication or expose private merchant information.

### Troubleshooting

#### The run says the URL is not supported

Use the store's custom URL, for example `https://shopname.storenvy.com`, rather than `https://www.storenvy.com/stores/...`.

#### The run extracted no products

Confirm the storefront is public and contains products allowed by your filters. Enable `includeInactive` and `includeSoldOut` for a complete migration audit.

#### Fewer products were saved than expected

Check `maxItems`. Also check whether inactive or sold-out records were excluded. Duplicate product URLs are intentionally emitted once.

#### A store works in the browser but fails temporarily

Retry later and inspect the run log for the endpoint involved. The Actor already retries transient requests with bounded backoff.

### FAQ

#### Does it require a Storenvy account?

No. It reads only public storefront data and does not require login credentials.

#### Does it use a browser or proxy?

No. The current implementation uses public JSON over direct HTTP, reducing compute cost and runtime.

#### Can I scrape several stores in one run?

Yes. Add multiple custom storefront URLs to `startUrls`; `maxItems` applies globally.

#### Can I get variants and SKUs?

Yes. Every output row includes a `variants` array with variant ID, name, SKU, prices, inventory, availability percentage, sold-out state, and status.

#### Can I monitor sold-out products?

Yes. Leave `includeSoldOut` enabled, schedule the Actor, and compare stable product and variant IDs between snapshots.

#### Why is currency not included?

The observed public endpoint returns numeric prices but no explicit currency code. The Actor avoids guessing.

#### Can I scrape private order or customer data?

No. This Actor is limited to public product and store catalog information.

### Related ecommerce scrapers

Explore other Automation Lab ecommerce tools:

- [Amazon Scraper](https://apify.com/automation-lab/amazon-scraper)
- [eBay Scraper](https://apify.com/automation-lab/ebay-scraper)
- [Etsy Scraper](https://apify.com/automation-lab/etsy-scraper)

Choose those actors when the source is Amazon, eBay, or Etsy. Use this Actor specifically for public Storenvy custom storefronts.

### Support

If a valid public Storenvy storefront fails, open an issue from the Actor page and include:

- the storefront or product URL
- a link to the failed run
- the expected product or catalog behavior
- whether filters were enabled

Do not include credentials or private merchant data. A reproducible public example helps us investigate quickly.

# Actor input Schema

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

Public custom storefront URLs (shop.storenvy.com) or product URLs. Add multiple stores to monitor them in one run.

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

Maximum number of product records saved across all supplied stores.

## `includeInactive` (type: `boolean`):

Also save products whose Storenvy status is not active.

## `includeSoldOut` (type: `boolean`):

Keep sold-out products for availability monitoring and catalog migration.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://storenvyou.storenvy.com"
    }
  ],
  "maxItems": 10,
  "includeInactive": false,
  "includeSoldOut": true
}
```

# Actor output Schema

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

API link to normalized products extracted into the default dataset.

# 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://storenvyou.storenvy.com"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/storenvy-store-products-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://storenvyou.storenvy.com" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/storenvy-store-products-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://storenvyou.storenvy.com"
    }
  ],
  "maxItems": 10
}' |
apify call automation-lab/storenvy-store-products-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Storenvy Store Products Scraper",
        "description": "Extract Storenvy catalogs with product prices, variants, SKUs, inventory, collections, images, availability, and public store metadata.",
        "version": "0.1",
        "x-build-id": "K5NkkTqVVk2wQ2vk7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~storenvy-store-products-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-storenvy-store-products-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/automation-lab~storenvy-store-products-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-storenvy-store-products-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/automation-lab~storenvy-store-products-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-storenvy-store-products-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": "🏪 Storenvy storefront or product URLs",
                        "type": "array",
                        "description": "Public custom storefront URLs (shop.storenvy.com) or product URLs. Add multiple stores to monitor them in one run.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum products",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of product records saved across all supplied stores.",
                        "default": 50
                    },
                    "includeInactive": {
                        "title": "Include inactive products",
                        "type": "boolean",
                        "description": "Also save products whose Storenvy status is not active.",
                        "default": false
                    },
                    "includeSoldOut": {
                        "title": "Include sold-out products",
                        "type": "boolean",
                        "description": "Keep sold-out products for availability monitoring and catalog migration.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```