# MIT OpenCourseWare Scraper | Free MIT Course Data (`parseforge/mit-ocw-scraper`) Actor

Pull MIT OpenCourseWare courses with title, instructor, department, level, semester, syllabus, lecture notes, problem sets, exams, and video URLs. Build free education datasets, study tools, and AI training corpora using world-class material from MIT, all openly licensed.

- **URL**: https://apify.com/parseforge/mit-ocw-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Education, For creators, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🎓 MIT OpenCourseWare Scraper

> 🚀 **Export MIT's entire free course catalog in seconds.** Search by topic, department, or level and get structured data on 2,500+ world-class MIT courses.

> 🕒 **Last updated:** 2026-05-21 · **📊 16 fields** per record · **2,500+ courses** · **Global coverage**

MIT OpenCourseWare (OCW) is one of the world's most prestigious free educational resources, offering course materials from nearly every MIT department. This actor connects directly to the OCW search API and extracts structured course data in real time - no browser required, no login needed.

The dataset covers undergraduate and graduate courses from all 30+ MIT departments, spanning engineering, mathematics, science, humanities, economics, and more. Every record includes instructor names, topics, course level, and feature flags for videos, problem sets, and exams.

**Coverage:** 2,500+ courses from 30+ departments. Undergraduate, graduate, and non-credit levels. All MIT subject areas.

### Target Audience / Use Cases

| Who | What they build |
|-----|-----------------|
| EdTech developers | Course recommendation engines, curriculum mapping tools |
| Researchers | Academic dataset analysis, learning outcome studies |
| Data journalists | Reports on STEM education, free learning resources |
| Students and learners | Discover MIT courses by topic or department |

### 📋 What the MIT OCW Scraper does

- Searches MIT OpenCourseWare by keyword, topic, or department
- Filters by academic level (undergraduate, graduate)
- Extracts instructor names, departments, course numbers, and full topic trees
- Flags which courses include lecture videos, problem sets, or exams
- Returns direct course URLs for immediate access
- Paginates automatically through all matching results

> 💡 **Why it matters:** MIT OpenCourseWare is completely free and has no paywall. This actor makes the entire catalog machine-readable and ready for integration into any application or pipeline.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `searchQuery` | string | Search term to find courses (e.g. "machine learning", "calculus") | `machine learning` |
| `maxItems` | number | Maximum courses to return. Free: 10, Paid: up to 1,000,000 | `10` |
| `department` | string | Filter by department name (e.g. "Electrical Engineering and Computer Science") | - |
| `level` | select | Filter by academic level | All Levels |

**Example - Search by topic:**
```json
{
  "searchQuery": "machine learning",
  "maxItems": 50
}
````

**Example - Filter by department and level:**

```json
{
  "searchQuery": "algorithms",
  "department": "Electrical Engineering and Computer Science",
  "level": "graduate",
  "maxItems": 100
}
```

> ⚠️ **Good to Know:** Free users are limited to 10 courses per run. [Upgrade to paid](https://console.apify.com/sign-up?fpr=vmoqkp) to access the full catalog of 2,500+ courses.

### 📊 Output

Each record contains 16 fields:

| Field | Type | Description |
|-------|------|-------------|
| 🖼️ `imageUrl` | string | Course thumbnail image URL |
| 📚 `title` | string | Course title |
| 👩‍🏫 `instructors` | array | List of instructor names |
| 🏛️ `department` | string | MIT department name |
| 🔢 `courseNumber` | string | MIT course number (e.g. "6.867") |
| 🔗 `url` | string | Direct URL to the course on OCW |
| 🎓 `level` | string | Academic level (Undergraduate / Graduate / Non-Credit) |
| 🏷️ `topics` | array | All topic tags for the course |
| 📹 `hasVideo` | boolean | Whether course includes lecture videos |
| 📝 `hasProblemSets` | boolean | Whether course includes problem sets |
| 📋 `hasExams` | boolean | Whether course includes exams |
| 📅 `lastModified` | string | When the course was added to OCW (ISO 8601) |
| 🗓️ `term` | string | Semester (Fall / Spring / January IAP) |
| 📆 `year` | number | Academic year |
| ⏱️ `scrapedAt` | string | Timestamp of data collection |
| ❌ `error` | string/null | Error message if scraping failed |

**Sample record:**

```json
{
  "imageUrl": "https://ocw.mit.edu/courses/6-867-machine-learning-fall-2006/6fc42e1b17babba77f04228a00b1e110_6-867f06.jpg",
  "title": "Machine Learning",
  "instructors": [
    "Prof. Tommi Jaakkola",
    "Ali Mohammad",
    "Rohit Singh"
  ],
  "department": "Electrical Engineering and Computer Science",
  "courseNumber": "6.867",
  "url": "https://ocw.mit.edu/courses/6-867-machine-learning-fall-2006",
  "level": "Graduate",
  "topics": [
    "Engineering",
    "Science",
    "Computer Science",
    "Artificial Intelligence",
    "Mathematics",
    "Probability and Statistics",
    "Cognitive Science",
    "Algorithms and Data Structures"
  ],
  "hasVideo": false,
  "hasProblemSets": true,
  "hasExams": true,
  "lastModified": "2020-03-03T20:45:06.944239Z",
  "term": "Fall",
  "year": 2006,
  "scrapedAt": "2026-05-22T01:39:36.199Z",
  "error": null
}
```

### ✨ Why choose this Actor

| Feature | Benefit |
|---------|---------|
| 🆓 Completely free source | No paywalls, no subscriptions, no logins needed |
| ⚡ Real-time API | Data is always fresh - no stale caches |
| 🔍 Full-text search | Finds courses by topic, concept, or keyword |
| 🏷️ Rich metadata | 16 fields including topics, instructors, feature flags |
| 🎓 2,500+ courses | Covers the entire MIT OCW catalog |
| 🔢 Accurate course numbers | MIT-style numbering (6.867, 18.657, etc.) |
| 📹 Feature detection | Instantly identify courses with videos, problem sets, exams |

### 📈 How it compares to alternatives

| Feature | This Actor | Manual browsing | Other scrapers |
|---------|-----------|-----------------|----------------|
| Structured JSON output | ✅ | ❌ | Partial |
| Full topic tree | ✅ | ❌ | Rare |
| Instructor names | ✅ | Manual | Rare |
| Feature flags (video/exams) | ✅ | Manual | ❌ |
| Pagination support | ✅ | Manual | Partial |
| Free to run | ✅ | ✅ | Varies |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 credit)
2. Open the **MIT OpenCourseWare Scraper** actor
3. Enter a search query (e.g. "machine learning", "thermodynamics")
4. Optionally filter by department or level
5. Set your `maxItems` limit
6. Click **Start** and download results as JSON, CSV, or Excel

### 💼 Business use cases

#### EdTech Platform Development

Build course recommendation systems by using MIT OCW data as a training dataset. Match users' learning goals to relevant MIT courses based on topics, level, and available materials.

#### Academic Research and Analysis

Analyze trends in MIT's curriculum over time. Track which topics appear most frequently across departments, or identify gaps in available course materials.

#### Learning Path Automation

Combine this actor with Coursera or Udemy scrapers to create multi-platform learning paths. MIT OCW provides foundational academic content while other platforms offer certifications.

#### Content Aggregation and SEO

Build educational resource directories that surface free MIT content alongside paid alternatives. MIT OCW's reputation makes it a high-quality anchor for any learning portal.

### 🔌 Automating MIT OCW Scraper

Connect this actor to your favorite automation tools:

- **Make (formerly Integromat):** Trigger a course collection run on a schedule and pipe results to Google Sheets or Airtable
- **Zapier:** Send new course discoveries to Slack, Notion, or any CRM
- **Apify Scheduler:** Run weekly to catch newly published courses
- **REST API:** Call directly from your application using the Apify API

### 🌟 Beyond business use cases

#### Academic Research

Study the evolution of computer science curricula at MIT. Analyze which topics have gained or lost prominence across decades of course offerings.

#### Creative Projects

Build a "random MIT course" discovery app, or create personalized MIT study plans based on career goals and current knowledge.

#### Non-profit and Education Access

Help underserved communities find free, high-quality MIT content. Use topic filtering to surface courses relevant to specific workforce development programs.

#### Experimentation and Learning

Practice data analysis with a clean, structured dataset from one of the world's most respected universities.

### 🤖 Ask an AI assistant about this scraper

You can ask Claude, ChatGPT, or any AI assistant: "What can I do with MIT OpenCourseWare course data?" or "How do I filter MIT courses by department using the Apify API?" - and point it to this actor's documentation for context.

### ❓ Frequently Asked Questions

**🎓 Is MIT OpenCourseWare really free?**
Yes. OCW is completely free and requires no login or registration. All course materials are openly licensed.

**📦 How many courses does it cover?**
The MIT OCW catalog contains 2,500+ courses across all MIT departments.

**🔍 Can I search by topic like "machine learning" or "quantum mechanics"?**
Yes. The `searchQuery` field supports full-text search across course titles, descriptions, and topic tags.

**🏛️ Can I filter by department?**
Yes. Use the `department` field with the exact department name (e.g. "Electrical Engineering and Computer Science" or "Mathematics").

**🎓 Can I get only undergraduate or only graduate courses?**
Yes. Set `level` to "undergraduate" or "graduate" to filter results.

**📹 How do I find courses with lecture videos?**
Query normally and filter output by `hasVideo: true`. Courses with lecture videos are clearly flagged in the output.

**📊 What format can I export data in?**
JSON, CSV, Excel, XML, HTML - all standard Apify dataset export formats.

**⏱️ How long does a run take?**
A run returning 100 courses typically completes in under 10 seconds. The OCW API responds quickly.

**🔄 Is the data real-time?**
Yes. Every run fetches fresh data directly from the MIT OCW API. No caching.

**🌐 Does it work without a proxy?**
Yes. MIT OCW is a public educational site with no bot protection. No proxy required.

**💰 What's the cost?**
Free users get 10 courses per run. Paid users can retrieve up to 1,000,000 courses. See Apify pricing for platform costs.

**🔗 Can I get the full course URL?**
Yes. Every record includes a direct `url` field linking to the course on ocw.mit.edu.

### 🔌 Integrate with any app

Export MIT OCW data to:

| Platform | Use |
|----------|-----|
| Google Sheets | Spreadsheet analysis |
| Airtable | Database and CRM |
| Notion | Knowledge management |
| Slack | Team notifications |
| Zapier | Workflow automation |
| Make | Advanced integrations |
| REST API | Custom application integration |
| Webhooks | Real-time event triggers |

### 🔗 Recommended Actors

| Actor | Description |
|-------|-------------|
| [Coursera Scraper](https://apify.com/parseforge/coursera-scraper) | Scrape Coursera courses with ratings, enrollment counts, and difficulty levels |
| [Udemy Scraper](https://apify.com/parseforge/udemy-scraper) | Extract Udemy courses with pricing, reviews, and instructor data |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for scrapers covering 100+ websites across education, e-commerce, finance, and more.

***

*This actor is not affiliated with or endorsed by MIT or MIT OpenCourseWare. All data is sourced from publicly available information on ocw.mit.edu. Use responsibly and in accordance with MIT OCW's terms of service.*

# Actor input Schema

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

Search term to find courses (e.g. 'machine learning', 'calculus', 'physics')

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `department` (type: `string`):

Filter by department name (e.g. 'Electrical Engineering and Computer Science', 'Mathematics')

## `level` (type: `string`):

Filter by course level

## Actor input object example

```json
{
  "searchQuery": "machine learning",
  "maxItems": 10,
  "level": ""
}
```

# Actor output Schema

## `results` (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 = {
    "searchQuery": "machine learning",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/mit-ocw-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 = {
    "searchQuery": "machine learning",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/mit-ocw-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 '{
  "searchQuery": "machine learning",
  "maxItems": 10
}' |
apify call parseforge/mit-ocw-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MIT OpenCourseWare Scraper | Free MIT Course Data",
        "description": "Pull MIT OpenCourseWare courses with title, instructor, department, level, semester, syllabus, lecture notes, problem sets, exams, and video URLs. Build free education datasets, study tools, and AI training corpora using world-class material from MIT, all openly licensed.",
        "version": "0.1",
        "x-build-id": "mkGAt9p8o1ePcZvlB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~mit-ocw-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-mit-ocw-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/parseforge~mit-ocw-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-mit-ocw-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/parseforge~mit-ocw-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-mit-ocw-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": [
                    "searchQuery"
                ],
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search term to find courses (e.g. 'machine learning', 'calculus', 'physics')"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "department": {
                        "title": "Department",
                        "type": "string",
                        "description": "Filter by department name (e.g. 'Electrical Engineering and Computer Science', 'Mathematics')"
                    },
                    "level": {
                        "title": "Level",
                        "enum": [
                            "",
                            "undergraduate",
                            "graduate"
                        ],
                        "type": "string",
                        "description": "Filter by course level",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```