# Google Play Reviews Scraper (`fetch_cat/google-play-reviews-scraper`) Actor

Scrape public Google Play reviews with ratings, review text, dates, helpful votes, app versions, and developer replies for ASO monitoring.

- **URL**: https://apify.com/fetch\_cat/google-play-reviews-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.10 / 1,000 review saveds

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

## Google Play Reviews Scraper

Scrape public reviews from Google Play app listings. Export review text, star ratings, review dates, helpful vote counts, app version, reviewer names, and developer replies for app store monitoring, ASO research, support workflows, and competitor tracking.

### App review-mining workflow

Use [Google Play Apps Scraper](https://apify.com/fetch_cat/google-play-apps-scraper) to discover Android app IDs, ratings, installs, categories, and developer metadata.

Then use [Google Play Reviews Scraper](https://apify.com/fetch_cat/google-play-reviews-scraper) and [Apple App Store Reviews Scraper](https://apify.com/fetch_cat/apple-app-store-reviews-scraper) to collect public review text for ASO, product feedback, support triage, and competitor analysis.

Compare outputs by app, country, rating, version, and review date to build mobile app intelligence datasets.

### What does Google Play Reviews Scraper do?

Google Play Reviews Scraper collects publicly visible app reviews from Google Play.

It helps you turn app-store feedback into structured data you can analyze, filter, export, and send into your own tools.

You can provide Google Play package IDs such as `com.instagram.android` or full Google Play app URLs.

The actor returns one dataset row per review.

Each row includes the app, reviewer, rating, review text, dates, helpful votes, developer reply, locale, and scrape timestamp.

### Who is it for?

#### App developers

Track new complaints, praise, bugs, feature requests, and release feedback from your own app reviews.

#### ASO agencies

Compare review velocity, ratings, wording, and sentiment across client apps and competitor apps.

#### Product teams

Use public reviews as a continuous source of product discovery and prioritization signals.

#### Customer support teams

Monitor negative reviews and developer replies so support can escalate important issues quickly.

#### Reputation teams

Watch review trends across countries and languages before they become public reputation problems.

#### Market researchers

Collect app-store review samples for category studies, user pain-point analysis, and competitive intelligence.

### Why use this scraper?

- ✅ Scrapes public Google Play reviews without requiring a Google account.
- ✅ Accepts both package IDs and Google Play app URLs.
- ✅ Supports country and language localization.
- ✅ Supports newest, rating, and helpfulness sorting.
- ✅ Saves developer replies when Google Play provides them.
- ✅ Exports clean JSON, CSV, Excel, XML, RSS, and HTML from Apify datasets.
- ✅ Works through the Apify API, schedules, webhooks, and integrations.

### Typical use cases

- Monitor daily new reviews for your Android apps.
- Compare competitor reviews before a product launch.
- Track complaints after a new app version is released.
- Build an ASO dashboard with ratings and review text.
- Send one-star reviews to Slack or a support queue.
- Collect review samples for language-model sentiment analysis.
- Audit whether developer replies are being posted consistently.

### Input overview

The actor is designed for simple review collection.

You choose the apps, review limit, country, language, and sorting mode.

Optional date filters let you save only reviews inside a time window.

### Input fields

| Field | Type | Description |
|---|---:|---|
| `apps` | array | Google Play package IDs or full app URLs. |
| `maxReviews` | integer | Maximum number of reviews to save across all apps. |
| `country` | string | Two-letter country code such as `US`, `GB`, `DE`, or `IN`. |
| `language` | string | Language code such as `en`, `es`, `de`, or `fr`. |
| `sort` | string | `newest`, `rating`, or `helpfulness`. |
| `startDate` | string | Optional lower review-date filter. |
| `endDate` | string | Optional upper review-date filter. |

### Example input

```json
{
  "apps": [
    "com.instagram.android",
    "https://play.google.com/store/apps/details?id=com.google.android.youtube"
  ],
  "maxReviews": 100,
  "country": "US",
  "language": "en",
  "sort": "newest"
}
````

### Output data

Each dataset item represents one public Google Play review.

| Field | Description |
|---|---|
| `appId` | Google Play package ID. |
| `appUrl` | App listing URL. |
| `appName` | App title. |
| `reviewId` | Google Play review identifier. |
| `reviewUrl` | Direct Google Play review URL when available. |
| `reviewerName` | Public reviewer display name. |
| `reviewerImageUrl` | Public reviewer image URL. |
| `rating` | Star rating from 1 to 5. |
| `reviewText` | Review body text. |
| `reviewDate` | Review date as an ISO timestamp. |
| `thumbsUpCount` | Public helpful-vote count. |
| `developerReplyText` | Developer reply text, if present. |
| `developerReplyDate` | Developer reply date, if present. |
| `appVersion` | App version associated with the review, if present. |
| `country` | Country used for the scrape. |
| `language` | Language used for the scrape. |
| `sort` | Sort mode used for the request. |
| `scrapedAt` | Timestamp when the actor saved the item. |

### Example output

```json
{
  "appId": "com.instagram.android",
  "appUrl": "https://play.google.com/store/apps/details?id=com.instagram.android&hl=en&gl=US",
  "appName": "Instagram",
  "reviewId": "example-review-id",
  "reviewUrl": "https://play.google.com/store/apps/details?id=com.instagram.android&reviewId=example-review-id",
  "reviewerName": "Public Reviewer",
  "reviewerImageUrl": "https://play-lh.googleusercontent.com/example",
  "rating": 4,
  "reviewText": "Useful app with a recent issue after the latest update.",
  "reviewDate": "2026-06-15T14:05:07.944Z",
  "thumbsUpCount": 3,
  "developerReplyText": null,
  "developerReplyDate": null,
  "appVersion": "433.0.0.47.68",
  "country": "US",
  "language": "en",
  "sort": "newest",
  "scrapedAt": "2026-06-16T14:10:07.233Z"
}
```

### How much does it cost to scrape Google Play reviews?

This actor uses pay-per-event pricing.

There is a small start charge per run and a per-review charge for each saved review.

The default build is designed for affordable recurring monitoring and larger review exports.

For a typical run with 1,000 reviews, pricing is intended to be around 10–15 cents before Apify platform usage rules and any current tier discounts.

Always check the live Apify Store pricing panel for the exact current price.

### How to run it

1. Open the actor on Apify.
2. Add one or more app IDs or Google Play URLs.
3. Choose country and language.
4. Select sort order.
5. Set `maxReviews`.
6. Click **Start**.
7. Export the dataset in your preferred format.

### Best practices

- Start with a small `maxReviews` value when testing a new app.
- Use `newest` for monitoring workflows.
- Use `helpfulness` when you want high-signal reviews.
- Use country and language settings that match your target market.
- Schedule recurring runs for daily or weekly review monitoring.
- Use date filters when you only need a specific release window.

### Monitoring new reviews

For daily monitoring, run the actor on a schedule with `sort` set to `newest`.

Export the dataset to your database or send it through a webhook.

Deduplicate by `reviewId` in your downstream system.

### Competitor review tracking

You can include multiple competitor app IDs in one run.

The dataset includes `appId` and `appName`, so you can group reviews by app later.

This is useful for tracking recurring complaints, pricing feedback, missing features, and user sentiment by competitor.

### Release feedback workflows

Use `startDate` and `endDate` around a release date to collect reviews from a launch or update window.

Pair the `appVersion` field with review text to identify version-specific issues.

### Developer reply workflows

The actor saves developer reply text and reply dates when they are visible.

This helps teams audit response coverage and escalation quality.

You can filter rows where `developerReplyText` is empty to find reviews that may still need attention.

### Integrations

Use this actor with Apify integrations to automate review workflows.

- Send new one-star reviews to Slack.
- Save all reviews to Google Sheets.
- Trigger a webhook after every scheduled scrape.
- Load review data into BigQuery, Snowflake, or your BI warehouse.
- Connect to Zapier or Make for no-code workflows.
- Feed review text into sentiment analysis or issue clustering pipelines.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/google-play-reviews-scraper').call({
  apps: ['com.instagram.android'],
  maxReviews: 100,
  country: 'US',
  language: 'en',
  sort: 'newest'
});

console.log(`Dataset: ${run.defaultDatasetId}`);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/google-play-reviews-scraper').call(run_input={
    'apps': ['com.instagram.android'],
    'maxReviews': 100,
    'country': 'US',
    'language': 'en',
    'sort': 'newest',
})

print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~google-play-reviews-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"apps":["com.instagram.android"],"maxReviews":100,"country":"US","language":"en","sort":"newest"}'
```

### MCP server usage

You can use this actor from Apify MCP tools in Claude Code, Claude Desktop, and other MCP clients.

MCP URL format:

```text
https://mcp.apify.com/?tools=fetch_cat/google-play-reviews-scraper
```

Add it from Claude Code:

```bash
claude mcp add apify-google-play-reviews https://mcp.apify.com/?tools=fetch_cat/google-play-reviews-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-google-play-reviews": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/google-play-reviews-scraper"
    }
  }
}
```

Example prompts:

- "Scrape the newest 50 Google Play reviews for com.instagram.android."
- "Compare recent one-star reviews for these three Android apps."
- "Collect helpful Google Play reviews for this app and summarize recurring complaints."

### Data quality notes

Google Play may provide different review samples by country, language, sorting, and availability.

Some reviews do not include app version information.

Some reviews do not have developer replies.

Reviewer names and images are public profile data as displayed by Google Play.

### Limits and reliability

Google Play content can change over time.

If a package ID is invalid or no public reviews are available, the actor skips that app and continues with the rest of the input.

Very large jobs may take longer and should be split by app, country, or language for easier monitoring.

### Troubleshooting

#### Why did I get fewer reviews than requested?

Google Play may not expose the requested number for the selected app, country, language, sort order, or date range.

Try a different country, language, or sorting mode.

#### Why are developer reply fields empty?

The app developer may not have replied to that review, or the reply may not be visible for the selected locale.

#### Why are review dates not exactly in my local timezone?

Dates are exported as ISO timestamps so they can be processed consistently across systems.

### Legality and responsible use

This actor collects publicly available Google Play review data.

Use the data responsibly and follow applicable laws, platform terms, privacy requirements, and your organization’s compliance rules.

Do not use review data to harass reviewers or attempt to identify private individuals.

### Related scrapers

Explore related actors from Anna on Apify:

- https://apify.com/fetch\_cat/apple-app-store-reviews-scraper
- https://apify.com/fetch\_cat/tiktok-comments-scraper
- https://apify.com/fetch\_cat/reddit-scraper
- https://apify.com/fetch\_cat/google-maps-reviews-scraper

### FAQ

#### Can I scrape multiple apps in one run?

Yes. Add multiple package IDs or app URLs to the `apps` array.

#### Can I scrape reviews by country?

Yes. Set the `country` field to the two-letter market you want.

#### Can I scrape non-English reviews?

Yes. Set `language` to the desired language code.

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

Yes. Apify datasets support CSV, Excel, JSON, XML, RSS, and HTML exports.

#### Can I schedule daily monitoring?

Yes. Use Apify schedules and set `sort` to `newest`.

#### Does this actor require my Google account?

No. It is designed for public Google Play review data.

#### What should I use as the app identifier?

Use the Android package ID from the Google Play URL, such as `com.instagram.android`.

#### Is each row one review?

Yes. Each saved dataset item is one public Google Play review.

# Actor input Schema

## `apps` (type: `array`):

One or more Google Play package IDs (for example, com.instagram.android) or full Google Play app URLs.

## `maxReviews` (type: `integer`):

Total maximum number of reviews to save across all apps.

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

Two-letter Google Play country code used for localized reviews, for example US, GB, DE, or IN.

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

Two-letter language code used for Google Play review text and app metadata, for example en, es, de, or fr.

## `sort` (type: `string`):

Sort order to request from Google Play.

## `startDate` (type: `string`):

Only save reviews on or after this date. Leave empty to disable the lower bound.

## `endDate` (type: `string`):

Only save reviews on or before this date. Leave empty to disable the upper bound.

## Actor input object example

```json
{
  "apps": [
    "com.instagram.android"
  ],
  "maxReviews": 20,
  "country": "US",
  "language": "en",
  "sort": "newest"
}
```

# Actor output Schema

## `overview` (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 = {
    "apps": [
        "com.instagram.android"
    ],
    "country": "US",
    "language": "en",
    "sort": "newest"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/google-play-reviews-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "apps": ["com.instagram.android"],
    "country": "US",
    "language": "en",
    "sort": "newest",
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/google-play-reviews-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "apps": [
    "com.instagram.android"
  ],
  "country": "US",
  "language": "en",
  "sort": "newest"
}' |
apify call fetch_cat/google-play-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Play Reviews Scraper",
        "description": "Scrape public Google Play reviews with ratings, review text, dates, helpful votes, app versions, and developer replies for ASO monitoring.",
        "version": "0.1",
        "x-build-id": "RFO65QglrGpWQrgor"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~google-play-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-google-play-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/fetch_cat~google-play-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-google-play-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/fetch_cat~google-play-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-google-play-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "apps"
                ],
                "properties": {
                    "apps": {
                        "title": "App IDs or Google Play URLs",
                        "type": "array",
                        "description": "One or more Google Play package IDs (for example, com.instagram.android) or full Google Play app URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Maximum reviews",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Total maximum number of reviews to save across all apps.",
                        "default": 20
                    },
                    "country": {
                        "title": "Country",
                        "minLength": 2,
                        "maxLength": 2,
                        "type": "string",
                        "description": "Two-letter Google Play country code used for localized reviews, for example US, GB, DE, or IN.",
                        "default": "US"
                    },
                    "language": {
                        "title": "Language",
                        "minLength": 2,
                        "maxLength": 5,
                        "type": "string",
                        "description": "Two-letter language code used for Google Play review text and app metadata, for example en, es, de, or fr.",
                        "default": "en"
                    },
                    "sort": {
                        "title": "Review sort order",
                        "enum": [
                            "newest",
                            "rating",
                            "helpfulness"
                        ],
                        "type": "string",
                        "description": "Sort order to request from Google Play.",
                        "default": "newest"
                    },
                    "startDate": {
                        "title": "Start date",
                        "type": "string",
                        "description": "Only save reviews on or after this date. Leave empty to disable the lower bound."
                    },
                    "endDate": {
                        "title": "End date",
                        "type": "string",
                        "description": "Only save reviews on or before this date. Leave empty to disable the upper bound."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
