# Shopify Store Opportunity Intelligence (`thescrapelab/shopify-store-opportunity-intelligence`) Actor

Analyze Shopify stores for products, pricing, tech stack, public contacts, competitor monitoring, and agency lead opportunities.

- **URL**: https://apify.com/thescrapelab/shopify-store-opportunity-intelligence.md
- **Developed by:** [Inus Grobler](https://apify.com/thescrapelab) (community)
- **Categories:** E-commerce, Lead generation, SEO tools
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 store intelligence records

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 Opportunity Intelligence

Analyze public Shopify storefronts to extract products, pricing, discounts, tech stack, social links, public business contact info, and opportunity scores for lead generation, competitor monitoring, and e-commerce research.

Use it as a Shopify store analyzer, Shopify lead finder, Shopify product scraper, Shopify competitor monitoring tool, and Shopify tech stack research actor.

### What this actor does

- Detects whether a public storefront is likely Shopify.
- Returns one clean store intelligence record per valid store.
- Analyzes public product catalogs, prices, discounts, variants, collections, and availability.
- Detects visible Shopify apps and e-commerce tools from public storefront evidence.
- Scores agency, CRO, SEO, email/SMS, reviews, subscription, app-sales, and competitor-monitoring opportunities.
- Optionally outputs one row per public product.
- Optionally extracts public business contact information when visibly published.
- Monitors product, price, discount, availability, collection, and tech-stack changes across runs.

### Who should use it

- Shopify agencies
- CRO and SEO agencies
- Paid ads agencies
- Shopify app sales teams
- E-commerce consultants
- DTC brands monitoring competitors
- Lead generation teams
- E-commerce investors and acquirers
- Market researchers

### Use cases

- Find Shopify agency leads.
- Build Shopify store lead lists.
- Find Shopify app sales prospects.
- Monitor competitor products and prices.
- Track discounts and availability.
- Analyze Shopify tech stacks.
- Research DTC brands.
- Audit e-commerce stores for CRO and SEO opportunities.
- Monitor product catalog changes.

### Run it in 30 seconds

Paste one or more Shopify store URLs:

```json
{
  "storeUrls": [
    "https://colourpop.com"
  ]
}
````

That is enough for store opportunity analysis.

The input form is intentionally short. `analysisType` controls the extra behavior automatically:

- `storeOpportunities` returns store profiles: one row per Shopify store.
- `productCatalog` returns a product list: one row per public product, with product fields as separate columns.
- `agencyLeads` includes visibly published public business contact fields.
- `competitorMonitoring` compares against the previous run.

To get a list of products, choose **Product list - one row per product** in the input form, or set `"analysisType": "productCatalog"` in the API input.

### Simple input examples

Agency lead scoring:

```json
{
  "analysisType": "agencyLeads",
  "storeUrls": [
    "https://colourpop.com",
    "https://www.tentree.com"
  ]
}
```

Competitor price monitoring:

```json
{
  "analysisType": "competitorMonitoring",
  "storeUrls": [
    "https://colourpop.com"
  ]
}
```

Product list, one row per product:

```json
{
  "analysisType": "productCatalog",
  "storeUrls": [
    "https://colourpop.com"
  ],
  "maxProductsPerStore": 500
}
```

### Output overview

The actor has two main output shapes:

- **Store profiles**: one row per store, with flat lead, catalog, pricing, tech-stack, and opportunity fields.
- **Product list**: one row per product, with flat product columns such as `productTitle`, `productUrl`, `minVariantPrice`, `isDiscounted`, `available`, and `featuredImage`.

The default store-profile output is one row per store, with important flat fields for CSV/Excel plus nested intelligence fields.

```json
{
  "recordType": "store",
  "storeDomain": "example-store.com",
  "storeName": "Example Store",
  "platform": "Shopify",
  "platformConfidence": 0.98,
  "productCountEstimate": 428,
  "productsAnalyzed": 10,
  "averagePrice": 38.4,
  "discountedProductsPercent": 22.5,
  "reviewApp": "Judge.me",
  "emailMarketing": "Klaviyo",
  "overallOpportunityScore": 86,
  "agencyFitScore": 91,
  "topOpportunityTitle": "Subscription opportunity",
  "estimatedStoreSize": "medium"
}
```

Product-list mode outputs product records as the main dataset rows. Each product has separate spreadsheet columns for title, handle, URL, vendor, product type, tags, prices, compare-at prices, discount status, availability, variant counts, images, and source route. The full nested product object is also kept for API users who want the complete structure.

Monitoring mode outputs `change` records for new products, removed products, price changes, availability changes, discount changes, new or removed collections, and visible tech-stack changes.

The Apify Output tab includes focused dataset views:

- Store overview: one-row-per-store lead intelligence.
- Agency leads: scores, public contact fields, and social links.
- Product rows: one row per product with spreadsheet-friendly product columns.
- Monitoring changes: price, product, availability, collection, and app changes.
- Run health: warnings, validation, cost, and charge counters.

### Store opportunity scores explained

Scores are deterministic and evidence-based. The actor does not claim revenue, traffic, conversion rate, or inventory quantity unless publicly visible.

- `overallOpportunityScore`: combined B2B usefulness score.
- `agencyFitScore`: active store, meaningful catalog, public contact routes, and lead quality.
- `croOpportunityScore`: review gaps, discounting, policy/page gaps, upsell gaps, and product metadata.
- `seoOpportunityScore`: product/page coverage, blog/content signals, metadata, and schema evidence.
- `emailSmsOpportunityScore`: catalog size, DTC fit, discounts, and missing visible email/SMS tools.
- `reviewsOpportunityScore`: product pages with no visible review app or widget.
- `subscriptionOpportunityScore`: replenishable categories without a visible subscription app.
- `appSalesOpportunityScore`: Shopify fit, active store signals, and missing competing app category.
- `competitorMonitoringValueScore`: catalog size, discounting, and public price/availability data.

### Tech-stack detection

The actor detects common storefront tools from public scripts, DOM markers, app snippets, CSS classes, globals, and visible widgets.

Examples include Judge.me, Loox, Yotpo, Okendo, Klaviyo, Omnisend, Attentive, Postscript, Recharge, Skio, Gorgias, Zendesk, Rebuy, Google Tag Manager, Meta Pixel, TikTok Pixel, Shop Pay, Klarna, Algolia, Searchspring, and more.

Tech-stack detection is based on public storefront evidence and may be partial when a store hides scripts, blocks bots, or loads apps only after user interaction.

### Public contact info

Public contact extraction is disabled by default.

When enabled, the actor only extracts visibly published business contact details such as generic support, info, hello, or sales emails, public phone numbers, contact page URLs, and about page URLs. It does not submit forms and does not collect private customer data.

### Pricing

Pricing is pay-per-event. You are charged only for valid useful records:

- Store records: `$2.00 per 1,000` valid Shopify store intelligence records.
- Product records: `$1.50 per 1,000` valid public product rows in Product list mode.
- Change records: `$1.00 per 1,000` valid monitoring change records.

What counts as a paid result:

- A valid `store` record with Shopify detected and status `ok` or `partial`.
- A valid `product` record when product row output is enabled.
- A valid `change` record when monitoring detects a real public change.

What is not charged:

- Run summaries
- Warnings
- Invalid inputs
- Skipped stores
- Blocked stores
- Non-Shopify records
- Duplicate records
- Malformed records
- Products that are unchanged during monitoring

Pricing is based on measured Apify benchmark runs for store and product records. The default store analysis profile was cost-optimized after testing 512 MB, 1024 MB, and 2048 MB configurations. Change-record pricing is provisional until larger real monitoring-change volume is available.

The actor uses explicit pay-per-event records. Run summaries, warnings, skipped stores, and non-Shopify records are not charged as default dataset items.

### Pricing and cost tips

- Basic store analysis is the cheapest mode.
- The default analyzes up to 10 public products per store to keep costs low.
- Product rows increase output volume and runtime.
- Higher `maxProductsPerStore` values increase runtime.
- Competitor monitoring is best for scheduled recurring runs.
- Browser fallback is disabled by default to keep runs cheap.
- Leave public contact extraction off unless you need visible business contact fields.

### API examples

JavaScript:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('TheScrapeLab/shopify-store-opportunity-intelligence').call({
  storeUrls: ['https://colourpop.com'],
  analysisType: 'storeOpportunities'
});

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

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("TheScrapeLab/shopify-store-opportunity-intelligence").call(
    run_input={
        "storeUrls": ["https://colourpop.com"],
        "analysisType": "storeOpportunities",
    }
)

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

cURL:

```bash
curl "https://api.apify.com/v2/acts/TheScrapeLab~shopify-store-opportunity-intelligence/runs?token=$APIFY_TOKEN" \
  -H "content-type: application/json" \
  -d '{"storeUrls":["https://colourpop.com"],"analysisType":"storeOpportunities"}'
```

### CSV and exports

Use the default one-row-per-store output for lead lists, agency prospecting, app prospecting, and competitor summaries.

Choose `productCatalog` when you want one row per product for product catalog exports, price tracking, or product research. In this mode, store profile records are not mixed into the main business output; product rows are the primary result.

The main store row includes CSV-friendly fields such as `storeDomain`, `storeName`, `productCountEstimate`, `productsAnalyzed`, `averagePrice`, `discountedProductsPercent`, `reviewApp`, `emailMarketing`, `overallOpportunityScore`, `agencyFitScore`, `topOpportunityTitle`, and `estimatedStoreSize`.

Product rows include CSV-friendly fields such as `storeDomain`, `productId`, `productHandle`, `productTitle`, `productVendor`, `productType`, `productUrl`, `currency`, `minVariantPrice`, `maxVariantPrice`, `compareAtPriceMin`, `compareAtPriceMax`, `isDiscounted`, `discountPercent`, `available`, `availableVariants`, `totalVariants`, `featuredImage`, `sourceType`, and `sourceScrapedAt`.

### Competitor monitoring and change detection

Use:

```json
{
  "analysisType": "competitorMonitoring",
  "storeUrls": [
    "https://colourpop.com"
  ]
}
```

The first run stores a compact public state. Later runs compare against that state and output change records only when public product, pricing, availability, discount, collection, metadata, or visible app signals change.

### Limitations

- Some stores disable public product JSON.
- Some stores block bots or hide data behind JavaScript.
- Exact revenue, traffic, conversion rate, and inventory are not available unless publicly visible.
- Product counts may be estimates.
- Tech-stack detection is based on public storefront evidence.
- Browser fallback costs more and is disabled by default.
- Public contact extraction only works when business contact details are visibly published.
- This actor is not affiliated with Shopify.

### Privacy and compliance

This actor uses public storefront data only.

It does not:

- Access Shopify Admin
- Use Shopify Admin API
- Attempt login
- Scrape checkout
- Add items to cart
- Submit forms
- Scrape customer data
- Collect private information
- Solve CAPTCHAs
- Bypass access controls
- Use paid third-party enrichment APIs

### FAQ

#### Is this a Shopify Admin API tool?

No. It analyzes public Shopify storefronts only.

#### Does it scrape private customer data?

No. It does not scrape customer accounts, checkout, carts, payment pages, private reviews, or private customer data.

#### Can it monitor price changes?

Yes. Use competitor monitoring to compare products, prices, discounts, availability, collections, and visible app signals across runs.

#### Can it output one row per product?

Yes. Choose **Product list - one row per product** in the input form, or set `"analysisType": "productCatalog"`. The actor will output product records with separate product, price, discount, availability, and image columns.

#### Does it work without proxies?

Yes. The default public input does not require proxy setup. Advanced API users can still pass proxy configuration if they have a specific need.

#### Why are some stores partial?

Some stores block public routes, disable product JSON, load data through JavaScript, or expose only limited public information.

#### Why are product counts sometimes estimates?

Shopify stores do not always publish exact catalog counts. The actor estimates from public JSON routes, sitemaps, collections, and sampled product pages.

#### What does opportunity score mean?

It is a deterministic B2B usefulness score based on visible public evidence such as catalog size, app gaps, policy pages, social links, pricing signals, product data, and contact routes.

#### Can I use it for Shopify agency lead generation?

Yes. Use agency lead scoring to prioritize stores worth pitching for CRO, SEO, retention, ads, tech stack, content, or catalog work.

#### Can I use it for Shopify app sales prospecting?

Yes. The actor detects visible app categories and highlights stores where a competing app category was not detected.

### Store metadata

- SEO title: Shopify Store Analyzer & Lead Finder
- SEO description: Analyze Shopify stores for products, prices, discounts, tech stack, public contacts, competitor monitoring, and agency lead opportunities.
- Recommended categories: E-commerce, Lead generation, Marketing

# Actor input Schema

## `storeUrls` (type: `array`):

Paste Shopify store URLs or domains to analyze. You can enter one store or many stores.

## `analysisType` (type: `string`):

Choose Store profiles for one summary row per Shopify store, or Product list for separate product rows with product columns.

## `maxProductsPerStore` (type: `integer`):

For Product list mode, this is the maximum product rows per store. For Store profiles, it controls how many public products are sampled for pricing and catalog signals.

## Actor input object example

```json
{
  "storeUrls": [
    "https://colourpop.com"
  ],
  "analysisType": "storeOpportunities",
  "maxProductsPerStore": 10
}
```

# Actor output Schema

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

All records produced by the actor.

## `storeOverview` (type: `string`):

Default dataset view focused on one row per Shopify store.

## `agencyLeads` (type: `string`):

Dataset view focused on agency-fit and opportunity scores.

## `productRows` (type: `string`):

Dataset view for detailed product records when product row output is enabled.

## `monitoringChanges` (type: `string`):

Dataset view for product, price, availability, collection, metadata, and tech-stack changes.

## `runHealth` (type: `string`):

Dataset view for warnings and run summary records.

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify Store Opportunity Intelligence",
        "description": "Analyze Shopify stores for products, pricing, tech stack, public contacts, competitor monitoring, and agency lead opportunities.",
        "version": "1.0",
        "x-build-id": "OUDvabWMl2IZ73s0r"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/thescrapelab~shopify-store-opportunity-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-thescrapelab-shopify-store-opportunity-intelligence",
                "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/thescrapelab~shopify-store-opportunity-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-thescrapelab-shopify-store-opportunity-intelligence",
                "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/thescrapelab~shopify-store-opportunity-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-thescrapelab-shopify-store-opportunity-intelligence",
                "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": [
                    "storeUrls"
                ],
                "properties": {
                    "storeUrls": {
                        "title": "Shopify store URLs",
                        "type": "array",
                        "description": "Paste Shopify store URLs or domains to analyze. You can enter one store or many stores.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "analysisType": {
                        "title": "What do you want to analyze?",
                        "enum": [
                            "storeOpportunities",
                            "productCatalog",
                            "agencyLeads",
                            "competitorMonitoring"
                        ],
                        "type": "string",
                        "description": "Choose Store profiles for one summary row per Shopify store, or Product list for separate product rows with product columns.",
                        "default": "storeOpportunities"
                    },
                    "maxProductsPerStore": {
                        "title": "Max products per store",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "For Product list mode, this is the maximum product rows per store. For Store profiles, it controls how many public products are sampled for pricing and catalog signals.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```