# Apple App Store Top Charts & Rankings Scraper (`automation-lab/apple-app-store-top-charts-scraper`) Actor

🍎 Track Apple App Store top free and paid rankings by country. Export app ranks, IDs, bundle IDs, ratings, prices, genres, and URLs.

- **URL**: https://apify.com/automation-lab/apple-app-store-top-charts-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

## Apple App Store Top Charts & Rankings Scraper

Track Apple App Store chart rankings by country, enrich ranked apps with iTunes metadata, and export clean datasets for ASO, competitor monitoring, and market research.

### What does Apple App Store Top Charts & Rankings Scraper do?

Apple App Store Top Charts & Rankings Scraper extracts public Apple App Store ranking data from Apple's JSON feeds and iTunes APIs.

It collects top free and top paid app charts by storefront country.

It can enrich each ranked app with bundle ID, ratings, version, screenshots, description, genre, price, and developer details.

It can also run optional iTunes app keyword searches so you can combine chart monitoring with competitor discovery.

### Who is it for?

ASO teams use it to monitor which apps are rising or falling in important country charts.

Mobile app marketers use it to spot competitor movements before campaign planning.

App publishers use it to benchmark their own apps against category and market leaders.

Market analysts use it to build repeatable datasets for app economy research.

Investors and product strategists use it to identify fast-moving consumer app categories.

### Why use this App Store rankings scraper?

🍎 It uses public Apple JSON endpoints instead of brittle browser scraping.

🌍 It supports multiple country storefronts in one run.

📈 It keeps chart type and rank fields explicit for monitoring workflows.

🔎 It enriches chart records through the iTunes Lookup API.

🧾 It exports structured rows that are easy to load into BI tools, sheets, warehouses, and alerting systems.

### Data sources

The actor uses Apple Marketing Tools RSS JSON feeds for app charts.

It uses the public iTunes Lookup API to enrich app IDs returned by chart feeds.

It uses the public iTunes Search API when you provide optional search terms.

No login is required.

No browser is required.

No proxy is required for normal operation.

### Input options

| Field | Type | Description |
| --- | --- | --- |
| `countries` | array | Two-letter App Store country codes such as `us`, `gb`, `ca`, `au`, `de`, or `jp`. |
| `charts` | array | Chart feeds to scrape: `top-free` and/or `top-paid`. |
| `maxItems` | integer | Maximum dataset records across all countries, charts, and searches. |
| `includeDetails` | boolean | Enrich chart records with iTunes Lookup details. |
| `searchTerms` | array | Optional iTunes app keywords for competitor discovery. |
| `searchLimit` | integer | Search results per term and country. |

### Output data

Each dataset item represents one App Store chart or search result record.

| Field | Description |
| --- | --- |
| `country` | App Store storefront country code. |
| `chart` | Chart type, or `search` for keyword results. |
| `rank` | Position in the returned chart/search result list. |
| `appId` | Apple numeric app ID. |
| `name` | App name. |
| `developerName` | Developer or seller name. |
| `developerUrl` | Apple developer page URL when available. |
| `appStoreUrl` | App Store URL. |
| `bundleId` | iOS bundle identifier when available. |
| `genre` | Primary genre. |
| `genres` | All genres returned by Apple. |
| `price` | Price returned by iTunes Lookup. |
| `currency` | Currency code. |
| `rating` | Average user rating. |
| `ratingCount` | User rating count. |
| `version` | Current app version. |
| `releaseDate` | Original release date. |
| `updatedAt` | Current version release date or feed update date. |
| `iconUrl` | App icon artwork URL. |
| `screenshots` | Screenshot URLs. |
| `description` | App description. |
| `sourceUrl` | Apple JSON endpoint used for the record. |
| `searchTerm` | Keyword for search records. |
| `scrapedAt` | ISO timestamp when the actor saved the row. |

### Example input

```json
{
  "countries": ["us", "gb"],
  "charts": ["top-free", "top-paid"],
  "maxItems": 200,
  "includeDetails": true,
  "searchTerms": ["fitness tracker"],
  "searchLimit": 20
}
````

### Example output

```json
{
  "country": "us",
  "chart": "top-free",
  "rank": 1,
  "appId": "6448311069",
  "name": "ChatGPT",
  "developerName": "OpenAI OpCo, LLC",
  "bundleId": "com.openai.chat",
  "genre": "Productivity",
  "rating": 4.9,
  "ratingCount": 1000000,
  "appStoreUrl": "https://apps.apple.com/us/app/chatgpt/id6448311069",
  "sourceUrl": "https://rss.applemarketingtools.com/api/v2/us/apps/top-free/100/apps.json",
  "scrapedAt": "2026-06-25T00:00:00.000Z"
}
```

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

The actor uses pay-per-event pricing.

There is a small run start fee and a per-item fee for each app record saved.

Current formula-derived pricing is configured as a $0.005 start event and tiered per-item pricing with Bronze at about $0.000026 per extracted app record.

Actual platform pricing is shown on the Apify actor page before you run it.

### How to scrape App Store top charts

1. Choose one or more country storefronts.
2. Choose `top-free`, `top-paid`, or both.
3. Keep `includeDetails` enabled when you need bundle IDs, ratings, screenshots, and descriptions.
4. Set `maxItems` to the number of app records you need.
5. Run the actor and export the dataset as JSON, CSV, Excel, or through the Apify API.

### ASO monitoring workflow

Run the actor daily for your key countries.

Store the dataset in a warehouse or spreadsheet.

Compare app IDs, rank, and chart fields over time.

Trigger alerts when a competitor enters the top 10 or when your own app changes position.

### Competitor discovery workflow

Add search terms such as `habit tracker`, `budget planner`, or `ai photo editor`.

The actor will add iTunes Search API results to the same dataset shape.

Use `searchTerm` to separate discovery rows from top chart rows.

### Tips for best results

Use lowercase two-letter country codes.

Start with one or two countries when testing.

Use `maxItems` in multiples of 100 when collecting full chart pages.

Disable `includeDetails` only when you need the lowest possible runtime and can work with feed-level data.

Use search terms for discovery, not for historical rank tracking.

### Limits and caveats

Apple public chart feeds usually return up to 100 apps per country and chart.

Some chart types are not available in Apple's public feed for all media types, so this actor supports the stable `top-free` and `top-paid` app feeds.

Ratings, screenshots, descriptions, and bundle IDs depend on iTunes Lookup API availability.

Apple can change public feed structures; the actor is designed to fail one country/chart gracefully and continue with the rest.

### Integrations

Send results to Google Sheets for ASO dashboards.

Load results into BigQuery, Snowflake, or PostgreSQL for time-series ranking analysis.

Use Apify webhooks to trigger Slack alerts after scheduled runs.

Use Make, Zapier, or n8n to route new top-chart entries into reporting systems.

### 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('automation-lab/apple-app-store-top-charts-scraper').call({
  countries: ['us'],
  charts: ['top-free'],
  maxItems: 100,
  includeDetails: true,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/apple-app-store-top-charts-scraper').call(run_input={
    'countries': ['us'],
    'charts': ['top-free'],
    'maxItems': 100,
    'includeDetails': True,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~apple-app-store-top-charts-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"countries":["us"],"charts":["top-free"],"maxItems":100,"includeDetails":true}'
```

### MCP usage

Use Apify MCP when you want Claude Desktop, Claude Code, or another MCP client to run the scraper as a tool.

Add the actor to Claude Code:

```bash
claude mcp add apify-apple-app-store-rankings https://mcp.apify.com/?tools=automation-lab/apple-app-store-top-charts-scraper
```

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/apple-app-store-top-charts-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-apple-app-store-rankings": {
      "url": "https://mcp.apify.com/?tools=automation-lab/apple-app-store-top-charts-scraper"
    }
  }
}
```

Example prompts:

- "Run the Apple App Store top charts scraper for US top free apps and summarize the top 20 productivity apps."
- "Compare paid app rankings in US and GB and return apps with rating count above 10,000."
- "Find fitness tracker competitors from App Store search and list their bundle IDs."

### Legality and responsible use

This actor uses public Apple JSON endpoints.

You are responsible for using exported data in line with applicable laws, platform terms, and privacy rules.

Do not use the dataset for spam, abusive automation, or prohibited profiling.

### Related scrapers

Explore other automation-lab actors for mobile app intelligence, app reviews, website monitoring, and market research workflows.

Related actor pages use the `https://apify.com/automation-lab/` namespace.

### Troubleshooting

If a country returns no records, verify that the country code is a valid Apple storefront code.

If a chart returns no records, try `top-free` or `top-paid` for the same country.

If enriched fields are missing, keep `includeDetails` enabled and check whether iTunes Lookup returns those fields for the app.

If a run stops earlier than expected, increase `maxItems` and verify how many country/chart/search combinations you requested.

### FAQ

#### Can I scrape App Store rankings by country?

Yes. Provide one or more country codes in `countries`.

#### Can I get bundle IDs?

Yes. Keep `includeDetails` enabled so the actor calls iTunes Lookup.

#### Does it scrape reviews?

No. This actor focuses on top charts, rankings, and app metadata. Use a review-specific actor for review text.

#### Does it need proxies?

No. The MVP uses public Apple JSON APIs and normally does not require proxies.

#### Can I schedule it?

Yes. Use Apify schedules to run it daily or hourly and compare datasets over time.

### Changelog

Initial version supports Apple top free and top paid app charts, multi-country runs, iTunes Lookup enrichment, and optional iTunes Search discovery.

# Actor input Schema

## `countries` (type: `array`):

Two-letter App Store country codes to collect, such as us, gb, ca, au, de, or jp.

## `charts` (type: `array`):

Apple public Marketing Tools app charts to scrape.

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

Maximum dataset records across all countries, charts, and searches. Apple chart feeds return up to 100 apps per country/chart.

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

Adds bundle ID, rating, rating count, version, screenshots, description, price, currency, and developer URL where Apple returns them.

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

Optional keywords for iTunes app search. Use this to combine chart monitoring with competitor/app discovery.

## `searchLimit` (type: `integer`):

Maximum iTunes Search API results for each search term in each country.

## Actor input object example

```json
{
  "countries": [
    "us",
    "gb"
  ],
  "charts": [
    "top-free",
    "top-paid"
  ],
  "maxItems": 20,
  "includeDetails": true,
  "searchTerms": [
    "fitness tracker"
  ],
  "searchLimit": 10
}
```

# 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 = {
    "countries": [
        "us",
        "gb"
    ],
    "charts": [
        "top-free",
        "top-paid"
    ],
    "maxItems": 20,
    "includeDetails": true,
    "searchTerms": [
        "fitness tracker"
    ],
    "searchLimit": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/apple-app-store-top-charts-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 = {
    "countries": [
        "us",
        "gb",
    ],
    "charts": [
        "top-free",
        "top-paid",
    ],
    "maxItems": 20,
    "includeDetails": True,
    "searchTerms": ["fitness tracker"],
    "searchLimit": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/apple-app-store-top-charts-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 '{
  "countries": [
    "us",
    "gb"
  ],
  "charts": [
    "top-free",
    "top-paid"
  ],
  "maxItems": 20,
  "includeDetails": true,
  "searchTerms": [
    "fitness tracker"
  ],
  "searchLimit": 10
}' |
apify call automation-lab/apple-app-store-top-charts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apple App Store Top Charts & Rankings Scraper",
        "description": "🍎 Track Apple App Store top free and paid rankings by country. Export app ranks, IDs, bundle IDs, ratings, prices, genres, and URLs.",
        "version": "0.1",
        "x-build-id": "B3cfocAlczTydbL5n"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~apple-app-store-top-charts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-apple-app-store-top-charts-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~apple-app-store-top-charts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-apple-app-store-top-charts-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~apple-app-store-top-charts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-apple-app-store-top-charts-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": [
                    "countries",
                    "charts",
                    "maxItems"
                ],
                "properties": {
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "Two-letter App Store country codes to collect, such as us, gb, ca, au, de, or jp.",
                        "items": {
                            "type": "string",
                            "minLength": 2,
                            "maxLength": 2
                        },
                        "default": [
                            "us"
                        ]
                    },
                    "charts": {
                        "title": "Chart types",
                        "type": "array",
                        "description": "Apple public Marketing Tools app charts to scrape.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "top-free"
                        ]
                    },
                    "maxItems": {
                        "title": "Maximum apps",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum dataset records across all countries, charts, and searches. Apple chart feeds return up to 100 apps per country/chart.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Enrich apps with iTunes Lookup details",
                        "type": "boolean",
                        "description": "Adds bundle ID, rating, rating count, version, screenshots, description, price, currency, and developer URL where Apple returns them.",
                        "default": true
                    },
                    "searchTerms": {
                        "title": "Optional app search terms",
                        "type": "array",
                        "description": "Optional keywords for iTunes app search. Use this to combine chart monitoring with competitor/app discovery.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchLimit": {
                        "title": "Search results per term/country",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum iTunes Search API results for each search term in each country.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
