# App Store Intelligence Pro - ASO & Rank Tracker (`webdatalabs/app-store-intelligence-pro`) Actor

Cross-store (Apple App Store + Google Play) ASO & competitor research: keyword difficulty + popularity, rank tracking, top charts, full metadata and AI review insights.

- **URL**: https://apify.com/webdatalabs/app-store-intelligence-pro.md
- **Developed by:** [WebDataLabs](https://apify.com/webdatalabs) (community)
- **Categories:** SEO tools, AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 keyword intelligences

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## App Store Intelligence Pro — Cross-Store ASO, Keyword Difficulty & Rank Tracking

Apple App Store **and** Google Play in one unified schema: keyword difficulty + popularity scores, keyword rank tracking, top charts, full app metadata, and AI-mined review insights.

### What you get

**App Store Intelligence Pro** is a cross-store **ASO (App Store Optimization) and competitive research** tool. Instead of just downloading app data, it answers the questions ASO and app-marketing teams actually act on: **how hard is a keyword to rank for, how much demand does it have, who ranks for it today, and how are those positions moving over time** — for both Apple App Store and Google Play, in a single flat schema you can pipe straight into a sheet, a dashboard, or an agent.

The flagship is the **keyword intelligence** mode: for every keyword you give it, you get a **difficulty score (0–100)** — computed from how many apps target the term and how strong the top-ranked apps are — plus a **popularity estimate (5–100)** and the live competitor count. Run it on a schedule and it tracks **rank deltas and popularity deltas** across runs, so you see movement, not just a snapshot.

### What can it do?

| Mode | What you give it | What you get back |
|------|------------------|-------------------|
| **Keyword intelligence** | Keywords | Difficulty + popularity score, competitor count, deltas over time (one row per keyword) |
| **Keyword rankings** | Keywords | Which apps rank for the keyword, their position + rank change (one row per app) |
| **App details** | App names, store URLs, IDs or package names | Full metadata: rating, ratings count, price, category, version, release notes… |
| **Top charts** | (nothing, or `free`/`paid`/`grossing`) | The store's top-charts ranking with position + rank change |
| **Reviews** | App names, URLs, IDs or package names | Customer reviews (rating, text, author, date, version), optional AI insights |

All modes work across **Apple App Store**, **Google Play**, or both — and across any list of countries.

### What data does it extract?

High-value fields (the full field list is auto-rendered in the Output tab):

| Field | Description |
|-------|-------------|
| `difficultyScore` / `difficultyLabel` | Keyword ranking difficulty 0–100 (Easy → Very hard) |
| `popularityScore` / `popularityLabel` | Estimated keyword search demand 5–100 (Low → Very high) |
| `competitorCount` | Number of apps targeting the keyword |
| `popularityDelta` | Change in popularity vs the previous run |
| `rankPosition` / `rankDelta` | Rank for a keyword or chart, and its change vs the previous run |
| `title`, `developer`, `category`, `rating`, `ratingCount`, `price`, `version` | Core app metadata (both stores) |
| `reviewRating`, `reviewText`, `reviewAuthor`, `reviewDate` | Individual customer reviews |
| `aiThemes`, `aiSentiment`, `aiPraises`, `aiComplaints` | AI-mined review insights (opt-in) |

### Example output

Keyword intelligence (one row per keyword):

```json
{
  "recordType": "keyword",
  "store": "apple",
  "country": "us",
  "keyword": "habit tracker",
  "difficultyScore": 77,
  "difficultyLabel": "Very hard",
  "popularityScore": 79,
  "popularityLabel": "Very high",
  "competitorCount": 190,
  "isEstimated": true,
  "popularityDelta": 3,
  "scrapedAt": "2026-07-04T12:00:00Z"
}
````

Keyword rankings (one row per ranking app):

```json
{
  "recordType": "ranking",
  "store": "apple",
  "country": "us",
  "rankKeyword": "habit tracker",
  "rankType": "search",
  "rankPosition": 2,
  "rankDelta": 1,
  "title": "Habit Tracker - HabitKit",
  "developer": "Sebastian Roehl",
  "rating": 4.85,
  "ratingCount": 2212,
  "url": "https://apps.apple.com/us/app/id6443918070"
}
```

> Note: Apple search and app-details rows carry the full ratings count; Google Play *rankings* and *charts* rows carry the star rating but not the ratings count (that needs a detail fetch — use **app-details** mode for full Google Play metadata).

### How to use it

1. Pick a **mode** (default: keyword intelligence).
2. Fill **query** with keywords, or — for app details / reviews — paste App Store / Google Play URLs, Apple IDs, or Android package names.
3. Choose **stores** (Apple, Google Play, or both) and **countries**.
4. Run it. Schedule it to track rank and popularity movement over time.

Track keyword difficulty across both stores:

```json
{ "mode": "keyword-intelligence", "query": ["habit tracker", "meditation", "budget planner"], "stores": ["apple", "google-play"], "countries": ["us", "gb"] }
```

Pull reviews with AI insights for a competitor:

```json
{ "mode": "reviews", "query": ["https://apps.apple.com/us/app/id310633997", "com.whatsapp"], "stores": ["apple", "google-play"], "countries": ["us"], "aiEnrichment": true }
```

### How much does it cost?

This actor uses **pay-per-event** pricing — you only pay for the results you actually get (per keyword scored, per ranking, per app, per review, and per AI insight), with the exact rates shown in the pricing box above. A trial keyword run costs a few cents. There is no subscription.

### Use cases

- **ASO managers** — score a shortlist of target keywords by difficulty and demand, then target the winnable ones (filter `difficultyLabel = "Easy"` or `"Moderate"` with a healthy `popularityScore`).
- **App marketers tracking competitors** — schedule keyword-rankings and watch `rankDelta` to catch when a rival gains or loses positions.
- **Growth teams doing cross-store analysis** — compare the same keywords on Apple vs Google Play in one dataset (Apple's fuzzy search and Play's stricter matching give complementary signals).
- **Product teams** — pull reviews with `aiEnrichment` to surface the top `aiComplaints` and `aiThemes` across a competitor set.
- **Market researchers** — snapshot top charts by country and track chart movement over time.

### FAQ

#### How is keyword difficulty calculated?

From the live search results: how many apps target the keyword combined with how strong the top-ranked apps are (their rating volume). A term dominated by a few apps with millions of ratings scores as very hard; a term whose top apps have a few hundred ratings scores as easy. This mirrors the method professional ASO tools use.

#### Is the popularity score Apple's official Search Popularity?

No — and it says so (`isEstimated: true`). Apple's official 5–100 Search Popularity lives behind Apple Search Ads and has no public data source. This actor computes an **honest estimate** from the observable demand signal (the rating-base strength of the apps that win the term). It's best used to compare keywords against each other and to track movement over time via `popularityDelta`.

#### Does it track rankings over time?

Yes. Rank positions and popularity scores are stored per keyword/store/country between runs, so scheduled runs return `rankDelta` and `popularityDelta` automatically (they are `null` on the first run).

#### How many reviews can it get?

Google Play reviews are paginated and effectively uncapped by `maxResults`. Apple caps recent reviews at about 500 per app per country — fan out across countries for more volume. This actor is built for ASO and competitor intelligence, not bulk review archiving.

#### Is it legal to scrape the app stores?

The actor only reads **publicly available** store data through near-official endpoints and does not collect personal identity beyond a reviewer's public display name. As with any scraping, you are responsible for complying with the stores' terms and applicable law in your use of the data.

#### Do I need my own API keys?

No. AI review insights work out of the box; you can optionally supply your own OpenAI key. Datacenter proxy is enough for keyword, rankings, app-details and charts modes; reviews mode automatically routes Apple review fetching through residential proxy for reliability, so you don't need to configure anything.

### Related actors

- **Google Play Reviews Scraper** — deep review extraction for a single store.
- **Amazon Reviews Scraper**, **Testberichte Scraper Pro** — review intelligence on other platforms.
- **Semrush Scraper**, **Google Trends Reliable** — more of the webdatalabs research toolkit.

### Support

Questions, edge cases, or a store layout change? Open an issue on the **Issues** tab and the webdatalabs team will take a look.

### Leave a review

Is this actor saving you time? A quick review on the Store helps other people find it — and tells us which fields to add next. **[Rate this actor →](https://apify.com/webdatalabs/app-store-intelligence-pro)**

# Actor input Schema

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

Pick the job. Keyword intelligence returns a difficulty + popularity score per keyword (the flagship). Keyword rankings returns which apps rank for each keyword. App details returns full metadata. Top charts returns the store rankings. Reviews returns customer reviews (optionally AI-summarized).

## `query` (type: `array`):

For keyword modes: search terms (e.g. "vpn", "habit tracker"). For app-details / reviews: App Store or Google Play URLs, Apple track IDs (e.g. 310633997), or Android package names (e.g. com.whatsapp). For top charts: leave empty (or a Google Play category name). Pasted store URLs are accepted directly.

## `stores` (type: `array`):

Which store(s) to query.

## `countries` (type: `array`):

ISO country codes to query, e.g. us, gb, de. Popularity and rankings are country-specific.

## `maxResults` (type: `integer`):

Upper bound per keyword/app/country. Reviews are capped by the store (Apple ~500/app/country).

## `aiEnrichment` (type: `boolean`):

Reviews mode only. Adds AI-mined themes, sentiment, top praises and complaints per app (gpt-4o-mini). Billed per app at the AI rate.

## `openaiApiKey` (type: `string`):

Optional. Only used when AI review insights is on. Falls back to the built-in key if omitted.

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

Datacenter proxy is enough for Apple and Google Play. Switch to Residential only if you see blocks at high volume.

## `debug` (type: `boolean`):

Verbose logs for troubleshooting.

## Actor input object example

```json
{
  "mode": "keyword-intelligence",
  "query": [
    "habit tracker"
  ],
  "stores": [
    "apple",
    "google-play"
  ],
  "countries": [
    "us"
  ],
  "maxResults": 100,
  "aiEnrichment": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  },
  "debug": false
}
```

# Actor output Schema

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

No description

## `keywordIntelligence` (type: `string`):

No description

## `rankings` (type: `string`):

No description

## `reviews` (type: `string`):

No description

## `full` (type: `string`):

No description

# 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 = {
    "query": [
        "habit tracker"
    ],
    "countries": [
        "us"
    ],
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("webdatalabs/app-store-intelligence-pro").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 = {
    "query": ["habit tracker"],
    "countries": ["us"],
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("webdatalabs/app-store-intelligence-pro").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 '{
  "query": [
    "habit tracker"
  ],
  "countries": [
    "us"
  ],
  "maxResults": 100
}' |
apify call webdatalabs/app-store-intelligence-pro --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "App Store Intelligence Pro - ASO & Rank Tracker",
        "description": "Cross-store (Apple App Store + Google Play) ASO & competitor research: keyword difficulty + popularity, rank tracking, top charts, full metadata and AI review insights.",
        "version": "1.0",
        "x-build-id": "hnupKUpoAKOHfygO7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/webdatalabs~app-store-intelligence-pro/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-webdatalabs-app-store-intelligence-pro",
                "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/webdatalabs~app-store-intelligence-pro/runs": {
            "post": {
                "operationId": "runs-sync-webdatalabs-app-store-intelligence-pro",
                "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/webdatalabs~app-store-intelligence-pro/run-sync": {
            "post": {
                "operationId": "run-sync-webdatalabs-app-store-intelligence-pro",
                "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": "What do you want",
                        "enum": [
                            "keyword-intelligence",
                            "keyword-rankings",
                            "app-details",
                            "top-charts",
                            "reviews"
                        ],
                        "type": "string",
                        "description": "Pick the job. Keyword intelligence returns a difficulty + popularity score per keyword (the flagship). Keyword rankings returns which apps rank for each keyword. App details returns full metadata. Top charts returns the store rankings. Reviews returns customer reviews (optionally AI-summarized).",
                        "default": "keyword-intelligence"
                    },
                    "query": {
                        "title": "Keywords or apps",
                        "type": "array",
                        "description": "For keyword modes: search terms (e.g. \"vpn\", \"habit tracker\"). For app-details / reviews: App Store or Google Play URLs, Apple track IDs (e.g. 310633997), or Android package names (e.g. com.whatsapp). For top charts: leave empty (or a Google Play category name). Pasted store URLs are accepted directly.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "stores": {
                        "title": "Stores",
                        "type": "array",
                        "description": "Which store(s) to query.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "apple",
                                "google-play"
                            ],
                            "enumTitles": [
                                "Apple App Store",
                                "Google Play"
                            ]
                        },
                        "default": [
                            "apple",
                            "google-play"
                        ]
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "ISO country codes to query, e.g. us, gb, de. Popularity and rankings are country-specific.",
                        "default": [
                            "us"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results per query",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Upper bound per keyword/app/country. Reviews are capped by the store (Apple ~500/app/country).",
                        "default": 100
                    },
                    "aiEnrichment": {
                        "title": "AI review insights",
                        "type": "boolean",
                        "description": "Reviews mode only. Adds AI-mined themes, sentiment, top praises and complaints per app (gpt-4o-mini). Billed per app at the AI rate.",
                        "default": false
                    },
                    "openaiApiKey": {
                        "title": "OpenAI API key (optional)",
                        "type": "string",
                        "description": "Optional. Only used when AI review insights is on. Falls back to the built-in key if omitted."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Datacenter proxy is enough for Apple and Google Play. Switch to Residential only if you see blocks at high volume.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": []
                        }
                    },
                    "debug": {
                        "title": "Debug logging",
                        "type": "boolean",
                        "description": "Verbose logs for troubleshooting.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```