# Khan Academy Scraper (`crawlerbros/khanacademy-scraper`) Actor

Scrape Khan Academy with free CC-licensed educational content. Search by keyword, fetch by path/URL/subject, list all courses, look up videos by YouTube ID. Returns videos with download URLs, articles, exercises, courses and units.

- **URL**: https://apify.com/crawlerbros/khanacademy-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Videos, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Khan Academy Scraper

Scrape free, CC-licensed educational content from [Khan Academy](https://www.khanacademy.org). The scraper exposes search, the full topic browser, by-subject course listings, direct path/URL lookups for videos / articles / exercises / courses, and a YouTube-ID lookup for any video Khan Academy publishes.

Khan Academy is a freely accessible educational platform — no login or API key required. The scraper uses Khan Academy's own public GraphQL endpoints (the same ones the website calls) and returns clean structured records with rich video metadata (download URLs, subtitles, durations) for downstream use in research, content discovery, dataset building, or curriculum tools.

### Features

- **Search** — full-text search across videos, articles, exercises and topics
- **Topic browser** — list every course Khan Academy offers, grouped by category
- **By subject** — list all courses under a major root subject (Math, Science, Computing, Test Prep, etc.)
- **By path / URL** — fetch a single course, video, article or exercise directly
- **By YouTube video ID** — look up any Khan Academy-published video by its YouTube ID
- **Optional unit expansion** — emit a record per course-unit alongside the course record
- **Filtering** — restrict by subject, content kind, duration window, or keyword in title/description

### Use cases

- **Educators**: build curriculum playlists, find aligned exercises and articles for a topic
- **Researchers**: assemble open educational resource (OER) datasets, all CC-licensed
- **Content creators**: discover Khan Academy videos for a topic; pull download URLs and metadata
- **EdTech**: map a topic graph, mirror lesson content into your platform
- **Translators / accessibility tools**: detect subtitle availability per language

### Input

The actor accepts a single input object. Required field: `mode`.

| Field | Type | Description |
|---|---|---|
| `mode` | enum | One of `search`, `byPaths`, `byUrls`, `bySubject`, `topicBrowser`, `byVideoIds` |
| `searchQuery` | string | Free-text query (mode=search) |
| `subject` | enum | Root subject for mode=bySubject — math, science, computing, humanities, test-prep, ela, economics-finance-domain, partner-content, college-careers-more, khan-for-educators, ai-activities |
| `subjects` | enum[] | Restrict mode=search or mode=topicBrowser to these subjects |
| `contentKinds` | enum[] | Restrict mode=search to specific content kinds: Video, Article, Exercise, Topic |
| `paths` | string[] | Khan Academy content paths (e.g. `math/algebra`) |
| `urls` | string[] | Full khanacademy.org URLs |
| `videoIds` | string[] | YouTube IDs to resolve back into KA videos |
| `containsKeyword` | string | Drop records whose title/description/keywords do not contain this string (case-insensitive) |
| `minDurationSeconds` | integer | Drop videos shorter than this |
| `maxDurationSeconds` | integer | Drop videos longer than this |
| `includeUnits` | boolean | For course paths/URLs: emit one record per unit in addition to the course record |
| `maxItems` | integer | Hard cap on emitted records (default 50, max 5000) |

#### Example: list all courses under Math

```json
{
  "mode": "bySubject",
  "subject": "math",
  "maxItems": 50
}
````

#### Example: search videos about photosynthesis

```json
{
  "mode": "search",
  "searchQuery": "photosynthesis",
  "contentKinds": ["Video"],
  "maxItems": 25
}
```

#### Example: fetch a specific course + its units

```json
{
  "mode": "byUrls",
  "urls": ["https://www.khanacademy.org/math/algebra"],
  "includeUnits": true
}
```

#### Example: full topic-browser tree

```json
{
  "mode": "topicBrowser",
  "maxItems": 500
}
```

### Output

Each record is pushed to the default dataset. Fields are emitted only when populated (no nulls). Common fields across record types:

- `id` — Khan Academy content ID (e.g. `19647488`, `x2f8bb11595b61c86`)
- `slug` — URL-safe slug
- `kind` — One of `Video`, `Article`, `Exercise`, `Topic`, `Course`, `Unit`, `Project`
- `title` — Translated title
- `description` — HTML-stripped description
- `url` — Direct Khan Academy URL
- `subject` — Primary root subject slug
- `recordType` — Stable record-type label (`video`, `article`, `exercise`, `course`, `unit`, etc.)
- `scrapedAt` — UTC ISO timestamp

**Video-specific:**

- `youtubeId` + `youtubeUrl`
- `durationSeconds`
- `thumbnailUrl`
- `downloadUrls` — `{m3u8, mp4, mp4-low, mp4-low-ios, png}` direct CDN URLs
- `subtitleLanguages` — language codes with translated subtitles
- `authorNames`, `keywords`, `dateAdded`, `license`, `language`, `educationalLevel`

**Course-specific:**

- `unitCount`, `lessonCount`, `masteryEnabled`, `curriculumKey`, `iconUrl`

#### Sample video record

```json
{
  "id": "19647488",
  "slug": "negative-numbers-introduction",
  "kind": "Video",
  "title": "Intro to negative numbers",
  "description": "Mysterious negative numbers! What ARE they? ...",
  "youtubeId": "Hlal9ME2Aig",
  "youtubeUrl": "https://www.youtube.com/watch?v=Hlal9ME2Aig",
  "durationSeconds": 576,
  "thumbnailUrl": "https://cdn.kastatic.org/googleusercontent/...",
  "authorNames": ["Sal Khan"],
  "downloadUrls": {
    "m3u8": "https://cdn.kastatic.org/ka-youtube-converted/Hlal9ME2Aig.m3u8/Hlal9ME2Aig.m3u8",
    "mp4": "https://cdn.kastatic.org/ka-youtube-converted/Hlal9ME2Aig.mp4/Hlal9ME2Aig.mp4"
  },
  "dateAdded": "2011-02-20T16:51:16Z",
  "language": "en",
  "license": "cc-by-nc-sa",
  "url": "https://www.khanacademy.org/math/arithmetic-home/negative-numbers/neg-num-intro/v/negative-numbers-introduction",
  "subject": "math",
  "recordType": "video",
  "scrapedAt": "2026-05-21T09:17:47Z"
}
```

### Data source

Khan Academy is a non-profit educational organization that provides free, CC-licensed (CC-BY-NC-SA) lessons in math, science, the arts, computer programming, economics, and more.

This scraper hits Khan Academy's public GraphQL endpoints — the same ones used by their website. No login, cookies or API key are required, and the actor runs on the free Apify plan without any paid proxy add-ons.

### FAQ

**Does this require login or an API key?**
No. Khan Academy's content is freely accessible. The scraper uses public endpoints with no authentication.

**Do I need to provide a proxy?**
No. The scraper works from datacenter IPs out-of-the-box.

**What is the license of the returned data?**
Khan Academy content is licensed under CC-BY-NC-SA 3.0 unless otherwise noted. You can reuse it for non-commercial purposes with attribution. Verify the `license` field on each record.

**Can I get transcripts?**
Khan Academy stores subtitle files per language; the actor exposes the available subtitle languages in `subtitleLanguages`. To fetch the actual transcript bodies, follow up with the YouTube ID against the YouTube transcript API or KA's subtitles endpoint.

**Why are some titles different from what I see on the site?**
Khan Academy localizes content per visitor region. The actor uses the en/US locale by default.

**What if Khan Academy updates their GraphQL schema?**
The cacheable persisted queries are tied to a publish version (pcv) that the actor fetches dynamically. Search queries are sent as fully inlined GraphQL strings so they survive schema bumps that don't change field shape.

**Can I run this on the free Apify plan?**
Yes. No proxy, no add-ons, no user-supplied credentials needed.

# Actor input Schema

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

What to fetch.

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

Free-text query used in mode=search (e.g. `algebra`, `photosynthesis`, `python`).

## `subject` (type: `string`):

Root Khan Academy subject to list courses for.

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

Restrict mode=search or mode=topicBrowser to these subject roots. Leave empty to include all subjects.

## `contentKinds` (type: `array`):

Restrict mode=search to these content kinds.

## `paths` (type: `array`):

Khan Academy content paths (e.g. `math/algebra`, `math/algebra/x2f8bb11595b61c86:foundation-algebra/x2f8bb11595b61c86:negative-numbers/v/negative-numbers-introduction`).

## `urls` (type: `array`):

Full khanacademy.org URLs to videos, articles, exercises, courses or topics.

## `videoIds` (type: `array`):

YouTube video IDs (11-character) — looked up in Khan Academy's search index.

## `containsKeyword` (type: `string`):

Drop records whose title, description, slug or keywords do not contain this string (case-insensitive).

## `minDurationSeconds` (type: `integer`):

Drop videos shorter than this duration in seconds.

## `maxDurationSeconds` (type: `integer`):

Drop videos longer than this duration in seconds.

## `includeUnits` (type: `boolean`):

For mode=byPaths / byUrls on courses: emit one record per unit in addition to the course record.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "bySubject",
  "searchQuery": "algebra",
  "subject": "math",
  "subjects": [],
  "contentKinds": [
    "Video",
    "Article",
    "Exercise",
    "Topic"
  ],
  "paths": [],
  "urls": [],
  "videoIds": [],
  "includeUnits": false,
  "maxItems": 50
}
```

# Actor output Schema

## `content` (type: `string`):

Dataset containing all scraped Khan Academy records.

# 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 = {
    "mode": "bySubject",
    "searchQuery": "algebra",
    "subject": "math",
    "subjects": [],
    "contentKinds": [
        "Video",
        "Article",
        "Exercise",
        "Topic"
    ],
    "paths": [],
    "urls": [],
    "videoIds": [],
    "includeUnits": false,
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/khanacademy-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 = {
    "mode": "bySubject",
    "searchQuery": "algebra",
    "subject": "math",
    "subjects": [],
    "contentKinds": [
        "Video",
        "Article",
        "Exercise",
        "Topic",
    ],
    "paths": [],
    "urls": [],
    "videoIds": [],
    "includeUnits": False,
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/khanacademy-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 '{
  "mode": "bySubject",
  "searchQuery": "algebra",
  "subject": "math",
  "subjects": [],
  "contentKinds": [
    "Video",
    "Article",
    "Exercise",
    "Topic"
  ],
  "paths": [],
  "urls": [],
  "videoIds": [],
  "includeUnits": false,
  "maxItems": 50
}' |
apify call crawlerbros/khanacademy-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Khan Academy Scraper",
        "description": "Scrape Khan Academy with free CC-licensed educational content. Search by keyword, fetch by path/URL/subject, list all courses, look up videos by YouTube ID. Returns videos with download URLs, articles, exercises, courses and units.",
        "version": "1.0",
        "x-build-id": "UAIC6wGuayqnpdIur"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~khanacademy-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-khanacademy-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/crawlerbros~khanacademy-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-khanacademy-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/crawlerbros~khanacademy-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-khanacademy-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byPaths",
                            "byUrls",
                            "bySubject",
                            "topicBrowser",
                            "byVideoIds"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "bySubject"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text query used in mode=search (e.g. `algebra`, `photosynthesis`, `python`).",
                        "default": "algebra"
                    },
                    "subject": {
                        "title": "Root subject (mode=bySubject)",
                        "enum": [
                            "math",
                            "science",
                            "economics-finance-domain",
                            "humanities",
                            "computing",
                            "test-prep",
                            "ela",
                            "partner-content",
                            "college-careers-more",
                            "khan-for-educators",
                            "ai-activities"
                        ],
                        "type": "string",
                        "description": "Root Khan Academy subject to list courses for.",
                        "default": "math"
                    },
                    "subjects": {
                        "title": "Multi-select subjects",
                        "type": "array",
                        "description": "Restrict mode=search or mode=topicBrowser to these subject roots. Leave empty to include all subjects.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "math",
                                "science",
                                "economics-finance-domain",
                                "humanities",
                                "computing",
                                "test-prep",
                                "ela",
                                "partner-content",
                                "college-careers-more",
                                "khan-for-educators",
                                "ai-activities"
                            ],
                            "enumTitles": [
                                "Math",
                                "Science",
                                "Economics & Finance",
                                "Humanities & Arts",
                                "Computing",
                                "Test Prep",
                                "ELA",
                                "Partner Content",
                                "College, Careers & More",
                                "Khan for Educators",
                                "AI Activities"
                            ]
                        },
                        "default": []
                    },
                    "contentKinds": {
                        "title": "Content kinds (mode=search)",
                        "type": "array",
                        "description": "Restrict mode=search to these content kinds.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Video",
                                "Article",
                                "Exercise",
                                "Topic"
                            ],
                            "enumTitles": [
                                "Videos",
                                "Articles",
                                "Exercises",
                                "Topics"
                            ]
                        },
                        "default": [
                            "Video",
                            "Article",
                            "Exercise",
                            "Topic"
                        ]
                    },
                    "paths": {
                        "title": "Content paths (mode=byPaths)",
                        "type": "array",
                        "description": "Khan Academy content paths (e.g. `math/algebra`, `math/algebra/x2f8bb11595b61c86:foundation-algebra/x2f8bb11595b61c86:negative-numbers/v/negative-numbers-introduction`).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "urls": {
                        "title": "Full URLs (mode=byUrls)",
                        "type": "array",
                        "description": "Full khanacademy.org URLs to videos, articles, exercises, courses or topics.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "videoIds": {
                        "title": "YouTube video IDs (mode=byVideoIds)",
                        "type": "array",
                        "description": "YouTube video IDs (11-character) — looked up in Khan Academy's search index.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "containsKeyword": {
                        "title": "Filter: title/description contains",
                        "type": "string",
                        "description": "Drop records whose title, description, slug or keywords do not contain this string (case-insensitive)."
                    },
                    "minDurationSeconds": {
                        "title": "Min duration (videos, seconds)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop videos shorter than this duration in seconds."
                    },
                    "maxDurationSeconds": {
                        "title": "Max duration (videos, seconds)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop videos longer than this duration in seconds."
                    },
                    "includeUnits": {
                        "title": "Include unit records",
                        "type": "boolean",
                        "description": "For mode=byPaths / byUrls on courses: emit one record per unit in addition to the course record.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
