# Apple App Store Apps Scraper (`fetch_cat/apple-app-store-apps-scraper`) Actor

🔎 Scrape Apple App Store app search results and metadata by keyword, app ID, country, and developer portfolio. Export ratings, prices, versions, genres, and URLs.

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

## Pricing

from $0.03 / 1,000 app records

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

## Apple App Store Apps Scraper

Find iOS and macOS apps, compare competitors, and export structured Apple App Store metadata for ASO, market research, product tracking, and lead generation.

### What does Apple App Store Apps Scraper do?

Apple App Store Apps Scraper collects public app metadata from Apple App Store search and direct app ID lookups.

Use it to turn App Store searches into clean rows with app names, app IDs, bundle IDs, developers, genres, prices, ratings, versions, update dates, descriptions, artwork, screenshots, device support, and App Store URLs.

The actor is designed for fast app discovery and metadata monitoring rather than user-review extraction.

### Who is it for?

- 📈 ASO agencies tracking keyword competitors across countries
- 📱 Mobile app publishers monitoring their own apps and rivals
- 🧭 Competitive-intelligence teams building app market maps
- 🛒 Ecommerce and marketplace teams researching app ecosystems
- 🧪 Product teams watching releases, pricing, ratings, and category changes
- 🧰 Data teams that need exportable App Store metadata without manual copying

### Why use this App Store scraper?

- 🔎 Search by keywords such as `budget planner`, `photo editor`, or `fitness tracker`
- 🆔 Look up exact Apple app IDs from App Store URLs
- 🌍 Compare country-specific metadata, prices, currencies, and ratings
- 🧾 Export structured data to JSON, CSV, Excel, Google Sheets, or your API
- ⚙️ Control maximum records to keep runs small or scale up discovery jobs
- 🧑‍💻 Optionally expand from known app IDs to other apps by the same developers

### What data can it extract?

| Field | Description |
| --- | --- |
| `appId` | Numeric Apple App Store app identifier |
| `bundleId` | iOS/macOS bundle identifier when available |
| `appName` | App listing name |
| `developer` | Public developer / artist name |
| `developerId` | Apple developer identifier |
| `sellerName` | Seller or publisher name |
| `primaryGenre` | Main App Store genre |
| `genres` | All available genre labels |
| `price` | Numeric price |
| `formattedPrice` | Store-formatted price label |
| `currency` | Local currency code |
| `averageRating` | Average public user rating |
| `ratingCount` | Total public rating count |
| `version` | Current app version |
| `releaseDate` | Original release date |
| `updatedDate` | Current version release date |
| `releaseNotes` | Latest release notes when available |
| `description` | Full public app description |
| `descriptionSnippet` | Short description excerpt for quick review |
| `appStoreUrl` | Direct App Store listing URL |
| `artworkUrl` | App icon / artwork URL |
| `screenshotUrls` | iPhone screenshot URLs |
| `ipadScreenshotUrls` | iPad screenshot URLs |
| `supportedDevices` | Public supported device list |
| `contentRating` | Age/content rating label |
| `minimumOsVersion` | Minimum OS version |
| `fileSizeBytes` | App binary size when Apple provides it |
| `languages` | Supported language codes |
| `sellerUrl` | Developer website URL when available |
| `scrapedAt` | Timestamp of extraction |

### How much does it cost to scrape Apple App Store app data?

This actor uses pay-per-event pricing.

You pay a small start event plus a per-app record event.

Typical keyword discovery runs are inexpensive because App Store metadata is fetched without a browser.

Final tiered prices are shown on the Apify Store pricing tab and in the run details before publication.

### How to scrape App Store search results

1. Open the actor on Apify.
2. Add one or more search terms.
3. Choose the App Store country, for example `US`, `GB`, or `DE`.
4. Set `Maximum apps` to the number of records you want.
5. Click **Start**.
6. Export the dataset in JSON, CSV, Excel, XML, RSS, or HTML.

### How to look up exact apps by ID

Use the numeric ID from an App Store URL.

For example, this URL:

`https://apps.apple.com/us/app/google-maps/id585027354`

contains app ID:

`585027354`

Paste one or more IDs into **App IDs** to fetch exact app records.

### Input options

| Input | Type | Description |
| --- | --- | --- |
| `searchTerms` | array of strings | App Store keywords to search |
| `appIds` | array of strings | Numeric Apple app IDs to look up |
| `country` | string | Two-letter App Store country code |
| `language` | string | Apple language code such as `en_us` |
| `maxItems` | integer | Maximum app records to save |
| `includeDeveloperApps` | boolean | Expand app ID lookups to developer portfolios |

### Example input

```json
{
  "searchTerms": ["todo app", "fitness tracker"],
  "appIds": ["284882215"],
  "country": "US",
  "language": "en_us",
  "maxItems": 20,
  "includeDeveloperApps": false
}
````

### Example output

```json
{
  "source": "search",
  "country": "US",
  "language": "en_us",
  "appId": 284882215,
  "bundleId": "com.facebook.Facebook",
  "appName": "Facebook",
  "developer": "Meta Platforms, Inc.",
  "primaryGenre": "Social Networking",
  "price": 0,
  "currency": "USD",
  "averageRating": 4.2,
  "ratingCount": 12345678,
  "version": "latest",
  "appStoreUrl": "https://apps.apple.com/...",
  "artworkUrl": "https://...png",
  "scrapedAt": "2026-06-19T00:00:00.000Z"
}
```

### Country and language tips

App Store metadata can vary by country.

Use country codes such as:

- 🇺🇸 `US` for United States
- 🇬🇧 `GB` for United Kingdom
- 🇩🇪 `DE` for Germany
- 🇫🇷 `FR` for France
- 🇯🇵 `JP` for Japan
- 🇦🇺 `AU` for Australia

Use language codes such as `en_us`, `de_de`, `fr_fr`, or `ja_jp`.

### Search tips

Start with focused keywords.

Good examples:

- `habit tracker`
- `invoice maker`
- `ai photo editor`
- `meal planner`
- `running tracker`

For broad category research, raise `Maximum apps` gradually.

### App ID tips

Direct app ID lookup is best when you already know the apps you want to monitor.

Use app IDs for:

- Your own app portfolio
- Known competitors
- Apps from another dataset
- Scheduled monitoring workflows
- Developer portfolio expansion

### Developer portfolio enrichment

Enable `includeDeveloperApps` when you provide app IDs and want to discover other apps by the same public developer.

This is useful for mapping publishers and identifying related products.

Keep `Maximum apps` high enough if you expect large portfolios.

### Integrations

Use the output dataset with:

- Google Sheets for competitor trackers
- Slack alerts for app version changes
- BI dashboards for App Store market maps
- Airtable bases for app databases
- CRM enrichment for mobile publisher leads
- Data warehouses for historical ASO analysis

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/apple-app-store-apps-scraper').call({
  searchTerms: ['todo app'],
  country: 'US',
  maxItems: 20
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/apple-app-store-apps-scraper').call(run_input={
    'searchTerms': ['todo app'],
    'country': 'US',
    'maxItems': 20,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl "https://api.apify.com/v2/acts/fetch_cat~apple-app-store-apps-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms":["todo app"],"country":"US","maxItems":20}'
```

### MCP usage

Connect the actor to Claude Desktop, Claude Code, or other MCP clients through Apify MCP.

Use this tools URL:

`https://mcp.apify.com/?tools=fetch_cat/apple-app-store-apps-scraper`

Claude Code CLI setup:

```bash
claude mcp add apify-apple-app-store-apps "https://mcp.apify.com/?tools=fetch_cat/apple-app-store-apps-scraper"
```

Claude Desktop JSON config example:

```json
{
  "mcpServers": {
    "apify-apple-app-store-apps": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/apple-app-store-apps-scraper"
    }
  }
}
```

Example prompts:

- “Find the top App Store apps for habit tracking in the US and summarize their ratings.”
- “Look up these app IDs and compare their genres, prices, and update dates.”
- “Build a table of competitor apps for the keyword photo editor in Germany.”

### Scheduling

Schedule the actor to run daily, weekly, or monthly to monitor:

- Rating count growth
- Version releases
- Price changes
- Competitor description changes
- New apps for target keywords

### Data quality notes

Apple may omit some fields for some apps or countries.

For example, screenshots, seller URLs, or current-version ratings may be unavailable.

Country-specific availability can also affect search results.

### Troubleshooting

#### Why did I get fewer apps than expected?

The App Store may have fewer matching public results for that keyword and country, or duplicate apps may be removed across inputs.

Try a broader search term or another country.

#### Why are some ratings empty?

Some apps have insufficient public ratings in the selected country or Apple does not return the field for that listing.

#### Can it scrape reviews?

This actor focuses on app search and metadata. Use the related reviews scraper for review text workflows.

### Legality and responsible use

This actor extracts publicly available App Store metadata.

You should use the data responsibly and follow Apify’s Terms of Service, Apple’s terms, and applicable laws.

Do not use the actor to collect private user data or bypass access controls.

### Related scrapers

- https://apify.com/fetch\_cat/apple-app-store-reviews-scraper
- https://apify.com/fetch\_cat/google-play-apps-scraper
- https://apify.com/fetch\_cat/google-play-reviews-scraper

### FAQ

#### Does this require an Apple account?

No. It works with public App Store metadata.

#### Does it use a browser?

No. Runs are lightweight and suitable for metadata discovery jobs.

#### Can I scrape multiple countries?

Run the actor separately per country if you need country-by-country comparison tables.

#### Can I mix searches and app IDs?

Yes. The actor accepts both in the same run and deduplicates apps by App Store app ID.

#### How many results can I request?

Use `maxItems` to cap the dataset. Start small for testing, then increase for production workflows.

### Changelog

#### 0.1

Initial version with keyword search, app ID lookup, country/language inputs, developer portfolio enrichment, and structured app metadata output.

# Actor input Schema

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

Keywords to search in the Apple App Store, such as competitor names, categories, or product terms.

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

Apple numeric app IDs to look up directly. You can find them in App Store URLs, for example id284882215.

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

Two-letter App Store country code used for localized availability, price, ratings, and currency.

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

Apple API language code, for example en\_us, de\_de, or fr\_fr.

## `maxItems` (type: `integer`):

Maximum number of app records to save across searches, app ID lookups, and optional developer portfolio enrichment.

## `includeDeveloperApps` (type: `boolean`):

When app IDs are supplied, also fetch other public apps from the same developer portfolios until the maximum is reached.

## Actor input object example

```json
{
  "searchTerms": [
    "todo app",
    "fitness tracker"
  ],
  "appIds": [
    "284882215",
    "310633997"
  ],
  "country": "US",
  "language": "en_us",
  "maxItems": 20,
  "includeDeveloperApps": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchTerms": [
        "todo app",
        "fitness tracker"
    ],
    "appIds": [
        "284882215",
        "310633997"
    ],
    "country": "US",
    "language": "en_us",
    "maxItems": 20,
    "includeDeveloperApps": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/apple-app-store-apps-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": [
        "todo app",
        "fitness tracker",
    ],
    "appIds": [
        "284882215",
        "310633997",
    ],
    "country": "US",
    "language": "en_us",
    "maxItems": 20,
    "includeDeveloperApps": False,
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/apple-app-store-apps-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": [
    "todo app",
    "fitness tracker"
  ],
  "appIds": [
    "284882215",
    "310633997"
  ],
  "country": "US",
  "language": "en_us",
  "maxItems": 20,
  "includeDeveloperApps": false
}' |
apify call fetch_cat/apple-app-store-apps-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apple App Store Apps Scraper",
        "description": "🔎 Scrape Apple App Store app search results and metadata by keyword, app ID, country, and developer portfolio. Export ratings, prices, versions, genres, and URLs.",
        "version": "0.1",
        "x-build-id": "zyMob0AVNVCUNrdvX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~apple-app-store-apps-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-apple-app-store-apps-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/fetch_cat~apple-app-store-apps-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-apple-app-store-apps-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/fetch_cat~apple-app-store-apps-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-apple-app-store-apps-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": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Keywords to search in the Apple App Store, such as competitor names, categories, or product terms.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "appIds": {
                        "title": "App IDs",
                        "type": "array",
                        "description": "Apple numeric app IDs to look up directly. You can find them in App Store URLs, for example id284882215.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Two-letter App Store country code used for localized availability, price, ratings, and currency.",
                        "default": "US"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Apple API language code, for example en_us, de_de, or fr_fr.",
                        "default": "en_us"
                    },
                    "maxItems": {
                        "title": "Maximum apps",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of app records to save across searches, app ID lookups, and optional developer portfolio enrichment.",
                        "default": 20
                    },
                    "includeDeveloperApps": {
                        "title": "Include developer portfolio apps",
                        "type": "boolean",
                        "description": "When app IDs are supplied, also fetch other public apps from the same developer portfolios until the maximum is reached.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```