# Shopify Store Scraper (`scraperx/shopify-store-scraper`) Actor

🛍️ Shopify Store Scraper extracts products, prices, variants, inventory, images, collections & SEO data from public Shopify stores. ⚡ Fast, scalable, API-ready. 📊 CSV/JSON export. 🚀 Ideal for competitor analysis, price tracking, and catalog enrichment.

- **URL**: https://apify.com/scraperx/shopify-store-scraper.md
- **Developed by:** [ScraperX](https://apify.com/scraperx) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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 Store Scraper

Shopify Store Scraper is a production-ready Shopify store scraping tool that extracts structured store metadata, product catalogs, variants, prices, inventory metrics, collections, theme details, detected apps, and optional Yotpo reviews from public Shopify stores. It solves the pain of manual data collection by providing an automated Shopify product scraper and Shopify store data extractor that’s fast, scalable, and export-ready. Built for marketers, developers, data analysts, and researchers, it helps you scrape Shopify products, analyze pricing and stock health, and automate catalog enrichment at scale — all through the Apify platform.

### What data / output can you get?

Below are examples of real output fields this Shopify product data scraper saves to the Apify dataset. Values are illustrative.

| Data type | Description | Example value |
| --- | --- | --- |
| store_domain | Store domain without protocol | www.allbirds.com |
| store_url | Full store URL | https://www.allbirds.com |
| shop_name | Shopify shop domain derived from meta | shop11044168.myshopify.com |
| country | Country code from meta.json | US |
| currency | Store currency code from meta.json | USD |
| locale | Content language (from meta or HTML) | en-US |
| theme_name | Active theme name parsed from HTML | rc-cm-2025-12-26_20-35 Update |
| total_products | Count of products from /products.json | 681 |
| total_variants | Sum of variants across products | 7276 |
| price_min | Minimum variant price across catalog | 2.0 |
| price_avg | Average variant price (2 decimals) | 79.34 |
| price_max | Maximum variant price across catalog | 500.0 |

Bonus outputs include theme_id, theme_version, collections (titles), collections_count, categories (product types), vendors, total_variants_available, inventory_availability_pct, estimated_launch_date/newest_product_date, products_with_images, avg_images_per_product, products_with_description, detected apps (apps_installed, apps_by_category, apps_count), top_products, and optional detailed_reviews when review extraction is enabled. Export your data from the Apify dataset as JSON, CSV, or Excel — ideal for a Shopify product export scraper workflow.

### Key features

- 🧠 Smart proxy fallback (when Apify Proxy is enabled)  
  Automatically progresses from direct requests to datacenter, then to residential proxies with retries on 403/429/503. Once residential is used, it’s kept for subsequent requests — boosting reliability for your Shopify store crawler workflows.

- 📦 Comprehensive catalog coverage  
  Uses Shopify’s public JSON endpoints (/products.json, /collections.json, /meta.json) to collect products, variants, prices, images, vendors, categories, and collections — a robust Shopify catalog scraper for structured data.

- ⭐ Optional Yotpo review extraction  
  Toggle extractReviews to fetch review stats for the 10 newest products and return per-product counts, average scores, and sampled reviews in detailed_reviews.

- 💾 Live dataset saving  
  Results are pushed to the Apify dataset as each store completes, so you can access partial data even if a long run stops — perfect for Shopify store data mining at scale.

- 🛡️ Resilient error handling  
  Store-level failures are saved as dataset items with error details, while remaining stores continue processing — a dependable Shopify web scraper for unattended runs.

- 📈 Pricing and inventory analytics  
  Computes price_min, price_avg, price_max, total_variants_available, and inventory_availability_pct out of the box — use it as a Shopify product price scraper and Shopify inventory scraper in one.

- 🔁 Batch store scraping  
  Provide multiple startUrls to scrape many Shopify shops in a single run — ideal for a Shopify store crawler at scale.

- 👩‍💻 Developer-friendly  
  Access all data via the Apify API or export to CSV/JSON/Excel. Great for pipelines, dashboards, and scripts — including Shopify store scraper Python automations via the Apify API.

- 🔐 No login or cookies required  
  Scrapes public endpoints only — a clean, safe alternative to a Shopify store scraper Chrome extension.

### How to use Shopify Store Scraper - step by step

1. Sign up or log in to your Apify account.
2. Open the “shopify-store-scraper” actor in your console.
3. Configure inputs:
   - startUrls: Add one or more Shopify store URLs (e.g., https://www.allbirds.com).
   - extractReviews: Set true to collect Yotpo review details for the 10 newest products; false to skip reviews for faster runs.
   - proxyConfiguration: Optional. Set useApifyProxy to true to enable smart proxy fallback (datacenter → residential with retries).
4. Click Start to launch the run.
5. Monitor progress in the Logs tab — you’ll see product page counts and any proxy fallback events.
6. Open the Dataset (OUTPUT) tab to view items as they’re saved while the run progresses.
7. Export results as JSON, CSV, or Excel — or fetch them programmatically via the Apify API for your Shopify product export scraper workflow.

Pro Tip: Automate recurring scrapes via the Apify API and pipe the dataset to your analytics stack or data warehouse for ongoing competitor monitoring and catalog updates.

### Use cases

| Use case name | Description |
| --- | --- |
| Competitor price monitoring | Track price_min/avg/max and newest products across competitor stores using this Shopify competitor product scraper for timely pricing moves. |
| Catalog export to CSV | Scrape Shopify products to CSV with titles, handles, prices, vendors, and categories for merchandising or marketplace onboarding. |
| Market research & trend analysis | Aggregate collections, categories, and vendors across many stores to study product mix and trends using a Shopify store data extractor. |
| Inventory availability tracking | Monitor total_variants_available and inventory_availability_pct to gauge stock health across selected catalogs. |
| Theme and app intelligence | Detect theme_name, theme_version, and apps_installed for ecosystem research and theme/app adoption analysis. |
| Review insights (Yotpo) | Enable extractReviews to collect reviews_count and avg_rating for recent products and benchmark customer sentiment. |
| Data pipeline ingestion (API) | Use the Apify API to ingest JSON outputs into BI tools or internal pipelines for continuous Shopify store data mining. |

### Why choose Shopify Store Scraper?

This solution prioritizes reliability and structured output for production data extraction.

- 🎯 Accurate, structured fields from public Shopify JSON APIs for consistent analytics.
- 🚀 Scales across multiple stores by accepting a list of startUrls and processing each sequentially.
- 🔌 Developer access via the Apify API with flexible exports (JSON, CSV, Excel) for easy integration.
- 🔒 Safe by design: no login or cookies; public endpoints only.
- 🧰 Production-ready: robust error handling and live dataset saves reduce operational risk.
- 🌐 Adaptive proxy strategy (when Apify Proxy is enabled) to minimize blocks and improve success rates.
- 🧩 More reliable than browser extensions — enjoy server-side stability and repeatability for your Shopify store scraping tool.

In short, it’s a dependable Shopify product data scraper that balances breadth of data, resiliency, and ease of integration.

### Is it legal / ethical to use Shopify Store Scraper?

Yes — when used responsibly. This actor collects data from publicly available Shopify endpoints (/products.json, /collections.json, /meta.json) and publicly accessible product pages. It does not access private or password-protected content.

Guidelines for compliant use:
- Scrape only public data and respect website terms of service.
- Ensure compliance with data protection laws (e.g., GDPR, CCPA) and your local regulations.
- Avoid misuse of contact or personal data; focus on product and catalog analytics.
- Consult your legal team for edge cases or jurisdiction-specific questions.

### Input parameters & output format

Example JSON input
```json
{
  "startUrls": [
    "https://www.allbirds.com",
    "https://example-store.myshopify.com"
  ],
  "extractReviews": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

Input fields

- startUrls (array, required): List one or more Shopify store URLs (e.g., https://www.allbirds.com). Default: not set.
- extractReviews (boolean, optional): Enable to extract detailed product reviews from Yotpo (slower but more comprehensive). Default: true.
- proxyConfiguration (object, optional): Choose which proxies to use. If Shopify rejects the proxy, a residential proxy will be used as a fallback. Default: not set.

Example JSON output (successful store item)

```json
{
  "store_domain": "www.allbirds.com",
  "store_url": "https://www.allbirds.com",
  "shop_name": "shop11044168.myshopify.com",
  "country": "US",
  "currency": "USD",
  "locale": "en-US",
  "theme_name": "rc-cm-2025-12-26_20-35 Update",
  "theme_id": 128596836432,
  "theme_version": "1.131.2",
  "apps_installed": ["Elevar Conversion Tracking", "JsEncrypt"],
  "apps_by_category": {
    "Analytics": ["Elevar Conversion Tracking"],
    "Other": ["JsEncrypt"]
  },
  "apps_count": 2,
  "total_products": 681,
  "total_variants": 7276,
  "collections": ["Accessories", "Shoes", "Apparel"],
  "collections_count": 250,
  "categories": ["Accessories", "Apparel", "Shoes", "Socks"],
  "vendors": ["Allbirds"],
  "price_min": 2.0,
  "price_avg": 79.34,
  "price_max": 500.0,
  "products_on_sale": 681,
  "discount_pct_avg": null,
  "products_with_reviews": 0,
  "review_coverage_pct": 0,
  "avg_reviews_per_product": null,
  "avg_rating": null,
  "total_estimated_sales": null,
  "avg_sales_per_product": null,
  "total_variants_available": 5647,
  "inventory_availability_pct": 77.6,
  "estimated_launch_date": "2018-11-12",
  "oldest_product_date": "2018-11-12",
  "newest_product_date": "2025-11-06",
  "products_with_images": 680,
  "avg_images_per_product": 4.5,
  "products_with_description": 681,
  "top_products": [
    {
      "title": "Allbirds Laces - Warm Red - Round",
      "url": "https://www.allbirds.com/products/allbirds-laces-warm-red-round",
      "price": 8.0,
      "reviews": 0,
      "rating": 0.0
    }
  ],
  "detailed_reviews": [
    {
      "product_url": "https://www.allbirds.com/products/allbirds-laces-warm-red-round",
      "product_id": "7242343809104",
      "reviews_count": 0,
      "avg_rating": 0.0,
      "reviews": []
    }
  ],
  "scraped_at": "2025-12-29T07:34:23.715157Z",
  "scrape_duration_sec": 15.71,
  "api_blocked": false
}
```

Example JSON output (error item when a store fails)

```json
{
  "store_url": "https://blocked-store.example",
  "error": "Failed to fetch homepage from https://blocked-store.example. All request attempts failed.",
  "scraped_at": "2026-04-09T10:00:00.000Z"
}
```

Example JSON output (error item when no valid URLs are supplied)

```json
{
  "error": "No valid URLs found in startUrls. Please provide at least one Shopify store URL in the input.",
  "input_received": {
    "startUrls": []
  },
  "scraped_at": "2026-04-09T10:00:00.000Z"
}
```

Notes:

- Some fields may be null if not present on the target (e.g., theme\_name, theme\_id, theme\_version) or when metrics are not calculated (e.g., discount\_pct\_avg).
- The api\_blocked flag is true when no products are returned (often due to blocking).
- detailed\_reviews is only included when extractReviews is true and reviews are successfully fetched.

### FAQ

#### Is there a free Shopify scraper I can try before subscribing?

Yes. You can run the Shopify Store Scraper on Apify and export sample results from the dataset. Availability and limits depend on your Apify plan, which makes it easy to evaluate.

#### Do I need to log in or provide cookies to scrape Shopify stores?

No. The scraper uses public Shopify endpoints and publicly accessible product pages. It requires no login or cookies.

#### Can I scrape multiple Shopify stores in one run?

Yes. Add multiple URLs to startUrls. The actor processes stores sequentially and saves each store’s results to the dataset as soon as it’s done.

#### How does blocking and proxy fallback work?

If you enable Apify Proxy via proxyConfiguration.useApifyProxy, the scraper will attempt direct requests first, then switch to a datacenter proxy, and finally to a residential proxy with retries on 403/429/503. Once residential is used, it’s kept for the rest of the run. Without Apify Proxy enabled, requests are direct only.

#### What product data does this Shopify web scraper extract?

It collects totals for products and variants, pricing analytics (price\_min/avg/max), inventory availability (total\_variants\_available, inventory\_availability\_pct), collections, categories, vendors, theme details, detected apps, and top\_products. Optional detailed\_reviews are available when extractReviews is enabled.

#### Can I export the results to CSV or Excel?

Yes. All results are saved to the Apify dataset. From there, you can export to JSON, CSV, or Excel, or access the data via the Apify API — ideal for a Shopify product export scraper workflow.

#### How are errors reported if a store fails?

Failures are captured as dataset items with store\_url, error, and scraped\_at. If no valid URLs are supplied, the dataset includes an item with error, input\_received, and scraped\_at explaining the issue.

#### Does review extraction work for all products?

When extractReviews is true, the scraper targets the 10 newest products and attempts to fetch Yotpo-based review metadata and samples. If a product has no Yotpo integration or parsing fails, that product will keep default review values (reviews: 0, rating: 0.0).

#### Can I use it with Python or my own scripts?

Yes. You can access the Apify dataset and actor runs via the Apify API from any language, including Python, to build automated pipelines and reporting workflows.

#### Is this better than a Shopify store scraper Chrome extension?

For repeatability and scale, yes. This server-side Shopify store scraping tool avoids browser instability and lets you automate jobs, export data reliably, and integrate results into your systems.

### Closing thoughts

Shopify Store Scraper is built to extract structured Shopify store intelligence at scale. With adaptive proxy fallback (when enabled), resilient error handling, and clean JSON outputs, it empowers marketers, developers, analysts, and researchers to build dependable Shopify data pipelines. Use the Apify API to automate batches, export Shopify products to CSV, and integrate insights anywhere in your stack. Start extracting smarter, faster Shopify store insights today.

# Actor input Schema

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

List one or more Shopify store URLs (e.g., https://www.allbirds.com).

## `extractReviews` (type: `boolean`):

Enable to extract detailed product reviews from Yotpo (slower but more comprehensive).

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

Choose which proxies to use. If Shopify rejects the proxy, a residential proxy will be used as a fallback.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.allbirds.com"
  ],
  "extractReviews": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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": [
        "https://www.allbirds.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperx/shopify-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 = {
    "startUrls": ["https://www.allbirds.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify Store Scraper",
        "description": "🛍️ Shopify Store Scraper extracts products, prices, variants, inventory, images, collections & SEO data from public Shopify stores. ⚡ Fast, scalable, API-ready. 📊 CSV/JSON export. 🚀 Ideal for competitor analysis, price tracking, and catalog enrichment.",
        "version": "0.1",
        "x-build-id": "na4ZQwtYwmqLSqYod"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperx~shopify-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperx-shopify-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/scraperx~shopify-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperx-shopify-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/scraperx~shopify-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperx-shopify-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Shopify Store URLs",
                        "type": "array",
                        "description": "List one or more Shopify store URLs (e.g., https://www.allbirds.com).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "extractReviews": {
                        "title": "Extract Product Reviews",
                        "type": "boolean",
                        "description": "Enable to extract detailed product reviews from Yotpo (slower but more comprehensive).",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. If Shopify rejects the proxy, a residential proxy will be used as a fallback."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
