# Shopify Store Analyzer (Pay per Event) (`eiv/shopify-store-analyzer`) Actor

Analyze any Shopify store in seconds. Detect 90+ installed apps, 19 analytics & ad pixels, theme, products, pricing, collections, social profiles, contact info, and payment methods. No browser — fast parallel HTTP.

- **URL**: https://apify.com/eiv/shopify-store-analyzer.md
- **Developed by:** [Eimantas V](https://apify.com/eiv) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 14.3% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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 Store Analyzer

Extract comprehensive intelligence from any **Shopify store** in seconds — no browser, no proxies required. This Actor performs a parallel HTTP analysis of any Shopify-powered website and returns a structured **JSON dataset** covering installed apps, analytics pixels, products, theme, social links, contact info, pricing, and much more.

Whether you're doing **competitive research**, building a **lead list of Shopify merchants**, or analyzing **ecommerce tech stacks**, this Actor delivers deep store intelligence at scale — fast and cost-efficiently.

---

### What can the Shopify Store Analyzer do?

- **Detect 90+ installed Shopify apps** across 20+ categories (email, SMS, reviews, loyalty, subscriptions, chat, upsell, page builders, and more)
- **Identify 19 analytics and ad pixels** including Meta Pixel, Google Analytics 4, TikTok Pixel, Pinterest Tag, Snapchat, LinkedIn Insight, Reddit Pixel, Criteo, and more
- **Extract theme information** — name, ID, and Shopify theme store ID
- **Scrape product catalog** — prices, vendors, product types, tags, variant counts, and a detailed sample
- **Pull all collections, pages, and blogs** from the store's public API
- **Detect payment methods** — Visa, Mastercard, PayPal, Shop Pay, Klarna, Afterpay, Affirm, Apple Pay, Google Pay, and more
- **Extract social media profiles** — Instagram, Facebook, Twitter/X, YouTube, TikTok, Pinterest, LinkedIn, Snapchat
- **Find contact details** — email addresses and phone numbers
- **Check published policies** — refund, privacy, shipping, terms of service, and legal notice
- **Parse JSON-LD structured data** from the homepage
- **Works on any Shopify store** — branded domains, myshopify.com domains, headless Shopify stores

#### Why use the Shopify Store Analyzer?

Unlike browser-based scrapers, this Actor uses **direct HTTP requests to Shopify's public APIs** and the store's homepage — making it **5–10× faster** and significantly cheaper to run. No Playwright, no Chrome, no proxy required for most stores.

With the **Apify platform**, you can:
- Schedule store monitoring to track competitor changes over time
- Plug results into Google Sheets, Airtable, or any CRM via integrations
- Connect to Zapier, Make, or your own pipeline via the API
- Run bulk analyses across thousands of Shopify stores in parallel

---

### What data does the Shopify Store Analyzer extract?

| Category | Data Points |
|---|---|
| **Store** | Name, myshopify domain, primary domain, currency, money format, locale, country, shop ID |
| **Theme** | Theme name, theme ID, Shopify theme store ID, role |
| **Products** | Count, price range, average price, vendors, product types, tags, total variants, 20-item sample |
| **Collections** | Count + full list with handles |
| **Pages & Blogs** | Page count + titles, blog count + handles |
| **Installed Apps** | Name, category, slug, detected via (script pattern) — 90+ signatures |
| **Analytics Pixels** | Name, category, detected via — 19 tracker signatures |
| **Payment Methods** | Visa, Mastercard, PayPal, Shop Pay, Apple Pay, Google Pay, Klarna, Afterpay, Affirm, and more |
| **Social Links** | Instagram, Facebook, Twitter/X, YouTube, TikTok, Pinterest, LinkedIn, Snapchat |
| **Contact** | Email address, phone number |
| **Policies** | Refund, privacy, terms of service, shipping, legal notice (present/absent) |
| **Metadata** | Page title, meta description, OG image, canonical URL, favicon, theme color |
| **JSON-LD** | All structured data blocks from the homepage |
| **Performance** | Total fetch time (ms), endpoints queried, endpoints succeeded |

---

### How to scrape a Shopify store

#### Step 1 — Open the Actor

Go to the **Input** tab in the Apify Console.

#### Step 2 — Add store URLs

Enter one or more Shopify store URLs in the **Store URLs** field. You can use branded domains (`https://gymshark.com`) or myshopify domains (`https://gymshark.myshopify.com`).

#### Step 3 — Set max products (optional)

The default is **250 products** (one API page). Increase to 5,000 for full catalog analysis, or drop to 10 for a quick tech-stack check.

#### Step 4 — Run the Actor

Click **Start**. Most single-store runs complete in **1–3 seconds**.

#### Step 5 — Download your data

Results are available as **JSON**, **CSV**, or **Excel** from the Storage tab, or via the Apify API.

---

### Input

Configure the Actor from the **Input** tab in the Apify Console, or pass a JSON body to the API.

```json
{
  "urls": [
    "https://gymshark.com",
    "https://allbirds.com",
    "https://rothys.com"
  ],
  "maxProducts": 250
}
````

| Field | Type | Default | Description |
|---|---|---|---|
| `urls` | `string[]` | — | **Required.** One or more Shopify store URLs |
| `maxProducts` | `integer` | `250` | Max products to fetch per store (1–5,000) |
| `proxyConfiguration` | `object` | — | Optional Apify Proxy settings |

***

### Output

Results are saved to the **Apify Dataset** as one JSON record per store. Here is a real example output:

```json
{
  "url": "https://gymshark.com",
  "scrapedAt": "2025-01-15T10:23:41.882Z",
  "isShopify": true,
  "store": {
    "name": "Gymshark",
    "myshopifyDomain": "gymshark.myshopify.com",
    "primaryDomain": "gymshark.com",
    "currency": "GBP",
    "moneyFormat": "£{{amount}}",
    "locale": "en",
    "country": "GB"
  },
  "theme": {
    "name": "Prestige",
    "id": 133770387565,
    "themeStoreId": 580,
    "role": "main"
  },
  "products": {
    "fetched": 250,
    "hasMore": true,
    "priceRange": { "min": 18.00, "max": 70.00 },
    "avgPrice": 38.50,
    "vendors": ["Gymshark"],
    "productTypes": ["Shorts", "T-Shirts", "Leggings", "Hoodies"],
    "tags": ["mens", "womens", "training", "lifting", "running"],
    "totalVariants": 2847,
    "sample": [
      {
        "id": 7823912345,
        "title": "Vital Seamless 2.0 Leggings",
        "vendor": "Gymshark",
        "productType": "Leggings",
        "handle": "vital-seamless-2-0-leggings",
        "price": 45.00,
        "compareAtPrice": null,
        "variantCount": 12,
        "imageCount": 6,
        "tags": ["womens", "seamless", "training"],
        "availableForSale": true,
        "createdAt": "2023-08-01T09:00:00Z"
      }
    ]
  },
  "collections": {
    "count": 42,
    "list": [
      { "id": 123456789, "handle": "mens", "title": "Men's", "updatedAt": "2025-01-10T12:00:00Z" }
    ]
  },
  "pages": { "count": 14, "titles": ["About Us", "Sustainability", "Size Guide", "Contact"] },
  "blogs": { "count": 2, "handles": ["news", "athlete-stories"] },
  "policies": {
    "refund": true,
    "privacy": true,
    "termsOfService": true,
    "shipping": true,
    "legalNotice": false
  },
  "apps": [
    { "name": "Klaviyo", "slug": "klaviyo", "category": "email_sms_marketing", "detectedVia": "klaviyo.com" },
    { "name": "Yotpo", "slug": "yotpo", "category": "reviews", "detectedVia": "staticw2.yotpo.com" },
    { "name": "Gorgias", "slug": "gorgias", "category": "customer_support", "detectedVia": "config.gorgias.chat" },
    { "name": "Smile.io", "slug": "smile", "category": "loyalty", "detectedVia": "cdn.smile.io" },
    { "name": "Rebuy", "slug": "rebuy", "category": "personalization_upsell", "detectedVia": "rebuyengine.com" }
  ],
  "pixels": [
    { "name": "Google Analytics 4", "category": "analytics", "detectedVia": "googletagmanager.com" },
    { "name": "Meta Pixel", "category": "paid_social", "detectedVia": "connect.facebook.net/en_US/fbevents" },
    { "name": "TikTok Pixel", "category": "paid_social", "detectedVia": "analytics.tiktok.com" },
    { "name": "Hotjar", "category": "heatmaps_analytics", "detectedVia": "static.hotjar.com" }
  ],
  "social": {
    "instagram": "https://www.instagram.com/gymshark/",
    "facebook": "https://www.facebook.com/Gymshark",
    "twitter": "https://twitter.com/gymshark",
    "youtube": "https://www.youtube.com/gymshark",
    "tiktok": "https://www.tiktok.com/@gymshark",
    "pinterest": null,
    "linkedin": "https://www.linkedin.com/company/gymshark",
    "snapchat": null
  },
  "contact": {
    "email": "support@gymshark.com",
    "phone": null
  },
  "paymentMethods": ["American Express", "Apple Pay", "Google Pay", "Mastercard", "PayPal", "Shop Pay", "Visa"],
  "performance": {
    "totalTimeMs": 1842,
    "endpointsQueried": 5,
    "endpointsSucceeded": 5
  }
}
```

***

### Use cases

**Competitor intelligence** — Track what apps and pixels your competitors are using. Know when they add a loyalty program, switch email providers, or start running TikTok ads.

**Sales prospecting** — Build targeted lists of Shopify merchants filtered by app stack (e.g., stores using Klaviyo + Recharge = high-intent subscription brand targets).

**Market research** — Analyze pricing strategies, product catalog size, and payment method adoption across a segment.

**Agency pitching** — Identify stores missing key tools (no reviews app, no live chat, no SMS) as outreach hooks.

**Investment due diligence** — Validate claims about store scale, product range, and tech sophistication.

***

### Other Actors you might find useful

| Actor | What it does |
|---|---|
| [**Meta Ads Library Scraper**](https://console.apify.com/actors/7utCWNseUb44VvYu3) | Scrape Facebook and Instagram ads by keyword or page URL — copy, CTA, reach, targeting, and delivery dates |
| [**Website Brand Extractor**](https://console.apify.com/actors/9n5ak6ClwMnlsbxN6) | Extract logos, brand colors, fonts, favicon, social links, and OG metadata from any website |
| [**Pinterest Scraper**](https://console.apify.com/actors/yLoirSPyhDp8eWmiu) | Scrape Pinterest pins by keyword or URL — images, saves, comments, board details, and dominant colors |

> **Pro tip:** Combine the Shopify Store Analyzer with the Website Brand Extractor to get a complete brand intelligence package — tech stack + visual identity — in a single pipeline.

***

### Is it legal to scrape Shopify stores?

This Actor only accesses **publicly available data** — the same data any visitor sees when browsing a store. It uses Shopify's public JSON endpoints (`/products.json`, `/collections.json`, etc.) and the store homepage.

We recommend:

- Reviewing the target store's **Terms of Service** and **robots.txt** before large-scale scraping
- Not using scraped data to spam or harass store owners
- Complying with **GDPR** and relevant data protection regulations in your jurisdiction

For a detailed overview of web scraping legality, see [Apify's guide on web scraping legality](https://apify.com/legal/web-scraping-legality).

***

### FAQ

#### Does this work on all Shopify stores?

Yes — any store powered by Shopify exposes the public endpoints this Actor uses. This includes headless Shopify stores, stores with custom domains, and Shopify Plus merchants.

#### Do I need a proxy?

No proxy is required for most stores. Shopify's public endpoints are not IP-restricted. For very large bulk runs, you can optionally enable Apify Proxy in the input settings.

#### How fast is it?

Typical single-store analysis completes in **1–3 seconds**. The Actor fires all HTTP requests in parallel and does not render a browser.

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

Yes. Use the **Export** button in the Apify Dataset view, or call the [Apify API](https://docs.apify.com/api/v2) with `?format=csv` or `?format=xlsx`.

#### Can I integrate this with Zapier or Make?

Yes — use the Apify integration available on both [Zapier](https://zapier.com/apps/apify/integrations) and [Make](https://www.make.com/en/integrations/apify) to trigger workflows when new store data is scraped.

***

### Support

- Questions about usage? Use the **Discussion** tab on the Actor page

# Actor input Schema

## `urls` (type: `array`):

List of Shopify store URLs to analyze (e.g. https://allbirds.com).

## `maxProducts` (type: `integer`):

Maximum number of products to retrieve per store (250 per page).

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

Optional Apify Proxy settings.

## Actor input object example

```json
{
  "urls": [
    "https://gymshark.com"
  ],
  "maxProducts": 250
}
```

# Actor output Schema

## `storeData` (type: `string`):

Full store analysis records including apps, pixels, products, theme, social links, contact info, policies, and payment methods.

# 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 = {
    "urls": [
        "https://gymshark.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("eiv/shopify-store-analyzer").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 = { "urls": ["https://gymshark.com"] }

# Run the Actor and wait for it to finish
run = client.actor("eiv/shopify-store-analyzer").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 '{
  "urls": [
    "https://gymshark.com"
  ]
}' |
apify call eiv/shopify-store-analyzer --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify Store Analyzer (Pay per Event)",
        "description": "Analyze any Shopify store in seconds. Detect 90+ installed apps, 19 analytics & ad pixels, theme, products, pricing, collections, social profiles, contact info, and payment methods. No browser — fast parallel HTTP.",
        "version": "0.0",
        "x-build-id": "vfVUWWQLjL1RsyQpa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/eiv~shopify-store-analyzer/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-eiv-shopify-store-analyzer",
                "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/eiv~shopify-store-analyzer/runs": {
            "post": {
                "operationId": "runs-sync-eiv-shopify-store-analyzer",
                "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/eiv~shopify-store-analyzer/run-sync": {
            "post": {
                "operationId": "run-sync-eiv-shopify-store-analyzer",
                "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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "Store URLs",
                        "type": "array",
                        "description": "List of Shopify store URLs to analyze (e.g. https://allbirds.com).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProducts": {
                        "title": "Max Products to Fetch",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of products to retrieve per store (250 per page).",
                        "default": 250
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
