# Microsoft Learn Catalog Scraper (`automation-lab/microsoft-learn-catalog-scraper`) Actor

Export Microsoft Learn modules, learning paths, certifications, exams, and courses for L\&D catalog sync and skills taxonomy workflows.

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

## Pricing

from $0.01 / 1,000 catalog item saveds

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

## Microsoft Learn Catalog Scraper

Export Microsoft Learn catalog metadata from the public Microsoft Learn Catalog API.

Use this actor to collect modules, learning paths, certifications, exams, and instructor-led courses for L&D platforms, skills taxonomies, training-content monitoring, recruiting intelligence, and education data pipelines.

### What does Microsoft Learn Catalog Scraper do?

Microsoft Learn Catalog Scraper turns Microsoft Learn's public catalog JSON into clean Apify dataset rows.

It extracts Microsoft Learn records such as modules, learning paths, certifications, exams, and courses.

Each output row includes stable Microsoft UIDs, titles, summaries, URLs, duration, roles, products, levels, subjects, ratings, popularity, related item IDs, update timestamps, and optional raw source JSON.

### Who is it for?

#### L&D platforms

Sync Microsoft Learn modules and paths into internal course catalogs.

#### Training teams

Monitor new and changed Microsoft Learn content for Azure, Power Platform, GitHub, Microsoft 365, security, and data workloads.

#### Certification teams

Track exams and certifications with related study material.

#### Recruiting and workforce analytics teams

Map Microsoft training content to role and skill taxonomies.

#### Education data vendors

Build normalized Microsoft Learn datasets for search, recommendations, or market intelligence.

### Why use this actor?

- ✅ Uses the public Microsoft Learn Catalog API.
- ✅ No login, browser, or residential proxy required.
- ✅ Normalizes multiple catalog collections into one clean dataset.
- ✅ Supports locale, type, text, product, role, level, and subject filters.
- ✅ Includes stable UIDs for incremental catalog syncs.
- ✅ Can include raw source objects for audit-heavy pipelines.

### What Microsoft Learn data can I scrape?

You can scrape:

- Microsoft Learn modules
- Microsoft Learn learning paths
- Microsoft certifications
- Microsoft exams
- Microsoft courses

### Data fields

| Field | Description |
| --- | --- |
| `catalogType` | Requested API collection |
| `itemType` | Microsoft item type |
| `uid` | Stable Microsoft Learn UID |
| `title` | Catalog item title |
| `summary` | Clean text summary or subtitle |
| `url` | Microsoft Learn URL |
| `locale` | Returned locale |
| `durationMinutes` | Duration in minutes |
| `durationHours` | Duration in hours |
| `products` | Microsoft product slugs |
| `roles` | Microsoft role slugs |
| `levels` | Beginner, intermediate, advanced, and related levels |
| `subjects` | Subject slugs |
| `popularity` | Microsoft popularity score when present |
| `ratingAverage` | Average rating when present |
| `ratingCount` | Rating count when present |
| `lastModified` | Microsoft last-modified timestamp |
| `iconUrl` | Catalog icon URL |
| `childCount` | Number of units/modules when present |
| `relatedUids` | Related units, modules, exams, courses, or study guides |
| `scrapedAt` | Actor scrape timestamp |
| `raw` | Optional original source object |

### How much does it cost to scrape Microsoft Learn catalog data?

This actor uses pay-per-event pricing.

There is a small start charge per run and a per-item charge for each catalog record saved.

The default input is intentionally small enough for a first test run while still returning useful module data.

For large catalog syncs, increase `maxItems` or select more catalog types.

### How to scrape Microsoft Learn modules

1. Open the actor on Apify.
2. Keep `catalogTypes` set to `modules`.
3. Keep `locale` as `en-us` or enter another Microsoft Learn locale.
4. Set `maxItems` to the number of module records you need.
5. Run the actor.
6. Download results as JSON, CSV, Excel, XML, or HTML.

### How to monitor Microsoft Learn certifications

1. Set `catalogTypes` to `certifications`.
2. Optionally set `roles` such as `solution-architect`.
3. Optionally set `levels` such as `intermediate`.
4. Run the actor daily or weekly.
5. Compare `uid` and `lastModified` values between runs.

### Input options

#### `catalogTypes`

Select one or more catalog collections.

Available values are `modules`, `learningPaths`, `certifications`, `exams`, and `courses`.

#### `locale`

Use a Microsoft Learn locale such as `en-us`, `de-de`, `fr-fr`, `ja-jp`, or `es-es`.

#### `maxItems`

Limit how many matching records are saved across all selected catalog types.

#### `searchQuery`

Filter records by title, summary, subtitle, UID, display name, or course number.

#### `products`

Filter by product slugs such as `azure`, `azure-machine-learning`, `power-bi`, or `github`.

#### `roles`

Filter by role slugs such as `developer`, `administrator`, `data-scientist`, or `solution-architect`.

#### `levels`

Filter by level values such as `beginner`, `intermediate`, or `advanced`.

#### `subjects`

Filter by subject slugs such as `machine-learning` or `cloud-computing`.

#### `includeRaw`

Set to `true` to include the original Microsoft Learn JSON object in each dataset row.

### Example input

```json
{
  "catalogTypes": ["modules"],
  "locale": "en-us",
  "maxItems": 100,
  "products": ["azure"],
  "levels": ["beginner"],
  "includeRaw": false
}
````

### Example output

```json
{
  "catalogType": "modules",
  "itemType": "module",
  "uid": "learn.wwl.experiment-azure-machine-learning",
  "title": "Experiment with Azure Machine Learning",
  "summary": "Learn how to find the best machine learning model...",
  "url": "https://learn.microsoft.com/en-us/training/modules/experiment-azure-machine-learning/",
  "locale": "en-us",
  "durationMinutes": 65,
  "durationHours": 1.08,
  "products": ["azure-machine-learning"],
  "roles": ["data-scientist"],
  "levels": ["beginner"],
  "subjects": ["machine-learning"],
  "lastModified": "2026-03-13T17:10:00+00:00"
}
```

### Tips for best results

- Start with one catalog type to inspect available fields.
- Use `maxItems` for sample runs.
- Use `uid` as your primary key in downstream systems.
- Use `lastModified` to detect changes between catalog snapshots.
- Enable `includeRaw` only when you need complete source JSON.

### Integrations

Connect the dataset to:

- Learning management systems
- Skills ontology databases
- Data warehouses
- BI dashboards
- Recruiting analytics workflows
- Catalog-change monitors
- Certification content trackers

### 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/microsoft-learn-catalog-scraper').call({
  catalogTypes: ['modules', 'learningPaths'],
  locale: 'en-us',
  maxItems: 500,
  products: ['azure']
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/microsoft-learn-catalog-scraper').call(run_input={
    'catalogTypes': ['certifications', 'exams'],
    'locale': 'en-us',
    'maxItems': 250,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~microsoft-learn-catalog-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"catalogTypes":["modules"],"locale":"en-us","maxItems":100}'
```

### MCP integration

Use this actor from MCP-compatible clients through Apify MCP Server.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/microsoft-learn-catalog-scraper
```

Add it in Claude Code:

```bash
claude mcp add apify-microsoft-learn "https://mcp.apify.com/?tools=automation-lab/microsoft-learn-catalog-scraper"
```

Or use a JSON MCP configuration:

```json
{
  "mcpServers": {
    "apify-microsoft-learn": {
      "url": "https://mcp.apify.com/?tools=automation-lab/microsoft-learn-catalog-scraper"
    }
  }
}
```

#### MCP prompts

Try prompts such as:

Example prompts:

- "Using MCP, run the Microsoft Learn Catalog Scraper to export 100 beginner Azure modules."
- "Using the Apify MCP tool, run the Microsoft Learn actor and find certifications for solution architects."
- "Use MCP with automation-lab/microsoft-learn-catalog-scraper to monitor Microsoft Learn exams and return UIDs plus last modified dates."

### Scheduling

You can schedule this actor to run daily, weekly, or monthly.

For catalog monitoring, store each dataset and compare `uid` plus `lastModified` between runs.

### Locale support

The actor passes your locale to the Microsoft Learn Catalog API.

Availability can vary by catalog item and Microsoft locale.

If a localized item is not available, Microsoft may return source metadata according to the API's behavior.

### Filtering strategy

Filters are applied after the public API response is downloaded.

This keeps behavior consistent across all catalog collections, including collections with different API-side filter support.

### Legality

This actor uses a public Microsoft Learn catalog endpoint and extracts public metadata.

You should still follow Microsoft terms, respect intellectual property, and use the data for legitimate business purposes.

Do not use the actor to copy protected course content beyond public catalog metadata.

### Troubleshooting

#### I got fewer records than expected

Check `maxItems`, selected catalog types, and filters. A product, role, level, subject, or text filter can narrow results quickly.

#### I do not see raw Microsoft fields

Set `includeRaw` to `true`. Raw fields are disabled by default to keep datasets smaller and easier to export.

#### A product or role filter returns nothing

Microsoft uses slug values. Inspect an unfiltered sample first, then reuse exact slugs from the `products` and `roles` arrays.

### FAQ

#### Can I scrape all Microsoft Learn modules?

Yes. Select `modules` and set `maxItems` high enough for the module catalog.

#### Can I scrape certifications and exams in one run?

Yes. Select both `certifications` and `exams` in `catalogTypes`.

#### Does this actor need proxies?

No. The baseline actor calls the public Microsoft Learn Catalog API directly.

#### Can I use this for change detection?

Yes. Use `uid` as the key and compare `lastModified` across scheduled runs.

#### Can I export to CSV?

Yes. Apify datasets can be downloaded as CSV, JSON, Excel, XML, RSS, or HTML.

### Related scrapers

Explore related Automation Lab actors:

- https://apify.com/automation-lab/udemy-scraper
- https://apify.com/automation-lab/linkedin-learning-scraper
- https://apify.com/automation-lab/coursera-scraper
- https://apify.com/automation-lab/job-board-keyword-signal-scanner

### Changelog

Initial version exports Microsoft Learn catalog records from the public API.

### Support

If you need a custom field, catalog collection, or workflow integration, open an issue from the actor page.

# Actor input Schema

## `catalogTypes` (type: `array`):

Microsoft Learn catalog collections to export.

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

Microsoft Learn locale code to request, for example en-us, de-de, fr-fr, ja-jp, or es-es.

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

Maximum number of matching catalog records to save across all selected catalog types.

## `searchQuery` (type: `string`):

Optional case-insensitive text filter matched against title, summary, subtitle, UID, display name, and course number.

## `products` (type: `array`):

Optional Microsoft product slugs to include, e.g. azure, azure-machine-learning, power-bi, github.

## `roles` (type: `array`):

Optional Microsoft Learn role slugs to include, e.g. developer, administrator, data-scientist, solution-architect.

## `levels` (type: `array`):

Optional learning levels to include, e.g. beginner, intermediate, advanced.

## `subjects` (type: `array`):

Optional subject slugs to include, e.g. machine-learning, cloud-computing, app-development.

## `includeRaw` (type: `boolean`):

Attach the original Microsoft Learn catalog object to each output item for audits and custom pipelines.

## Actor input object example

```json
{
  "catalogTypes": [
    "modules"
  ],
  "locale": "en-us",
  "maxItems": 20,
  "includeRaw": 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 = {
    "catalogTypes": [
        "modules"
    ],
    "locale": "en-us",
    "maxItems": 20,
    "includeRaw": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/microsoft-learn-catalog-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 = {
    "catalogTypes": ["modules"],
    "locale": "en-us",
    "maxItems": 20,
    "includeRaw": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/microsoft-learn-catalog-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 '{
  "catalogTypes": [
    "modules"
  ],
  "locale": "en-us",
  "maxItems": 20,
  "includeRaw": false
}' |
apify call automation-lab/microsoft-learn-catalog-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Microsoft Learn Catalog Scraper",
        "description": "Export Microsoft Learn modules, learning paths, certifications, exams, and courses for L&D catalog sync and skills taxonomy workflows.",
        "version": "0.1",
        "x-build-id": "CQqpJXcfcm05h60eS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~microsoft-learn-catalog-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-microsoft-learn-catalog-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~microsoft-learn-catalog-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-microsoft-learn-catalog-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~microsoft-learn-catalog-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-microsoft-learn-catalog-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": {
                    "catalogTypes": {
                        "title": "Catalog types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Microsoft Learn catalog collections to export.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "modules",
                                "learningPaths",
                                "certifications",
                                "exams",
                                "courses"
                            ],
                            "enumTitles": [
                                "Modules",
                                "Learning paths",
                                "Certifications",
                                "Exams",
                                "Courses"
                            ]
                        },
                        "default": [
                            "modules"
                        ]
                    },
                    "locale": {
                        "title": "Locale",
                        "type": "string",
                        "description": "Microsoft Learn locale code to request, for example en-us, de-de, fr-fr, ja-jp, or es-es.",
                        "default": "en-us"
                    },
                    "maxItems": {
                        "title": "Maximum catalog records",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of matching catalog records to save across all selected catalog types.",
                        "default": 20
                    },
                    "searchQuery": {
                        "title": "Text search",
                        "type": "string",
                        "description": "Optional case-insensitive text filter matched against title, summary, subtitle, UID, display name, and course number."
                    },
                    "products": {
                        "title": "Products",
                        "type": "array",
                        "description": "Optional Microsoft product slugs to include, e.g. azure, azure-machine-learning, power-bi, github.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "roles": {
                        "title": "Roles",
                        "type": "array",
                        "description": "Optional Microsoft Learn role slugs to include, e.g. developer, administrator, data-scientist, solution-architect.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "levels": {
                        "title": "Levels",
                        "type": "array",
                        "description": "Optional learning levels to include, e.g. beginner, intermediate, advanced.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "subjects": {
                        "title": "Subjects",
                        "type": "array",
                        "description": "Optional subject slugs to include, e.g. machine-learning, cloud-computing, app-development.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeRaw": {
                        "title": "Include raw Microsoft object",
                        "type": "boolean",
                        "description": "Attach the original Microsoft Learn catalog object to each output item for audits and custom pipelines.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```