# Google Play Scraper (`scrapesmith/google-play-scraper`) Actor

All-in-one Google Play scraper. Search apps, get full details (27 fields with developer email/website), and extract reviews with filters. No browser, no proxy, 256MB.

- **URL**: https://apify.com/scrapesmith/google-play-scraper.md
- **Developed by:** [Scrape Smith](https://apify.com/scrapesmith) (community)
- **Categories:** Developer tools, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.25 / 1,000 results

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

## Google Play Scraper — Search, App Details & Reviews (All-in-One)

The only Google Play Store scraper you need. Search for Android apps, pull complete app details, and extract reviews — all in a single actor with three simple modes. No juggling multiple tools, no separate scrapers for each job.

---

### Why Use This All-in-One Google Play Scraper?

- **3 modes in 1 actor** — search apps, fetch full app details, or scrape reviews, all from the same tool
- **27 fields per app** in details mode — developer email, website, install counts, privacy policy links, and more
- **Install counts included** — see exactly how many installs each app has, both as a display string and a precise minimum
- **Developer contact info included** — email and website fields most Google Play scrapers don't bother capturing
- **Rating filter and 3 sort modes** in Reviews mode — isolate exactly the reviews you need
- **No browser, no proxy, no API key required** — fully anonymous, zero setup, zero maintenance
- **Fast across every mode** — search, details, and reviews all return in seconds, not minutes

Whether you're doing Android App Store Optimization, competitive research, or building an app intelligence dashboard, this scraper replaces three separate tools with one.

---

### The Three Modes

#### Search Mode
Enter one or more keywords and get back a ranked list of matching Android apps — exactly as they appear in Google Play's own search results. Perfect for keyword research, competitor discovery, and ASO ranking checks.

#### Details Mode
Provide a Google Play package ID or URL and get back the complete app profile: developer contact info, install counts, pricing, category, content rating, description, version history, and more — 27 fields in total.

#### Reviews Mode
Provide a Google Play package ID or URL and get back individual user reviews with ratings, review text, thumbs-up counts, app version, and developer replies — the same review engine used by our dedicated Google Play Reviews Scraper.

---

### Input Parameters

```json
{
  "mode": "search",
  "searchTerms": ["messaging apps"],
  "country": "us",
  "language": "en",
  "maxResults": 50
}
````

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `mode` | string | Yes | `search` | Which mode to run: `search`, `details`, or `reviews`. |
| `searchTerms` | array | Search mode only | — | Keywords to search for on Google Play. |
| `appIds` | array | Details / Reviews mode only | — | Google Play package IDs or URLs. |
| `country` | string | No | `us` | Two-letter country code for localized results. |
| `language` | string | No | `en` | Two-letter language code for result content. |
| `maxResults` | integer | Search mode only | 50 | Maximum apps to return per search term. |
| `maxReviews` | integer | Reviews mode only | 500 | Maximum reviews to return per app. |
| `sortBy` | string | Reviews mode only | `newest` | Review sort order: `newest`, `relevant`, or `rating`. |
| `ratingFilter` | array | Reviews mode only | all ratings | Only include reviews with these star ratings, e.g. `[1, 2]`. |
| `sinceDate` | string | Reviews mode only | — | Only include reviews on or after this date. Format: `YYYY-MM-DD`. |

***

### What Data Do You Get?

#### Search Mode (12 fields)

| Field | Description |
|---|---|
| **type** | Result type marker |
| **appId** | Google Play package ID |
| **title** | App name |
| **developer** | Publisher / developer name |
| **rating** | Current overall average rating |
| **installs** | Display-formatted install count (e.g. "1,000,000,000+") |
| **price** | App price |
| **iconUrl** | App icon URL |
| **url** | Direct Google Play link |
| **query** | The search term that returned this result |
| **country** | Storefront the result was pulled from |
| **scrapedAt** | Timestamp of when the data was collected |

#### Details Mode (27 fields)

| Field | Description |
|---|---|
| **type** | Result type marker |
| **appId** | Google Play package ID |
| **title** | App name |
| **developer** | Publisher / developer name |
| **developerEmail** | Developer's public contact email |
| **developerWebsite** | Developer's website URL |
| **rating** | Current overall average rating |
| **ratingCount** | Total number of ratings |
| **installs** | Display-formatted install count |
| **minInstalls** | Precise minimum install count |
| **price** | Numeric app price |
| **free** | Whether the app is free |
| **currency** | Currency code for the price |
| **category** | Primary Google Play category |
| **contentRating** | Age content rating |
| **description** | Full app description |
| **version** | Current app version |
| **androidVersion** | Minimum required Android version |
| **updated** | Date the app was last updated |
| **released** | Original app release date |
| **privacyPolicyUrl** | Link to the developer's privacy policy |
| **url** | Direct Google Play link |
| **iconUrl** | App icon URL |
| **screenshotUrls** | URLs to app screenshots |
| **country** | Storefront the data was pulled from |
| **language** | Language used for the result content |
| **scrapedAt** | Timestamp of when the data was collected |

#### Reviews Mode (17 fields)

| Field | Description |
|---|---|
| **reviewId** | Unique identifier for the review |
| **title** | Review headline, if the reviewer set one |
| **author** | Reviewer's display name |
| **authorImage** | URL to the reviewer's profile photo |
| **rating** | Star rating from 1 to 5 |
| **text** | Full review body text |
| **url** | Direct link to the review on Google Play |
| **date** | Review submission date (ISO 8601) |
| **thumbsUp** | Number of users who found the review helpful |
| **appVersion** | App version the review was written against |
| **developerReply** | The developer's reply text, if one was posted |
| **developerReplyDate** | Date the developer replied |
| **appId** | Google Play package ID |
| **country** | Storefront the review was pulled from |
| **language** | Language code used for review content |
| **scrapedAt** | Timestamp of when the data was collected |
| **status** | Result status for the review row |

***

### How Fast Is It?

| Mode | Volume | Time |
|---|---|---|
| Search | 59 apps | ~2 seconds |
| Details | 3 apps | ~2 seconds |
| Reviews | 50 reviews | ~3 seconds |
| Reviews | 500 reviews | ~30 seconds |
| Reviews | 5,000 reviews | ~1 minute |

There's no browser to spin up and no proxy hops to wait on in any mode, so search, details, and reviews all return in seconds regardless of how many apps or countries you request.

***

### Use Cases

#### App Store Optimization (ASO) & Keyword Research

- **Check keyword rankings** by running Search mode with your target keywords and seeing exactly where your Android app lands
- **Discover competitor apps** ranking for the same keywords you're targeting
- **Track ranking changes over time** by running the same search terms on a schedule
- **Compare install counts across competitors** using the `installs` and `minInstalls` fields

#### Competitive Intelligence & Market Research

- **Build a full competitor profile** by combining Details mode (installs, pricing, category, description) with Reviews mode (user sentiment) for the same app
- **Track update frequency** using the `updated` field across scheduled runs
- **Compare monetization strategies** across a category using `free`, `price`, and `currency`
- **Monitor localized presence** by pulling details and rankings across different countries and languages

#### Developer & Business Contact Research

- **Build outreach lists** using `developerEmail` and `developerWebsite` for partnership, sales, or acquisition research
- **Verify developer legitimacy** by checking for a populated `privacyPolicyUrl` and consistent developer contact info
- **Map developer portfolios** by searching for apps from the same publisher across categories

#### Customer Support Quality Auditing

- **Audit developer reply coverage** by checking which reviews have a populated `developerReply` field
- **Measure response time** using the gap between `date` and `developerReplyDate`
- **Identify unanswered complaints** by filtering for negative reviews (`ratingFilter: [1, 2]`) with no developer reply

#### AI, NLP & Machine Learning

- **Train ranking prediction models** using search position combined with install counts and ratings
- **Build sentiment datasets** by pairing Reviews mode output with Details mode context (category, price, installs)
- **Power app recommendation engines** using category, rating, and description data at scale
- **Train customer support response models** using real `developerReply` examples as ground truth

***

### Frequently Asked Questions

**Can I search, get details, and scrape reviews all in one run?**
Each run uses one `mode` at a time, but since all three modes live in the same actor, you can trigger them back-to-back with different `mode` values without switching tools or learning a new interface.

**Does Google Play Details mode include the developer's contact information?**
Yes. `developerEmail` and `developerWebsite` are included in Details mode output, which many competing Google Play scrapers leave out entirely.

**How are install counts reported?**
Two ways: `installs` gives you the display-formatted string Google Play shows publicly (like "1,000,000,000+"), and `minInstalls` gives you the precise minimum numeric value for easier sorting and comparison.

**Can I filter reviews by star rating in this all-in-one scraper?**
Yes. Use `ratingFilter` in Reviews mode with an array like `[1, 2]` to only receive negative reviews, or `[5]` to pull only 5-star reviews.

**Does this scraper capture developer replies to reviews?**
Yes. Reviews mode includes a `developerReply` field with the developer's response text, if one exists, plus a `developerReplyDate`.

**Can I get Google Play rankings and details for other countries?**
Yes. Set the `country` and `language` parameters to pull localized search results, details, and reviews for any supported region.

**Is a proxy required to use this scraper?**
No. All three modes run without any proxy configuration and without a browser, keeping every run fast and lightweight.

**How does Reviews mode compare to a dedicated Google Play reviews-only scraper?**
It returns the same 17 review fields and uses the same underlying review engine, so you get identical review data whether you use this all-in-one actor or a reviews-only scraper — the difference is just convenience of having search and details in the same tool.

**Does the details output include a privacy policy link?**
Yes. `privacyPolicyUrl` is included in Details mode, useful for compliance research or verifying an app meets basic transparency requirements.

**Do I need a Google Play Console account to use this?**
No. Every mode works from publicly available Google Play data. You don't need developer credentials, app ownership, or any Google authentication.

**Can I track how an app's ranking changes over time?**
Yes. Schedule Search mode to run daily or weekly with the same keywords and compare each app's position across runs.

**What's the difference between `installs` and `minInstalls`?**
`installs` is the rounded, display-friendly string shown on the Play Store page. `minInstalls` is the precise minimum numeric threshold behind that string, better suited for sorting, filtering, or numeric analysis.

**Can I filter reviews by date in this scraper?**
Yes. Use `sinceDate` in Reviews mode to only pull reviews submitted on or after a specific date.

**Can I export results to Excel or Google Sheets?**
Yes. Apify datasets support exporting to JSON, CSV, Excel, XML, and other formats, plus direct integrations to Google Sheets and other tools.

**Can I run this on a schedule to monitor changes?**
Yes. Apify's built-in scheduler lets you run any mode daily, weekly, or on any custom interval to continuously track rankings, app updates, install growth, or new reviews.

***

### Output Formats

Results are available directly from your dataset in every format Apify supports:

- **JSON** — structured data for programmatic use and API integration
- **CSV** — flat table format, opens directly in Excel and Google Sheets
- **Excel (.xlsx)** — native spreadsheet format with proper headers
- **XML** — structured markup for enterprise integrations

***

### Integration & Automation

Connect this Google Play scraper to your existing workflow:

- **Google Sheets** — append new search results, app details, or reviews automatically
- **Slack / Discord** — get notified when a scheduled run finds ranking changes or new reviews
- **Webhooks** — trigger your own systems when a run completes
- **Zapier / Make** — connect to thousands of apps without writing code
- **BigQuery / Snowflake / data warehouses** — load app intelligence data for long-term analysis

Set up a recurring schedule with Apify's built-in scheduler to track Google Play rankings, monitor app updates, or watch for new reviews without lifting a finger.

# Actor input Schema

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

What to scrape: search for apps, fetch app details, or scrape reviews.

## `searchTerms` (type: `array`):

Keywords to search for on Google Play. Used in Search mode.

## `appIds` (type: `array`):

Google Play Store app package IDs or URLs. Used in App details and Reviews modes.

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

Two-letter country code for localized results.

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

Two-letter language code for result content.

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

Maximum apps to return per search term. Used in Search mode.

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

Maximum reviews to scrape per app. Used in Reviews mode.

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

How to sort reviews. Used in Reviews mode.

## `ratingFilter` (type: `array`):

Only include reviews with these star ratings (e.g. \[1, 2] for negative reviews). Leave empty for all. Used in Reviews mode.

## `sinceDate` (type: `string`):

Only include reviews on or after this date. Format: YYYY-MM-DD. Used in Reviews mode.

## Actor input object example

```json
{
  "mode": "search",
  "searchTerms": [
    "messaging apps"
  ],
  "appIds": [
    "com.whatsapp"
  ],
  "country": "us",
  "language": "en",
  "maxResults": 50,
  "maxReviews": 500,
  "sortBy": "newest"
}
```

# 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 = {
    "searchTerms": [
        "messaging apps"
    ],
    "appIds": [
        "com.whatsapp"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesmith/google-play-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 = {
    "searchTerms": ["messaging apps"],
    "appIds": ["com.whatsapp"],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesmith/google-play-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 '{
  "searchTerms": [
    "messaging apps"
  ],
  "appIds": [
    "com.whatsapp"
  ]
}' |
apify call scrapesmith/google-play-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Play Scraper",
        "description": "All-in-one Google Play scraper. Search apps, get full details (27 fields with developer email/website), and extract reviews with filters. No browser, no proxy, 256MB.",
        "version": "0.0",
        "x-build-id": "Dl45RJHvAzPo0RHy1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesmith~google-play-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesmith-google-play-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/scrapesmith~google-play-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesmith-google-play-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/scrapesmith~google-play-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesmith-google-play-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"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "details",
                            "reviews"
                        ],
                        "type": "string",
                        "description": "What to scrape: search for apps, fetch app details, or scrape reviews.",
                        "default": "search"
                    },
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Keywords to search for on Google Play. Used in Search mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "appIds": {
                        "title": "App IDs or URLs",
                        "type": "array",
                        "description": "Google Play Store app package IDs or URLs. Used in App details and Reviews modes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Two-letter country code for localized results.",
                        "default": "us"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Two-letter language code for result content.",
                        "default": "en"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum apps to return per search term. Used in Search mode.",
                        "default": 50
                    },
                    "maxReviews": {
                        "title": "Max reviews per app",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum reviews to scrape per app. Used in Reviews mode.",
                        "default": 500
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "newest",
                            "relevant",
                            "rating"
                        ],
                        "type": "string",
                        "description": "How to sort reviews. Used in Reviews mode.",
                        "default": "newest"
                    },
                    "ratingFilter": {
                        "title": "Filter by rating",
                        "type": "array",
                        "description": "Only include reviews with these star ratings (e.g. [1, 2] for negative reviews). Leave empty for all. Used in Reviews mode.",
                        "items": {
                            "type": "integer"
                        }
                    },
                    "sinceDate": {
                        "title": "Reviews since date",
                        "type": "string",
                        "description": "Only include reviews on or after this date. Format: YYYY-MM-DD. Used in Reviews mode."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
