# Google Play Data Safety Scraper (`automation-lab/google-play-data-safety-scraper`) Actor

🔐 Extract normalized Google Play Data Safety disclosures and monitor collection, sharing, security, deletion, privacy-policy, and disclosure changes across Android app portfolios.

- **URL**: https://apify.com/automation-lab/google-play-data-safety-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Data Safety Scraper

Extract structured Google Play Data Safety disclosures for Android apps. Monitor what apps say they collect and share, why they use it, and which security practices they declare—without manually opening every app page.

Provide package IDs, Google Play URLs, or an Apify dataset. The Actor returns one normalized record per app with nested disclosure entries, stable hashes, and optional change detection.

### What does Google Play Data Safety Scraper do?

The Actor reads public `/store/apps/datasafety` pages and converts the disclosures into export-ready JSON.

It extracts:

- app identity and source URLs;
- data shared with other companies or organizations;
- data collected by the app;
- category, data type, purpose, and optional status;
- encryption-in-transit declarations;
- deletion-request availability;
- independent security review declarations;
- privacy-policy links;
- stable disclosure hashes;
- added and removed declarations compared with prior output.

### Who is it for?

#### Privacy and compliance teams

Audit a mobile vendor portfolio and retain timestamped evidence of developer-declared practices.

#### Vendor-risk analysts

Screen Android apps for sensitive collection, sharing, deletion, and encryption signals.

#### App intelligence providers

Enrich app catalogs with normalized privacy fields rather than unstructured page text.

#### Agencies and researchers

Compare competitors, market segments, or cohorts of apps at scale.

### Why use this Actor?

Google Play disclosures are readable by people but awkward to analyze in bulk. This Actor turns expandable page sections into consistent records.

- **Repeatable:** schedule the same portfolio daily, weekly, or monthly.
- **Auditable:** preserve source URLs, raw labels, timestamps, and hashes.
- **Monitoring-ready:** compare against a previous dataset.
- **Exportable:** use JSON, CSV, Excel, API, webhooks, or integrations.
- **Efficient:** HTTP-first extraction avoids browser overhead.

### Input options

Use one or combine several input methods.

| Field | Type | Purpose |
|---|---|---|
| `appIds` | string[] | Android package IDs |
| `startUrls` | URL[] | Google Play details or Data Safety URLs |
| `datasetId` | string | Dataset containing package IDs |
| `datasetAppIdField` | string | Package-ID column, default `appId` |
| `priorDatasetId` | string | Earlier Actor output for comparison |
| `locale` | string | Google Play language, default `en` |
| `country` | string | Two-letter country, default `US` |
| `useProxy` | boolean | Rotate Apify Proxy IP addresses |

At least one valid app ID, URL, or dataset is required.

### Quick start

1. Open the Actor input page.
2. Enter one or more package IDs.
3. Keep language `en` for normalized extraction.
4. Click **Start**.
5. Open the dataset to inspect or export results.

Example:

```json
{
  "appIds": [
    "com.spotify.music",
    "com.whatsapp"
  ],
  "locale": "en",
  "country": "US",
  "useProxy": false
}
````

### Scrape Google Play URLs

Details-page and Data Safety URLs are both accepted. The Actor extracts the `id` query parameter and constructs a canonical Data Safety URL.

```json
{
  "startUrls": [
    { "url": "https://play.google.com/store/apps/details?id=com.google.android.youtube" },
    { "url": "https://play.google.com/store/apps/datasafety?id=com.android.chrome" }
  ]
}
```

### Process an app portfolio dataset

Set `datasetId` to an Apify dataset ID and identify the package-ID column.

```json
{
  "datasetId": "YOUR_DATASET_ID",
  "datasetAppIdField": "appId",
  "locale": "en",
  "country": "US"
}
```

The Actor reads up to 10,000 source rows in one run and deduplicates package IDs.

### Output data

Each successful app produces one dataset item.

| Field | Description |
|---|---|
| `appId` | Android package ID |
| `appUrl` | Canonical details URL |
| `dataSafetyUrl` | Fetched disclosure URL |
| `title` | App title when exposed |
| `developer` | Developer when exposed |
| `dataShared` | Normalized shared-data entries |
| `dataCollected` | Normalized collected-data entries |
| `encryptedInTransit` | Declared encryption status |
| `deletionRequestAvailable` | Declared deletion-request status |
| `independentSecurityReview` | Independent-review declaration |
| `privacyPolicyUrl` | Developer privacy-policy URL |
| `securityPracticesText` | Normalized source text used to detect security-practice wording changes |
| `rawLabels` | Unique source labels retained for audits |
| `disclosureHash` | Stable SHA-256 disclosure fingerprint |
| `changes` | Comparison with prior output |
| `fetchedAt` | UTC extraction timestamp |

### Output example

```json
{
  "appId": "com.spotify.music",
  "title": "Spotify: Music and Podcasts",
  "locale": "en",
  "country": "US",
  "dataShared": [
    {
      "category": "Location",
      "dataType": "Approximate location",
      "purposes": ["Analytics", "Advertising or marketing"],
      "optional": false,
      "rawLabel": "Approximate location"
    }
  ],
  "encryptedInTransit": true,
  "deletionRequestAvailable": true,
  "disclosureHash": "…",
  "fetchedAt": "2026-07-12T00:00:00.000Z"
}
```

### Monitor disclosure changes

Run the Actor once and save its dataset ID. On a later run, pass that ID as `priorDatasetId`.

The `changes` object reports:

- `changed`: whether the stable hash differs;
- `added`: normalized declarations newly present;
- `removed`: declarations no longer present;
- `previousHash`: the earlier fingerprint.

This supports scheduled compliance alerts and evidence trails.

### How much does it cost to scrape Google Play Data Safety disclosures?

The Actor uses pay-per-event pricing: a small run-start charge plus a charge for each saved app disclosure. Subscription tiers receive volume discounts.

Exact current prices appear in the Actor pricing tab before every run. Failed app IDs do not produce dataset items and are not charged as results.

HTTP extraction keeps compute requirements low. Test a representative portfolio to estimate your total before scheduling large recurring jobs.

### Accuracy and raw labels

The Data Safety section is supplied by each app developer. The Actor reports those declarations; it does not independently verify actual application behavior.

Normalized fields make comparison easier, while `rawLabel` and `rawLabels` preserve source wording for traceability.

### Language and country

Parsing is optimized for English (`locale: "en"`). Country selection can affect which store version Google serves.

Non-English pages may still be fetched, but headings and purpose labels may not normalize completely. For consistent cross-app comparisons, use one locale and country across runs.

### Reliability tips

- Begin without a proxy for small portfolios.
- Enable `useProxy` if direct requests become rate-limited.
- Keep package IDs in canonical dotted form.
- Use English for normalized field extraction.
- Schedule moderate batches rather than many overlapping runs.
- Review logs for invalid or unavailable apps.

### Invalid and unavailable apps

Malformed URLs and package IDs that do not resolve to a Data Safety page are logged and skipped. Other valid apps continue processing.

No placeholder dataset row is emitted for a failed app, which keeps exports clean and billing tied to usable output.

### Integrations

#### Google Sheets and Excel

Export the default dataset directly for analyst review, filtering, and evidence retention.

#### Webhooks and Slack

Trigger a webhook after scheduled runs. Compare `changes.changed` and notify a compliance channel only when disclosures differ.

#### Make and Zapier

Start a run from a vendor onboarding workflow, then route results to risk-management or ticketing systems.

#### Cloud storage and databases

Use dataset API URLs to load normalized records into BigQuery, Snowflake, S3, or your own warehouse.

### API usage

Use the Apify API from JavaScript, Python, or cURL to automate app privacy extraction.

#### Run with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/google-play-data-safety-scraper').call({
  appIds: ['com.spotify.music'],
  locale: 'en',
  country: 'US'
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Run with Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/google-play-data-safety-scraper").call(
    run_input={"appIds": ["com.spotify.music"], "locale": "en", "country": "US"}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

#### Run with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~google-play-data-safety-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"appIds":["com.spotify.music"],"locale":"en","country":"US"}'
```

### Use with Apify MCP

Connect AI assistants through Apify MCP. For Claude Code, run:

```bash
claude mcp add --transport http apify https://mcp.apify.com/?tools=automation-lab/google-play-data-safety-scraper
```

For Claude Desktop, Cursor, or VS Code, add this remote server to the client's MCP JSON configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/google-play-data-safety-scraper"
    }
  }
}
```

Restart the client after saving the configuration, then authenticate with Apify when prompted.

Example prompts:

- “Check the Data Safety disclosure for these Android package IDs.”
- “Compare this app portfolio against last week's dataset.”
- “List apps declaring location sharing for advertising.”

### Scheduling a compliance monitor

1. Create an Apify task with your portfolio input.
2. Schedule it weekly or monthly.
3. Store the latest successful dataset ID.
4. Pass that ID as `priorDatasetId` on the next run.
5. Route records where `changes.changed` is true to your review workflow.

### Legality

#### Legal and ethical use

Google Play Data Safety pages are public developer declarations. Use the Actor responsibly and comply with applicable terms, laws, and organizational policies.

Do not use the output as the sole basis for consequential decisions. Validate important findings against the live page and other security or privacy evidence.

The user is responsible for selecting lawful inputs, retention periods, and downstream processing.

### Limitations

- Google may change HTML structure or wording.
- Developers may publish incomplete or inaccurate disclosures.
- Apps can vary by country, version, use, region, and age.
- English provides the strongest normalization.
- Deleted, restricted, or unavailable apps may be skipped.
- The Actor does not inspect APK code or network behavior.

### Troubleshooting

#### “Provide at least one valid app ID”

Check that `appIds` contains package IDs, URLs contain an `id` parameter, or `datasetId` points to rows with the configured field.

#### An app was skipped

Open the run log. The package may not exist in the selected country, may lack an accessible disclosure page, or Google may have returned an unexpected response.

#### Large batches receive intermittent failures

Enable `useProxy`, reduce overlapping schedules, and retry failed package IDs in a later run.

#### Collected or shared arrays are empty

Some developers declare no sharing, and some pages vary by locale. Confirm the live English Data Safety page before treating an empty array as an extraction issue.

### FAQ

#### Does this scrape app reviews or ratings?

No. It targets Data Safety declarations. Use a dedicated Google Play metadata or reviews Actor for reviews, ratings, installs, and broader app details.

#### Can I compare two runs?

Yes. Supply the earlier output dataset as `priorDatasetId` to receive a stable hash comparison and added/removed entries.

#### Is a Google account required?

No. The Actor accesses public disclosure pages anonymously.

#### Does it verify that an app truly follows the declaration?

No. It structures what the developer reports on Google Play.

#### Can I export CSV?

Yes. Open the dataset and choose CSV, Excel, JSON, XML, RSS, or another supported format.

### Related scrapers

Combine this Actor with Automation Lab tools for broader app intelligence:

- [Google Play Store Scraper](https://apify.com/automation-lab/google-play-store-scraper) for app metadata and discovery.
- [Google Play Reviews Scraper](https://apify.com/automation-lab/google-play-reviews-scraper) for review monitoring and customer feedback.

Use Data Safety output as the privacy layer alongside product, publisher, and review datasets.

### Support

If a page that works in an English browser is repeatedly skipped, open an Actor issue with the package ID, locale, country, and run ID. Do not include confidential portfolio information in a public report.

# Actor input Schema

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

Google Play package IDs, such as com.spotify.music.

## `startUrls` (type: `array`):

App details or Data Safety URLs.

## `datasetId` (type: `string`):

Optional dataset containing app IDs.

## `datasetAppIdField` (type: `string`):

Column containing package IDs.

## `priorDatasetId` (type: `string`):

Compare current disclosures with earlier actor output.

## `locale` (type: `string`):

Google Play language code. Parsing is optimized for English.

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

Two-letter Google Play country code.

## `useProxy` (type: `boolean`):

Rotate proxy IPs for larger portfolios.

## Actor input object example

```json
{
  "appIds": [
    "com.spotify.music",
    "com.whatsapp"
  ],
  "startUrls": [],
  "datasetAppIdField": "appId",
  "locale": "en",
  "country": "US",
  "useProxy": false
}
```

# Actor output Schema

## `dataset` (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 = {
    "appIds": [
        "com.spotify.music",
        "com.whatsapp"
    ],
    "startUrls": [],
    "datasetAppIdField": "appId",
    "locale": "en",
    "country": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/google-play-data-safety-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 = {
    "appIds": [
        "com.spotify.music",
        "com.whatsapp",
    ],
    "startUrls": [],
    "datasetAppIdField": "appId",
    "locale": "en",
    "country": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/google-play-data-safety-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 '{
  "appIds": [
    "com.spotify.music",
    "com.whatsapp"
  ],
  "startUrls": [],
  "datasetAppIdField": "appId",
  "locale": "en",
  "country": "US"
}' |
apify call automation-lab/google-play-data-safety-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Play Data Safety Scraper",
        "description": "🔐 Extract normalized Google Play Data Safety disclosures and monitor collection, sharing, security, deletion, privacy-policy, and disclosure changes across Android app portfolios.",
        "version": "0.1",
        "x-build-id": "uHe8bH7eaTufLdwJQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~google-play-data-safety-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-google-play-data-safety-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/automation-lab~google-play-data-safety-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-google-play-data-safety-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/automation-lab~google-play-data-safety-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-google-play-data-safety-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",
                "properties": {
                    "appIds": {
                        "title": "📱 App IDs",
                        "type": "array",
                        "description": "Google Play package IDs, such as com.spotify.music.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "🔗 Google Play URLs",
                        "type": "array",
                        "description": "App details or Data Safety URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "datasetId": {
                        "title": "📦 Input dataset ID",
                        "type": "string",
                        "description": "Optional dataset containing app IDs."
                    },
                    "datasetAppIdField": {
                        "title": "Dataset app ID field",
                        "type": "string",
                        "description": "Column containing package IDs.",
                        "default": "appId"
                    },
                    "priorDatasetId": {
                        "title": "🔄 Prior dataset ID",
                        "type": "string",
                        "description": "Compare current disclosures with earlier actor output."
                    },
                    "locale": {
                        "title": "🌐 Language",
                        "type": "string",
                        "description": "Google Play language code. Parsing is optimized for English.",
                        "default": "en"
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Two-letter Google Play country code.",
                        "default": "US"
                    },
                    "useProxy": {
                        "title": "🛡️ Use Apify Proxy",
                        "type": "boolean",
                        "description": "Rotate proxy IPs for larger portfolios.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```