# App Store & Google Play Review Sentiment Analyzer (`jurassic_jove/app-store-google-play-review-sentiment`) Actor

Scrape Apple App Store and Google Play reviews and get an AI cross-platform sentiment report: overall + per-store sentiment, top complaints/praises, and exactly where iOS and Android users disagree. Fully managed AI, no setup.

- **URL**: https://apify.com/jurassic\_jove/app-store-google-play-review-sentiment.md
- **Developed by:** [Data Runner](https://apify.com/jurassic_jove) (community)
- **Categories:** Lead generation, Automation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $200.00 / 1,000 cross-platform app review reports

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

## App Store & Google Play Review Sentiment Analyzer — iOS + Android Reviews with AI

**Analyze app reviews from the Apple App Store and Google Play in a single run — and see exactly where iOS and Android users disagree.** Get an AI-powered sentiment report with an executive summary, top complaints and praises, per-store breakdowns, a reputation-risk score, and the headline cross-platform comparison. Built for **app founders, product managers, ASO specialists, and competitive-intelligence teams** analyzing their own app or a competitor's.

No setup, no AI keys to manage, no scraping two separate tools and merging by hand. Point it at an app, pick your stores, and run.

---

### The differentiator: one run, both stores, side-by-side

Most review tools scrape a single store. This Actor analyzes **both at once** and surfaces the divergence that single-store tools can't — for example:

> *"Android users report crashes on launch and account bans, while iOS users mainly complain about a recent UI update and pricing. Both share security concerns, but Google Play ratings skew higher."*

That cross-platform delta — **how iOS vs Android sentiment and themes differ** — is generated automatically whenever you analyze both stores. It's the single most useful signal for prioritizing what to fix first, and for whom.

#### Results at a glance

A real example (Instagram, US, both stores) — the per-store split surfaces a gap a single-store tool would miss:

| Metric | 🍎 App Store (iOS) | 🤖 Google Play (Android) |
| --- | --- | --- |
| Average rating | **2.56 / 5** | **3.40 / 5** |
| Positive reviews | 36% | 60% |
| Negative reviews | 56% | 36% |
| AI sentiment score | 2 / 10 | 4 / 10 |

> **Cross-platform delta:** *"iOS users are far more critical (2.56/5), focusing on forced UI changes, account bans, and bugs; Android users are more positive (3.40/5) but still report account suspensions and feed problems."*

---

### Popular use cases

- **Competitor app research** — compare iOS vs Android sentiment for a rival app and find their weak spots.
- **Post-launch / post-update monitoring** — track how sentiment shifts after you ship an update, per platform.
- **ASO & store-listing research** — understand the language users actually use about your app.
- **Bug & feature prioritization** — see what to fix first, and which platform is hurting most.
- **Cross-platform parity audits** — quantify the App Store vs Google Play perception gap.

---

### What you get

- ✅ **Unified AI sentiment report** — executive summary, overall sentiment score, reputation-risk index, trend direction.
- ✅ **Top complaints & praises** — the themes users actually talk about, extracted by AI.
- ✅ **Per-store breakdown** — App Store vs Google Play: review counts, average rating, sentiment %, rating distribution.
- ✅ **Cross-platform delta** — the AI comparison of where iOS and Android users diverge (when both stores are analyzed).
- ✅ **Every analyzed review** (optional) — normalized, platform-tagged, with a rating-based sentiment label.
- ✅ **Resilient by design** — if one store fails or has no reviews, the other still completes. The run never crashes on a single bad review.

---

### How it works (3 steps)

1. **Choose your stores and give the app ID(s).** App Store numeric ID or URL, Google Play package name or URL. Select one store or both.
2. **Set the options.** Country/region, language, how many reviews per store, and sort order.
3. **Run.** Get one unified report (in the dataset and the key-value store), with overall + per-store metrics and the iOS-vs-Android comparison.

#### Input example — both stores (the full experience)

```json
{
  "platforms": ["app_store", "google_play"],
  "appStoreId": "310633997",
  "googlePlayId": "com.whatsapp",
  "country": "us",
  "maxReviewsPerPlatform": 200
}
````

#### Input example — App Store only (ID or URL both work)

```json
{
  "platforms": ["app_store"],
  "appStoreId": "https://apps.apple.com/us/app/whatsapp-messenger/id310633997",
  "maxReviewsPerPlatform": 300
}
```

#### Input example — Google Play only

```json
{
  "platforms": ["google_play"],
  "googlePlayId": "https://play.google.com/store/apps/details?id=com.spotify.music",
  "country": "gb",
  "language": "en"
}
```

> **Where to find the IDs:** the App Store ID is the number after `id` in the store URL (`…/id310633997`). The Google Play package is the `id=` value in the Play Store URL (`…?id=com.whatsapp`). You can paste either the raw ID/package or the full URL.

***

### Output

One **unified report** per run, written both to the dataset and to the key-value store (`OUTPUT`).

#### Example — an analyzed review (when "Include individual reviews" is on)

```json
{
  "platform": "app_store",
  "reviewId": "14198636296",
  "rating": 5,
  "title": "Works great",
  "text": "Reliable and fast, never lets me down.",
  "author": "echiso",
  "date": "2026-06-18T20:02:06.000Z",
  "appVersion": "26.22.76",
  "country": "us",
  "thumbsUp": null,
  "sentiment": "positive"
}
```

#### Example — the unified summary

```json
{
  "app": "WhatsApp Messenger",
  "platforms": ["app_store", "google_play"],
  "totalReviewsAnalyzed": 400,
  "reviewsByPlatform": { "app_store": 200, "google_play": 200 },
  "overall": {
    "averageRating": 3.92,
    "sentimentBreakdown": { "positivePct": 66.7, "neutralPct": 13.3, "negativePct": 20.0 },
    "ratingDistribution": { "1": 40, "2": 35, "3": 55, "4": 60, "5": 210 }
  },
  "perPlatform": {
    "app_store":   { "averageRating": 3.73, "sentimentBreakdown": { "positivePct": 61.0 } },
    "google_play": { "averageRating": 4.10, "sentimentBreakdown": { "positivePct": 72.0 } }
  },
  "crossPlatformDelta": "Android users report crashes on launch and account bans, while iOS users focus on a recent UI update and pricing. Google Play ratings skew higher.",
  "sentiment": {
    "overallSentimentScore": 6,
    "sentimentByPlatform": { "App Store": 5, "Google Play": 7 },
    "topPraises": ["Reliable, fast messaging", "End-to-end encryption", "Easy to use"],
    "topComplaints": ["Account bans without explanation", "Buggy recent updates", "Unresponsive support"],
    "trendDirection": "stable",
    "reputationRisk": 6,
    "executiveSummary": "A trusted, widely loved messenger whose core experience rates highly, but recent updates and account-ban complaints are creating friction — more so on iOS."
  }
}
```

***

### Works perfectly with the rest of the suite

This Actor is part of the Data Runner **review-intelligence** line:

- **Google Maps Review Scraper & AI Sentiment Analyzer** — local-business reputation.
- **Hotel Review Sentiment Scraper** — cross-platform hotel reputation (TripAdvisor, Booking, Google Maps).
- **Trustpilot Review Sentiment Analyzer** — brand and store reputation.

…and the lead-generation line:

- **Google Maps Lead Generator Pro**, **Lead Deduplicator & Merger**, **Email Verifier & Enricher Pro**, **Phone Number Validator & Formatter**.

Track an app's reputation across both stores here, then feed your wider competitive research with the rest of the suite.

***

### Pricing

Simple **pay-per-event** pricing:

- **One flat charge per app analyzed** — you get a complete cross-platform report per run, regardless of how many reviews fed into it.

`maxReviewsPerPlatform` controls how deep the analysis goes (and the runtime), not the price — so a 50-review check and a 400-review deep-dive cost the same per app. There is no per-run start fee beyond the negligible platform start event. Analyze on demand, or schedule a weekly run to watch sentiment over time.

***

### Honest limitations (read this)

- **App Store review depth is capped.** Apple's public review feed is paginated and limited to roughly **500 reviews** per app/country. Google Play allows deeper pagination. We fetch up to your cap and document what was retrieved.
- **Sentiment is AI-inferred**, not a human read of every review. The per-review sentiment label is derived from the star rating; the themes, scores, and cross-platform comparison are produced by AI analysis of a balanced sample of your reviews.
- **Reviews are point-in-time.** Stores show recent and relevant reviews; results reflect what's available when you run.
- **Not affiliated with Apple or Google.** This tool analyzes publicly available store reviews.

***

### FAQ

**How do I find an app's App Store ID or Google Play package?**
Open the app's store page. The **App Store ID** is the number after `id` in the URL (`apps.apple.com/.../id310633997` → `310633997`). The **Google Play package** is the `id=` value (`play.google.com/store/apps/details?id=com.whatsapp` → `com.whatsapp`). Paste either the raw value or the whole URL.

**Can I analyze a competitor's app?**
Yes — that's one of the most popular uses. Point it at any public app on either store to see what their users love and complain about, and how iOS vs Android perception differs.

**Which countries and languages are supported?**
Provide any store country code (e.g. `us`, `gb`, `mx`) and a language for Google Play. Reviews and ratings are pulled from that store region.

**What's the maximum number of reviews?**
Up to 1,000 per store per run. Note Apple's public feed caps around 500; Google Play can go deeper. Lower the cap for a quick pulse-check, raise it for a deep dive.

**How fresh is the data?**
Live — reviews are fetched at run time. Schedule the Actor (e.g. weekly) to track sentiment trends as you ship updates.

**Do I need to configure any AI keys?**
No. The AI analysis is fully managed — just provide the app and run.

**What export formats are available?**
Results land in a standard Apify dataset you can export as **CSV, JSON, Excel, or HTML**, plus a clean summary in the key-value store.

**What happens if one store fails or has no reviews?**
The run continues with the other store and notes it in the summary. The run only fails if **no** selected store returned any reviews.

# Actor input Schema

## `platforms` (type: `array`):

Which app stores to analyze. Select one or both. With both, you also get a cross-platform comparison (iOS vs Android).

## `appStoreId` (type: `string`):

The numeric Apple App Store app ID (e.g. 310633997) OR a full App Store URL (e.g. https://apps.apple.com/us/app/whatsapp-messenger/id310633997). Required if 'Apple App Store' is selected.

## `googlePlayId` (type: `string`):

The Google Play package name (e.g. com.whatsapp) OR a full Play Store URL (e.g. https://play.google.com/store/apps/details?id=com.whatsapp). Required if 'Google Play' is selected.

## `country` (type: `string`):

ISO 3166-1 alpha-2 country/region code for the store reviews (e.g. us, gb, mx).

## `language` (type: `string`):

Review language where the store supports it (e.g. en, es). Mainly affects Google Play.

## `maxReviewsPerPlatform` (type: `integer`):

Maximum reviews to fetch from EACH selected store. Controls runtime. Note: the App Store public review feed is capped at roughly 500 by Apple.

## `sortBy` (type: `string`):

Which reviews to prioritize when fetching up to the cap.

## `includeRawReviews` (type: `boolean`):

Include every analyzed review (with its platform tag and rating-based sentiment) in the output, not just the aggregated report.

## Actor input object example

```json
{
  "platforms": [
    "app_store",
    "google_play"
  ],
  "appStoreId": "310633997",
  "googlePlayId": "com.whatsapp",
  "country": "us",
  "language": "en",
  "maxReviewsPerPlatform": 200,
  "sortBy": "newest",
  "includeRawReviews": true
}
```

# 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 = {
    "platforms": [
        "app_store",
        "google_play"
    ],
    "appStoreId": "310633997",
    "googlePlayId": "com.whatsapp",
    "country": "us",
    "language": "en",
    "maxReviewsPerPlatform": 200,
    "sortBy": "newest"
};

// Run the Actor and wait for it to finish
const run = await client.actor("jurassic_jove/app-store-google-play-review-sentiment").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 = {
    "platforms": [
        "app_store",
        "google_play",
    ],
    "appStoreId": "310633997",
    "googlePlayId": "com.whatsapp",
    "country": "us",
    "language": "en",
    "maxReviewsPerPlatform": 200,
    "sortBy": "newest",
}

# Run the Actor and wait for it to finish
run = client.actor("jurassic_jove/app-store-google-play-review-sentiment").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 '{
  "platforms": [
    "app_store",
    "google_play"
  ],
  "appStoreId": "310633997",
  "googlePlayId": "com.whatsapp",
  "country": "us",
  "language": "en",
  "maxReviewsPerPlatform": 200,
  "sortBy": "newest"
}' |
apify call jurassic_jove/app-store-google-play-review-sentiment --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "App Store & Google Play Review Sentiment Analyzer",
        "description": "Scrape Apple App Store and Google Play reviews and get an AI cross-platform sentiment report: overall + per-store sentiment, top complaints/praises, and exactly where iOS and Android users disagree. Fully managed AI, no setup.",
        "version": "1.0",
        "x-build-id": "q7EJZyhGbSbax16Yg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jurassic_jove~app-store-google-play-review-sentiment/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jurassic_jove-app-store-google-play-review-sentiment",
                "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/jurassic_jove~app-store-google-play-review-sentiment/runs": {
            "post": {
                "operationId": "runs-sync-jurassic_jove-app-store-google-play-review-sentiment",
                "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/jurassic_jove~app-store-google-play-review-sentiment/run-sync": {
            "post": {
                "operationId": "run-sync-jurassic_jove-app-store-google-play-review-sentiment",
                "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",
                "properties": {
                    "platforms": {
                        "title": "Platforms",
                        "type": "array",
                        "description": "Which app stores to analyze. Select one or both. With both, you also get a cross-platform comparison (iOS vs Android).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "app_store",
                                "google_play"
                            ],
                            "enumTitles": [
                                "Apple App Store",
                                "Google Play"
                            ]
                        },
                        "default": [
                            "app_store",
                            "google_play"
                        ]
                    },
                    "appStoreId": {
                        "title": "App Store app ID or URL",
                        "type": "string",
                        "description": "The numeric Apple App Store app ID (e.g. 310633997) OR a full App Store URL (e.g. https://apps.apple.com/us/app/whatsapp-messenger/id310633997). Required if 'Apple App Store' is selected."
                    },
                    "googlePlayId": {
                        "title": "Google Play package name or URL",
                        "type": "string",
                        "description": "The Google Play package name (e.g. com.whatsapp) OR a full Play Store URL (e.g. https://play.google.com/store/apps/details?id=com.whatsapp). Required if 'Google Play' is selected."
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "ISO 3166-1 alpha-2 country/region code for the store reviews (e.g. us, gb, mx).",
                        "default": "us"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Review language where the store supports it (e.g. en, es). Mainly affects Google Play.",
                        "default": "en"
                    },
                    "maxReviewsPerPlatform": {
                        "title": "Max reviews per platform",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum reviews to fetch from EACH selected store. Controls runtime. Note: the App Store public review feed is capped at roughly 500 by Apple.",
                        "default": 200
                    },
                    "sortBy": {
                        "title": "Sort reviews by",
                        "enum": [
                            "newest",
                            "most_relevant",
                            "rating"
                        ],
                        "type": "string",
                        "description": "Which reviews to prioritize when fetching up to the cap.",
                        "default": "newest"
                    },
                    "includeRawReviews": {
                        "title": "Include individual reviews",
                        "type": "boolean",
                        "description": "Include every analyzed review (with its platform tag and rating-based sentiment) in the output, not just the aggregated report.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
