# Shopify App Store Scraper — Details & Reviews (`freshactors/shopify-app-store-scraper`) Actor

Reliable, always-fresh Shopify App Store data: app details, app reviews, and catalog discovery. Monitored daily. By FreshActors.

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

## Pricing

from $2.00 / 1,000 app details fetcheds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Shopify App Store Scraper — App Details, Reviews & Catalog Discovery

Scrape the **Shopify App Store** into clean, structured JSON — app **details**, store **reviews**, and full-catalog **discovery** by keyword. No account, no login, no API key. Look up apps by handle or URL, pull every review with rating and country, or find competitors across the whole catalog.

![Shopify App Store Scraper example output — structured app details + reviews](https://raw.githubusercontent.com/Freshactors/freshactors-assets/main/shopify-screenshot.png)

> ✅ **Last verified working: 2026-06-01.** This actor is monitored by an automated daily canary. When Shopify changes its markup, we patch fast and note it in the changelog below — so your data pipeline doesn't silently break.

---

### Why this Shopify App Store scraper

Most Shopify App Store scrapers break the moment Shopify tweaks a page layout — and the worst part is they **silently return nothing** or a false "0 reviews" instead of erroring loudly. That's the source of nearly every "stopped working" complaint you see on competing actors. This one is built to stay working:

- **Stable source of truth for details.** App details are read from the page's official `application/ld+json` structured-data block — title, rating, review count, category, developer — which is far more durable than scraping CSS class names that change weekly.
- **Robust, paginated reviews.** Every review with its rating, the reviewing store's name and country, how long they've used the app, the date, the full text, and (where present) the developer's reply. An empty-but-`200` review page is treated as a *soft failure* and retried with backoff — never reported as "0 reviews".
- **Catalog discovery via the official sitemap.** Find apps by keyword across the **entire Shopify App Store catalog** using Shopify's own sitemap (the canonical, always-fresh app index) instead of a fragile, client-rendered search box.
- **Stable output schema** (`_schemaVersion`) so your downstream code never breaks on a field rename.
- **Monitored daily.** A canary tests all three modes every day; any breakage is patched quickly and logged in the changelog at the bottom of this page.

If you've been burned by a scraper that quietly died, the whole reason FreshActors exists is operational reliability — "always-fresh" is the product.

### What data you get

The actor runs in three modes. Pick one with the `mode` input.

#### Mode `details` — full app metadata

| Field | Type | Description |
|---|---|---|
| `handle` | string | App slug (e.g. `klaviyo-email-marketing`) |
| `url` | string | Canonical app listing URL |
| `title` | string | App name |
| `developer` | string | Developer / publisher name |
| `category` | string | App category |
| `rating` | number | Overall star rating |
| `reviewCount` | number | Total number of reviews |
| `pricingSummary` | string | Pricing summary (e.g. "Free to install") |
| `builtForShopify` | boolean | "Built for Shopify" badge flag |
| `icon` | string | App icon image URL |
| `_type` | string | Record type (`app_details`) |
| `_schemaVersion` | string | Output schema version |
| `_scrapedAt` | string | ISO timestamp of capture |

#### Mode `reviews` — store reviews

| Field | Type | Description |
|---|---|---|
| `handle` | string | App the review belongs to |
| `reviewId` | string | Stable review identifier |
| `rating` | number | Star rating (1–5) |
| `storeName` | string | Name of the reviewing store |
| `country` | string | Store's country |
| `usedAppFor` | string | How long the store has used the app |
| `date` | string | Review date |
| `body` | string | Full review text |
| `developerReply` | string\|null | Developer's reply, if any |
| `_scrapedAt` | string | ISO timestamp of capture |

#### Mode `discover` — find apps across the catalog

Give a keyword (e.g. `email`, `review`, `crm`) and get full `details` records for matching apps drawn from the whole Shopify App Store catalog via the sitemap. Leave the keyword empty to enumerate the catalog from the top. Ideal for market research and competitor mapping.

### Use cases

- **App developers doing competitor research.** Pull `details` for every app in your niche to track rating, review count, pricing, and the "Built for Shopify" badge — the exact data you'd otherwise copy by hand. Searching for a *Shopify App Store API* or *Shopify app data export*? This is it.
- **Agencies & SaaS teams mining reviews for product insight.** Use `reviews` mode to export hundreds of reviews per app, then run sentiment or feature-request analysis. Filter by `reviewsSort` to surface the harshest (`lowest_rating`) or freshest (`newest`) feedback first.
- **Market researchers & VCs mapping the ecosystem.** Use `discover` to enumerate apps by keyword across the catalog — build a dataset of email-marketing apps, CRMs, or review widgets to size a market or screen acquisition targets.
- **Lead-gen & sales teams.** Discover apps in a category, then enrich each with developer name and pricing to build a prospect list of Shopify ecosystem players. A faceless, no-API-key way to *scrape Shopify App Store* listings on demand.

### Input

| Field | Type | Notes |
|---|---|---|
| `mode` | string | **Required.** `details` \| `reviews` \| `discover` |
| `appHandles` | string[] | App handles (e.g. `klaviyo-email-marketing`). For `details` + `reviews`. |
| `appUrls` | string[] | Alternative to handles: full app URLs. |
| `query` | string | Discovery keyword matched against app handles. For `discover`. |
| `maxApps` | int | Discovery cap, 1–1000. Default `50`. For `discover`. |
| `maxReviewsPerApp` | int | Reviews cap per app, 1–5000. Default `200`. For `reviews`. |
| `reviewsSort` | string | `newest` \| `highest_rating` \| `lowest_rating`. Default `newest`. |
| `lang` | string | Catalog language for the sitemap (two-letter). Default `en`. For `discover`. |

#### Example — details
```json
{
  "mode": "details",
  "appHandles": ["klaviyo-email-marketing", "judgeme-product-reviews"]
}
````

#### Example — reviews

```json
{
  "mode": "reviews",
  "appHandles": ["klaviyo-email-marketing"],
  "maxReviewsPerApp": 500,
  "reviewsSort": "newest"
}
```

#### Example — discover

```json
{
  "mode": "discover",
  "query": "email marketing",
  "maxApps": 50,
  "lang": "en"
}
```

### Output sample

A single `details` record:

```json
{
  "_type": "app_details",
  "_schemaVersion": "1.0",
  "handle": "klaviyo-email-marketing",
  "url": "https://apps.shopify.com/klaviyo-email-marketing",
  "title": "Klaviyo: Email Marketing & SMS",
  "developer": "Klaviyo",
  "category": "DeveloperApplication",
  "rating": 4.6,
  "reviewCount": 2805,
  "pricingSummary": "Free to install",
  "builtForShopify": false,
  "icon": "https://cdn.shopify.com/app-store/listing_images/.../icon.png",
  "_scrapedAt": "2026-06-01T08:00:00.000Z"
}
```

A single `review` record:

```json
{
  "_type": "review",
  "_schemaVersion": "1.0",
  "handle": "klaviyo-email-marketing",
  "reviewId": "2186287",
  "rating": 5,
  "storeName": "Bellaforma Jewelry",
  "country": "United States",
  "usedAppFor": "Over 1 year using the app",
  "date": "May 1, 2026",
  "body": "We've seen significant revenue growth through dialed-in flows and strategic email campaigns.",
  "developerReply": null,
  "_scrapedAt": "2026-06-01T08:00:00.000Z"
}
```

### Pricing

This actor is **pay-per-result** — no monthly subscription, you pay only for what you actually get:

| Event | What it covers | Price (USD) |
|---|---|---|
| App details fetched | Charged once per app whose full details are returned | **$0.002** |
| Discovery result fetched | Charged once per app returned from catalog discovery | **$0.001** |
| Review fetched | Charged once per app review returned | **$0.0001** |

**How much does 100 results cost?**

- **100 app details** → 100 × $0.002 = **$0.20**
- **100 reviews** → 100 × $0.0001 = **$0.01**
- **100 discovered apps** (full details for each) → 100 × $0.001 = **$0.10**

So pulling details for 100 apps and 200 reviews each (20,000 reviews) costs about $0.20 + $2.00 = **$2.20**. (Apify platform usage is billed separately per their standard rates.)

### FAQ

**Is scraping the Shopify App Store legal?**
This actor collects only **public, non-personal** listing data — the same app details, ratings, and reviews any visitor sees, plus Shopify's public sitemap. There's no login and no private account data. As with any scraping, use the data responsibly and in line with applicable terms and laws; consult your own counsel for your specific use case.

**Do I need an API key or a Shopify account?**
No. There is no official public Shopify App Store API, and this actor needs no API key, no login, and no Shopify account. You just provide handles, URLs, or a keyword.

**How do I find an app's handle?**
The handle is the slug at the end of the app URL. For `https://apps.shopify.com/klaviyo-email-marketing`, the handle is `klaviyo-email-marketing`. You can pass either handles (`appHandles`) or full URLs (`appUrls`).

**Can I get app reviews, including the country and developer replies?**
Yes. In `reviews` mode you get each review's rating, the reviewing store's name and country, how long they've used the app, the date, the full text, and the developer's reply where one exists. Cap the volume with `maxReviewsPerApp` (up to 5000).

**Can I discover or list all apps in a category?**
Yes — use `discover` mode with a keyword like `email`, `review`, or `crm`. It matches against the catalog sitemap and returns full details for up to `maxApps` (1000) matches. Leave `query` empty to enumerate the catalog from the top.

**Can I get install counts / sold data / revenue?**
No — Shopify doesn't publish install counts or revenue on listing pages, so they can't be scraped. You do get `reviewCount` and `rating`, which are the standard public popularity signals.

**How often is the data updated?**
It's live: every run fetches data fresh from Shopify at request time, stamped with `_scrapedAt`. The actor itself is verified by a daily canary across all three modes.

**What format is the output and how do I export it?**
Structured JSON per record, with a stable `_schemaVersion`. From the Apify console or API you can export the dataset to JSON, CSV, Excel, or XML.

**What happens if Shopify changes its page layout?**
Details are pulled from the durable `application/ld+json` block, and a daily canary tests every mode. If something breaks, we patch quickly and log it in the changelog — that "always-fresh" reliability is the whole point of FreshActors.

**Can I run this on a schedule?**
Yes. Use Apify Schedules to run any mode on a cron (e.g. daily review pulls), or trigger runs via the Apify API/client from your own code.

### Other FreshActors tools

| FreshActors actor | What it scrapes |
|---|---|
| [App Store Scraper](https://apify.com/freshactors/app-store-scraper) | Apple App Store — app details, search, reviews |
| [Google Play Scraper](https://apify.com/freshactors/google-play-scraper) | Google Play — app details + reviews |
| [Shopify App Store Scraper](https://apify.com/freshactors/shopify-app-store-scraper) | Shopify App Store — app details, reviews, discovery |
| [Redfin Scraper](https://apify.com/freshactors/redfin-scraper) | Redfin — US real-estate listings |
| [Greenhouse & Lever Jobs Scraper](https://apify.com/freshactors/greenhouse-lever-jobs-scraper) | Greenhouse + Lever — normalized job postings |

### Reliability

An automated **daily canary** exercises all three modes — `details`, `reviews`, and `discover` — and alerts us the moment Shopify changes something that affects output. When that happens we patch fast and record the fix in the changelog below, so you can see exactly when the actor was last verified working. Combined with the stable `_schemaVersion` on every record and JSON-LD-backed details, the goal is simple: your pipeline keeps running and never silently returns empty data.

#### Changelog

- **2026-06-01** — v1.0 launch. Details (JSON-LD structured data), reviews (paginated, with store / country / text / reply), and catalog discovery via the App Store sitemap. Daily canary monitoring across all three modes.

#### Legal note

Scrapes **public, non-personal** Shopify App Store listing data (the same data any visitor sees, plus the public sitemap). No login, no personal account data. Use responsibly and in line with applicable terms and laws.

*Found a problem? Open an issue on the actor — issues are answered fast. Staying fresh is the whole point.*

# Actor input Schema

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

What to scrape: app details, app reviews, or catalog discovery (find apps via the App Store sitemap).

## `appHandles` (type: `array`):

Shopify app handles (the slug in the app URL, e.g. klaviyo-email-marketing). Used by 'details' and 'reviews' modes.

## `appUrls` (type: `array`):

Alternative to handles: full app URLs like https://apps.shopify.com/klaviyo-email-marketing.

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

Discover mode only. Keyword matched against app handles in the App Store catalog (e.g. 'email', 'review', 'crm'). Leave empty to enumerate the catalog from the top.

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

Discover mode only. Number of matching apps to fetch full details for (1–1000).

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

Reviews mode only. Cap on reviews per app (1–5000).

## `reviewsSort` (type: `string`):

Order reviews (reviews mode). Default = Shopify's default order.

## `lang` (type: `string`):

Discover mode only. Two-letter App Store catalog language for the sitemap (default en).

## Actor input object example

```json
{
  "mode": "details",
  "appHandles": [
    "klaviyo-email-marketing"
  ],
  "maxApps": 50,
  "maxReviewsPerApp": 200,
  "reviewsSort": "newest",
  "lang": "en"
}
```

# Actor output Schema

## `results` (type: `string`):

App details / reviews / discovery results, depending on the selected mode.

# 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 = {
    "appHandles": [
        "klaviyo-email-marketing"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("freshactors/shopify-app-store-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "appHandles": ["klaviyo-email-marketing"] }

# Run the Actor and wait for it to finish
run = client.actor("freshactors/shopify-app-store-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "appHandles": [
    "klaviyo-email-marketing"
  ]
}' |
apify call freshactors/shopify-app-store-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify App Store Scraper — Details & Reviews",
        "description": "Reliable, always-fresh Shopify App Store data: app details, app reviews, and catalog discovery. Monitored daily. By FreshActors.",
        "version": "1.0",
        "x-build-id": "cotP0uzfAYkXwx0sQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/freshactors~shopify-app-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-freshactors-shopify-app-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/freshactors~shopify-app-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-freshactors-shopify-app-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/freshactors~shopify-app-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-freshactors-shopify-app-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "details",
                            "reviews",
                            "discover"
                        ],
                        "type": "string",
                        "description": "What to scrape: app details, app reviews, or catalog discovery (find apps via the App Store sitemap).",
                        "default": "details"
                    },
                    "appHandles": {
                        "title": "App handles",
                        "type": "array",
                        "description": "Shopify app handles (the slug in the app URL, e.g. klaviyo-email-marketing). Used by 'details' and 'reviews' modes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "appUrls": {
                        "title": "App URLs",
                        "type": "array",
                        "description": "Alternative to handles: full app URLs like https://apps.shopify.com/klaviyo-email-marketing.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "query": {
                        "title": "Discovery keyword",
                        "type": "string",
                        "description": "Discover mode only. Keyword matched against app handles in the App Store catalog (e.g. 'email', 'review', 'crm'). Leave empty to enumerate the catalog from the top."
                    },
                    "maxApps": {
                        "title": "Max apps to discover",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Discover mode only. Number of matching apps to fetch full details for (1–1000).",
                        "default": 50
                    },
                    "maxReviewsPerApp": {
                        "title": "Max reviews per app",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Reviews mode only. Cap on reviews per app (1–5000).",
                        "default": 200
                    },
                    "reviewsSort": {
                        "title": "Reviews sort",
                        "enum": [
                            "newest",
                            "highest_rating",
                            "lowest_rating"
                        ],
                        "type": "string",
                        "description": "Order reviews (reviews mode). Default = Shopify's default order.",
                        "default": "newest"
                    },
                    "lang": {
                        "title": "Catalog language",
                        "type": "string",
                        "description": "Discover mode only. Two-letter App Store catalog language for the sitemap (default en).",
                        "default": "en"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
