# Google Play Store Scraper (`maximedupre/google-play-store-scraper`) Actor

Scrape Google Play Store apps and reviews from keywords, package IDs, app URLs, category pages, or developer pages. Export app metadata, ratings, prices, developers, review text, replies, source URLs, ranks, and locale fields.

- **URL**: https://apify.com/maximedupre/google-play-store-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.05 / 1,000 scraped apps

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 Store scraper for apps and reviews

Google Play Store Scraper extracts public app data from [Google Play](https://play.google.com/store/apps). Search by keyword, scrape app details by package ID or URL, collect public reviews, or pull apps from category and developer pages.

Use it for app market research, ASO research, competitor tracking, review analysis, developer portfolio checks, and repeatable Google Play data exports. The Actor returns clean dataset rows with app IDs, source URLs, source rank, localized metadata, ratings, prices, developer details, review text, reviewer info, replies, app versions, and scrape timestamps.

You do not need a Google account, Play Console access, cookies, or a Google API key. Start with the prefilled `fitness tracker` search to preview the app result shape before adding more keywords, package IDs, or Google Play URLs.

### ✅ What this Actor does

- Searches Google Play apps from keyword targets.
- Scrapes app details from package IDs or Google Play app URLs.
- Scrapes public Google Play reviews for one or more apps.
- Extracts apps from Google Play category pages.
- Extracts apps from Google Play developer pages.
- Supports country and language settings for localized Google Play pages.
- Saves one dataset item per app or review.
- Adds source target, target type, source URL, source rank, country, language, and scrape time.
- Runs without user-provided Google credentials.

The Actor is focused on public Google Play Store data. It does not scrape private Play Console data, closed-testing tracks, APK files, install files, Google Play billing data, or historical review archives beyond what Google Play exposes publicly.

### 📦 Data you can extract

#### App rows

App rows can include:

- `rowType` - `app`
- `target` and `targetType`
- `sourceUrl` and `sourceRank`
- `appId`
- `title`, `summary`, and `description`
- `developer` and `developerUrl`
- `score`, `ratings`, and `reviews`
- `genre`
- `price`, `currency`, and `free`
- `icon` and `screenshots`
- `country`, `language`, and `scrapedAt`

When **Fetch full app details** is turned off for search, category, or developer runs, the Actor emits lightweight discovery rows with app IDs, source rank, source URL, locale, and scrape metadata. Turn full details on when you need app titles, ratings, descriptions, developer data, prices, and media.

#### Review rows

Review rows can include:

- `rowType` - `review`
- `target`, `targetType`, `sourceUrl`, and `sourceRank`
- `appId` and `reviewId`
- `reviewerName` and `reviewerImage`
- `score` and `scoreText`
- `text`
- `date`
- `replyText` and `replyDate`
- `thumbsUp`
- `version`
- `country`, `language`, and `scrapedAt`

Some fields can be empty when Google Play does not show them for a specific app, market, review, or language.

### 🚀 Common use cases

- Find Android apps for a keyword such as `fitness tracker`, `budget planner`, or `photo editor`.
- Build market research datasets for app categories and niches.
- Track competitor app ratings, prices, metadata, screenshots, and developer profiles.
- Collect public reviews for product feedback, support triage, sentiment analysis, or feature request research.
- Export developer portfolios from public Google Play developer pages.
- Schedule repeat Google Play checks and send results to spreadsheets, APIs, webhooks, or integrations.

### ▶️ How to run it

1. Choose a **Scrape mode**.
2. Add one or more targets.
3. Set **Country** and **Language** for the Google Play market you want.
4. Keep the limits low for a preview run, then raise them when the row shape looks right.
5. Start the Actor and open the dataset.

For a quick first run, use:

```json
{
	"mode": "search",
	"targets": ["fitness tracker"],
	"maxAppsPerTarget": 25,
	"country": "US",
	"language": "en",
	"includeDetails": false
}
````

### ⚙️ Input options

| Field | What it does |
| --- | --- |
| `mode` | Chooses how targets are interpreted: `search`, `details`, `reviews`, `category`, or `developer`. |
| `targets` | Search terms, Android package IDs, Google Play app URLs, category URLs, or developer URLs. |
| `maxAppsPerTarget` | Maximum app rows saved for each search, category, developer, or details target. |
| `maxReviewsPerApp` | Maximum review rows saved for each app in reviews mode. |
| `reviewSort` | Review order for reviews mode: newest, rating, or helpfulness. |
| `country` | Google Play country code, such as `US`, `GB`, `DE`, or `JP`. |
| `language` | Google Play language code, such as `en`, `de`, `fr`, or `ja`. |
| `includeDetails` | Opens each discovered app page to add detailed app metadata. Discovery-only runs are faster. |

Good target examples:

- Search mode: `fitness tracker`
- Details mode: `com.whatsapp`
- Details mode: `https://play.google.com/store/apps/details?id=com.spotify.music`
- Reviews mode: `com.spotify.music`
- Category mode: `https://play.google.com/store/apps/category/HEALTH_AND_FITNESS`
- Developer mode: a public Google Play developer page URL

### 🧾 Output examples

#### App row

```json
{
	"rowType": "app",
	"target": "fitness tracker",
	"targetType": "search",
	"sourceUrl": "https://play.google.com/store/search?q=fitness+tracker&c=apps&hl=en&gl=US",
	"sourceRank": 1,
	"appId": "com.google.android.apps.fitness",
	"title": "Google Fit: Activity Tracking",
	"summary": "Coaching you to a healthier and more active life",
	"developer": "Google LLC",
	"score": 3.8,
	"ratings": 640000,
	"genre": "HEALTH_AND_FITNESS",
	"free": true,
	"country": "US",
	"language": "en",
	"scrapedAt": "2026-05-27T17:43:26.137Z"
}
```

#### Review row

```json
{
	"rowType": "review",
	"target": "com.spotify.music",
	"targetType": "reviews",
	"sourceUrl": "https://play.google.com/store/apps/details?id=com.spotify.music&hl=en&gl=US",
	"sourceRank": 1,
	"appId": "com.spotify.music",
	"reviewId": "0438ffff-2666-4508-b69e-d9402e64699d",
	"reviewerName": "Prashant Mahour",
	"score": 1,
	"scoreText": "1",
	"text": "very high price nad not for poor peoples you are robbers",
	"date": "2026-05-26T17:45:16.920Z",
	"thumbsUp": 0,
	"version": "9.1.50.1906",
	"country": "US",
	"language": "en",
	"scrapedAt": "2026-05-27T17:46:33.585Z"
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for saved Google Play app results and saved Google Play review results. There is no separate Actor-start charge in the pricing file.

Keep first runs small by using one target and low limits. Discovery-only search runs are usually cheaper and faster than search runs with full app details because full details open each discovered app page.

### ⚠️ Limits and caveats

- Google Play can show different data by country and language.
- Review availability depends on what Google Play exposes publicly for the selected app, market, and language.
- Search, category, and developer discovery can run faster with **Fetch full app details** turned off.
- Full app details add richer fields but require one extra app page request per discovered app.
- The Actor skips invalid or unavailable targets and saves valid rows from the rest of the run.
- Public Google Play pages can change; if a target suddenly returns fewer fields, open an issue with the target and run settings.

### ❓ FAQ

#### Do I need a Google account or API key?

No. The Actor scrapes public Google Play pages and public review data without user-provided Google credentials.

#### Can it scrape Google Play reviews?

Yes. Use `reviews` mode with package IDs or Google Play app URLs. The Actor returns one dataset item per public review.

#### Can it search Google Play by keyword?

Yes. Use `search` mode and add search terms such as `fitness tracker`, `photo editor`, or `budget planner`.

#### Why are some app fields empty?

Google Play does not expose every field on every surface. Discovery rows can also be intentionally lightweight when **Fetch full app details** is turned off.

#### Can I scrape iOS App Store data too?

Use [App Store Ratings Scraper ↗](https://apify.com/maximedupre/app-store-ratings-scraper) for rating and metadata checks across Google Play and the Apple App Store.

### 📝 Changelog

- 0.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~google-play-store-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [App Store Ratings Scraper ↗](https://apify.com/maximedupre/app-store-ratings-scraper) - Check ratings and metadata for Google Play and Apple App Store apps.
- [Google Shopping Ads Scraper ↗](https://apify.com/maximedupre/google-shopping-ads-scraper) - Extract live paid Shopping ad products from Google Search.
- [TikTok Keywords Discovery Tool ↗](https://apify.com/maximedupre/tiktok-keywords-discovery-tool) - Collect TikTok autocomplete keyword ideas for content and SEO research.
- [Pinterest Keyword Scraper ↗](https://apify.com/maximedupre/pinterest-keyword-scraper) - Export Pinterest autocomplete suggestions from keyword seeds.
- [Website URL Crawler ↗](https://apify.com/maximedupre/website-url-crawler) - Build rendered link maps from public websites.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

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

Choose the Google Play surface to scrape: app search, app details, app reviews, category pages, or developer pages.

## `targets` (type: `array`):

Add one target per line. Use keywords for search mode, package IDs or app URLs for details and reviews, and Google Play category or developer URLs for those modes.

## `maxAppsPerTarget` (type: `integer`):

Maximum app items to save for each search, category, developer, or details target.

## `maxReviewsPerApp` (type: `integer`):

Maximum public review items to save for each app in reviews mode.

## `reviewSort` (type: `string`):

How Google Play should order reviews in reviews mode.

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

Google Play country code. App listings, prices, availability, and reviews can vary by market.

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

Google Play language code for localized app pages and reviews.

## `includeDetails` (type: `boolean`):

Open each discovered app page to include title, description, ratings, developer, price, icon, and screenshot URLs. Turn off for faster discovery-only runs.

## Actor input object example

```json
{
  "mode": "search",
  "targets": [
    "fitness tracker"
  ],
  "maxAppsPerTarget": 25,
  "maxReviewsPerApp": 100,
  "reviewSort": "newest",
  "country": "US",
  "language": "en",
  "includeDetails": true
}
```

# Actor output Schema

## `results` (type: `string`):

Open the dataset with Google Play app search, category, developer, detail, or review items.

# 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 = {
    "mode": "search",
    "targets": [
        "fitness tracker"
    ],
    "maxAppsPerTarget": 25,
    "maxReviewsPerApp": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/google-play-store-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 = {
    "mode": "search",
    "targets": ["fitness tracker"],
    "maxAppsPerTarget": 25,
    "maxReviewsPerApp": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/google-play-store-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 '{
  "mode": "search",
  "targets": [
    "fitness tracker"
  ],
  "maxAppsPerTarget": 25,
  "maxReviewsPerApp": 100
}' |
apify call maximedupre/google-play-store-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Play Store Scraper",
        "description": "Scrape Google Play Store apps and reviews from keywords, package IDs, app URLs, category pages, or developer pages. Export app metadata, ratings, prices, developers, review text, replies, source URLs, ranks, and locale fields.",
        "version": "0.0",
        "x-build-id": "VM4Hj6wc0CvVaK7eT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~google-play-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-google-play-store-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/maximedupre~google-play-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-google-play-store-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/maximedupre~google-play-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-google-play-store-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": [
                    "mode",
                    "targets",
                    "maxAppsPerTarget",
                    "maxReviewsPerApp",
                    "reviewSort",
                    "country",
                    "language",
                    "includeDetails"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "details",
                            "reviews",
                            "category",
                            "developer"
                        ],
                        "type": "string",
                        "description": "Choose the Google Play surface to scrape: app search, app details, app reviews, category pages, or developer pages.",
                        "default": "search"
                    },
                    "targets": {
                        "title": "Google Play targets",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Add one target per line. Use keywords for search mode, package IDs or app URLs for details and reviews, and Google Play category or developer URLs for those modes.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "maxAppsPerTarget": {
                        "title": "Apps per target",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum app items to save for each search, category, developer, or details target.",
                        "default": 25
                    },
                    "maxReviewsPerApp": {
                        "title": "Reviews per app",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum public review items to save for each app in reviews mode.",
                        "default": 100
                    },
                    "reviewSort": {
                        "title": "Review order",
                        "enum": [
                            "newest",
                            "rating",
                            "helpfulness"
                        ],
                        "type": "string",
                        "description": "How Google Play should order reviews in reviews mode.",
                        "default": "newest"
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "CA",
                            "GB",
                            "AU",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "NL",
                            "BR",
                            "MX",
                            "JP",
                            "IN",
                            "PT"
                        ],
                        "type": "string",
                        "description": "Google Play country code. App listings, prices, availability, and reviews can vary by market.",
                        "default": "US"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "nl",
                            "pt",
                            "ja"
                        ],
                        "type": "string",
                        "description": "Google Play language code for localized app pages and reviews.",
                        "default": "en"
                    },
                    "includeDetails": {
                        "title": "Full app details",
                        "type": "boolean",
                        "description": "Open each discovered app page to include title, description, ratings, developer, price, icon, and screenshot URLs. Turn off for faster discovery-only runs.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```