# Online Course Finder & Comparator (`trovevault/online-course-finder-comparator`) Actor

Find and compare online courses for a learner goal using public Coursera search pages and Skillshare class sitemap discovery. Produces ranked shortlist rows with buyingDecision, goalFitScore, valueForMoneyScore, confidenceTier, missingData and redFlags.

- **URL**: https://apify.com/trovevault/online-course-finder-comparator.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** Jobs, Social media, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 courses

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Online Course Finder & Comparator

Find and compare online courses for a specific learner goal. This actor searches public course platforms, extracts course metadata where available, and ranks course candidates by match, value, confidence, and practical trade-offs.

It is built for people and teams choosing what to learn, not for creators analyzing what to sell. For creator-side market research, use Course Market Gap Analyzer instead.

### What it does

Online Course Finder & Comparator helps answer questions like:

- Which course is the best fit for my learning goal?
- Which option looks like the best value?
- Which courses have enough public proof to trust?
- Which course is better for beginners, intermediate learners, or advanced users?
- What trade-offs should I check before buying or assigning a course?

The actor searches selected platforms from a learner goal and produces structured comparison rows that can be exported, scheduled, or connected to other Apify workflows.

### Input

Basic example:

```json
{
  "topic": "AI agents",
  "platforms": ["coursera", "skillshare"],
  "maxCoursesPerPlatform": 5,
  "learnerGoal": "Learn to build practical AI agent workflows for business automation",
  "experienceLevel": "intermediate",
  "budgetPreference": "best-value"
}
````

Team or procurement example:

```json
{
  "topic": "Python automation",
  "learnerGoal": "Automate repetitive reporting tasks with Python",
  "experienceLevel": "beginner",
  "decisionContext": "team training",
  "mustHaveCriteria": ["beginner-friendly", "hands-on projects", "under 10 hours"],
  "budgetPreference": "best-value"
}
```

### Input reference

| Field | Description |
| --- | --- |
| `topic` | Course topic or skill area to search. Use a concise phrase such as `AI agents`, `Python automation`, or `product analytics`. |
| `learnerGoal` | Practical learning outcome. This is the most important field for ranking because it explains what the learner needs to do after the course. |
| `platforms` | Course platforms to search. Current reliable public sources are `coursera` and `skillshare`. |
| `maxCoursesPerPlatform` | Maximum candidates to collect from each platform. Keep this small for fast shortlists; increase it for research. |
| `experienceLevel` | Optional learner level: `beginner`, `intermediate`, or `advanced`. |
| `decisionContext` | Optional context such as individual learning, team training, or procurement review. |
| `mustHaveCriteria` | Optional list of requirements such as certificate, project-based, short duration, or beginner-friendly. |
| `budgetPreference` | Optional ranking preference such as `best-value` or `lowest-price`. |
| `datasetId` | Optional Apify dataset ID to append rows into. |
| `runId` | Optional workflow identifier copied into output rows. |

### Output

Each dataset row represents a course candidate or a no-results recommendation when public discovery does not return enough data. Platform fetch issues are reported in the run summary, so blocked sources do not pollute the course shortlist.

Key fields include:

- `rank` - final recommendation order
- `buyingDecision` - plain-English decision such as shortlist, inspect manually, or lower priority
- `whyRankedHere` - the reason behind the recommendation rank
- `goalFitScore` - fit against the learner goal
- `valueForMoneyScore` - price-to-quality value signal
- `confidenceTier` and `dataConfidenceScore` - evidence strength based on available public metadata
- `recommendation` - short label such as Strong fit or Worth shortlisting
- `redFlags` - risks or missing proof to review before buying
- `missingData` - fields the public pages did not expose
- `nextAction` - what the learner or L\&D team should do next
- `bestFor` - learner profile the course appears best suited for
- `mainCaveat` and `tradeoffs` - what to verify before choosing
- `courseTitle`, `courseUrl`, `provider`, `platform`
- `rating`, `reviewCount`, `studentCount`, `price`, `currency`, `level`, `durationHours`

The output works well as a course shortlist for individuals, corporate L\&D teams, education researchers, and procurement workflows.

### Output example

```json
{
  "rank": 1,
  "buyingDecision": "shortlist",
  "recommendation": "Strong fit",
  "whyRankedHere": "High topic match, strong public proof, and practical fit for the stated learner goal.",
  "goalFitScore": 86,
  "valueForMoneyScore": 72,
  "dataConfidenceScore": 78,
  "confidenceTier": "medium",
  "courseTitle": "AI Agents for Business Automation",
  "courseUrl": "https://www.coursera.org/learn/example-course",
  "provider": "Example University",
  "platform": "coursera",
  "rating": 4.7,
  "reviewCount": 1200,
  "studentCount": null,
  "price": null,
  "currency": null,
  "level": "intermediate",
  "durationHours": 8,
  "bestFor": "Intermediate operators who want practical agent workflows",
  "mainCaveat": "Verify current price and certificate details on the course page.",
  "redFlags": [],
  "missingData": ["price"],
  "nextAction": "Open the course page and confirm syllabus, price, and certificate value.",
  "runId": "team-training-q3"
}
```

### API example

```bash
curl -X POST "https://api.apify.com/v2/acts/trovevault~online-course-finder-comparator/runs?waitForFinish=120" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "topic": "AI agents",
    "learnerGoal": "Learn to build practical AI agent workflows for business automation",
    "platforms": ["coursera", "skillshare"],
    "maxCoursesPerPlatform": 5
  }'
```

### Use cases

#### Individual learners

Compare courses before buying, especially when many marketplace results look similar.

#### Corporate L\&D teams

Build a shortlist of public courses for a skill area and export the results for review.

#### Managers and team leads

Find course options for a team member based on role, level, and outcome.

#### Education researchers

Collect structured comparison data for public course availability across platforms.

### How ranking works

The actor uses deterministic scoring:

- Topic and learner-goal overlap increase `goalFitScore`.
- Ratings, review counts, learner counts, detected level, and duration improve confidence.
- Budget preference changes how price affects `valueForMoneyScore`.
- Coursera is framed as stronger for certificates and structured programs, and unsupported sources are kept out of the default input until they return reliable data.

Scores are meant for shortlist building, not as a guarantee of course quality. Always inspect the final course page before purchasing or assigning training.

### Supported sources

The actor currently exposes public discovery from:

- Coursera search pages
- Skillshare public class sitemap

Udemy is intentionally not exposed in the input form right now because both its public search page GET requests and API endpoint returned Cloudflare challenge pages in HTTP tests. Skillshare search also blocks HTTP requests, so the actor uses the public class sitemap instead.

Some platforms personalize results, hide prices by region, or block automated requests. When a source blocks public HTTP discovery, the actor records the issue in `OUTPUT.sourceLog` and continues with the remaining sources.

### Limitations

The actor does not log in, purchase courses, bypass paywalls, or access private learner data. It only extracts public page metadata. Not every platform exposes all fields, so some rows may have missing price, duration, rating, or provider fields.

When structured course cards are unavailable, the actor falls back to page-level metadata where possible and records lower confidence.

### Troubleshooting

#### Few or no courses are returned

Use a broader `topic`, include both supported platforms, and keep the learner goal concrete. Very narrow goals may not match public course titles or descriptions.

#### Prices or duration are missing

Some platforms personalize price, hide subscription details, or omit duration from public cards. Check `missingData`, `confidenceTier`, and `mainCaveat` before making a purchase decision.

#### A platform appears blocked

Check `OUTPUT.sourceLog`. The actor keeps blocked or unreliable sources out of the shortlist and continues with the remaining public sources.

### Tips for best results

- Use a clear learner goal, not just a topic.
- Select `beginner`, `intermediate`, or `advanced` when level matters.
- Use `best-value` for balanced ranking or `lowest-price` for budget-sensitive searches.
- Use must-have criteria to tell the actor what actually matters, such as certificate, practical projects, or team suitability.
- Schedule recurring runs if you want to monitor changes in available courses or pricing.

### Integrations

Use `datasetId` to append results to an existing dataset and `runId` to trace rows through a larger workflow. The actor can be connected to dashboards, CSV exports, L\&D approval processes, spreadsheets, or follow-up analysis actors.

### FAQ

#### Does this buy or enroll in courses?

No. It only collects public course metadata and ranks candidates for review.

#### Is this for course creators?

No. This actor is learner-side. It helps choose courses. For creator-side market research, use a market gap or demand analysis actor.

#### Are rankings guaranteed?

No. Scores are deterministic shortlist signals based on public metadata and your learner goal. Always inspect the final course page before buying or assigning training.

#### Can I schedule it?

Yes. Use Apify schedules and optionally provide `datasetId` to append recurring results into the same dataset.

### Changelog

- `0.1`: Initial learner-side course finder with public discovery, ranking, trade-off analysis, `datasetId`, and `runId` support.

### Feedback and support

Open an Apify issue with the topic, learner goal, selected platforms, run ID, and any course you expected to appear.

# Actor input Schema

## `topic` (type: `string`):

Skill, subject, or course topic to search for. Example: AI agents, Python automation, Excel for finance, UX research. Use a specific phrase for cleaner course discovery.

## `learnerGoal` (type: `string`):

Outcome the learner or team wants after the course. Example: Build practical AI agent workflows for business automation in 4 weeks. This is used to rank fit and explain each recommendation.

## `decisionContext` (type: `string`):

Why you are choosing a course. The actor adapts recommendation language for an individual learner, career switcher, certification buyer, team training, or procurement shortlist.

## `experienceLevel` (type: `string`):

Current learner level. Choose beginner for first exposure, intermediate for practical builders, advanced for experienced practitioners, or any when level does not matter.

## `mustHaveCriteria` (type: `array`):

Selection requirements that matter most. The actor flags courses that appear to match or miss these criteria and explains missing evidence when public pages do not expose enough data.

## `budgetPreference` (type: `string`):

How price should affect ranking. Best overall value balances price and quality, cheapest first favors low cost, quality over price rewards proof signals, and free options first favors free or audit-friendly courses.

## `platforms` (type: `array`):

Course platforms to prospect. Coursera uses public search pages. Skillshare uses its public class sitemap because the search page blocks HTTP requests.

## `maxCoursesPerPlatform` (type: `integer`):

Maximum number of course candidates to keep from each platform. Use 3 to 10 for quick recommendations or 20 to 50 for broader L\&D research.

## `datasetId` (type: `string`):

Optional existing Apify dataset ID to append the same recommendation rows to, in addition to the default run dataset.

## `runId` (type: `string`):

Optional identifier copied to output rows for downstream tracing in larger workflows.

## Actor input object example

```json
{
  "topic": "AI agents",
  "learnerGoal": "Learn to build practical AI agent workflows for business automation",
  "decisionContext": "individual purchase",
  "experienceLevel": "intermediate",
  "mustHaveCriteria": [
    "hands-on projects"
  ],
  "budgetPreference": "best-value",
  "platforms": [
    "coursera",
    "skillshare"
  ],
  "maxCoursesPerPlatform": 5
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `summary` (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 = {
    "topic": "AI agents",
    "learnerGoal": "Learn to build practical AI agent workflows for business automation",
    "mustHaveCriteria": [
        "hands-on projects"
    ],
    "platforms": [
        "coursera",
        "skillshare"
    ],
    "maxCoursesPerPlatform": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/online-course-finder-comparator").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 = {
    "topic": "AI agents",
    "learnerGoal": "Learn to build practical AI agent workflows for business automation",
    "mustHaveCriteria": ["hands-on projects"],
    "platforms": [
        "coursera",
        "skillshare",
    ],
    "maxCoursesPerPlatform": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("trovevault/online-course-finder-comparator").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 '{
  "topic": "AI agents",
  "learnerGoal": "Learn to build practical AI agent workflows for business automation",
  "mustHaveCriteria": [
    "hands-on projects"
  ],
  "platforms": [
    "coursera",
    "skillshare"
  ],
  "maxCoursesPerPlatform": 5
}' |
apify call trovevault/online-course-finder-comparator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=trovevault/online-course-finder-comparator",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Online Course Finder & Comparator",
        "description": "Find and compare online courses for a learner goal using public Coursera search pages and Skillshare class sitemap discovery. Produces ranked shortlist rows with buyingDecision, goalFitScore, valueForMoneyScore, confidenceTier, missingData and redFlags.",
        "version": "0.1",
        "x-build-id": "ZTEdtaUYalL1OhZ7O"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~online-course-finder-comparator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-online-course-finder-comparator",
                "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/trovevault~online-course-finder-comparator/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-online-course-finder-comparator",
                "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/trovevault~online-course-finder-comparator/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-online-course-finder-comparator",
                "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": [
                    "topic",
                    "learnerGoal",
                    "platforms"
                ],
                "properties": {
                    "topic": {
                        "title": "What do you want to learn?",
                        "type": "string",
                        "description": "Skill, subject, or course topic to search for. Example: AI agents, Python automation, Excel for finance, UX research. Use a specific phrase for cleaner course discovery.",
                        "default": "AI agents"
                    },
                    "learnerGoal": {
                        "title": "Learning goal",
                        "type": "string",
                        "description": "Outcome the learner or team wants after the course. Example: Build practical AI agent workflows for business automation in 4 weeks. This is used to rank fit and explain each recommendation."
                    },
                    "decisionContext": {
                        "title": "Decision context",
                        "enum": [
                            "individual purchase",
                            "career switch",
                            "certification prep",
                            "team training",
                            "procurement shortlist"
                        ],
                        "type": "string",
                        "description": "Why you are choosing a course. The actor adapts recommendation language for an individual learner, career switcher, certification buyer, team training, or procurement shortlist.",
                        "default": "individual purchase"
                    },
                    "experienceLevel": {
                        "title": "Experience level",
                        "enum": [
                            "any",
                            "beginner",
                            "intermediate",
                            "advanced"
                        ],
                        "type": "string",
                        "description": "Current learner level. Choose beginner for first exposure, intermediate for practical builders, advanced for experienced practitioners, or any when level does not matter.",
                        "default": "intermediate"
                    },
                    "mustHaveCriteria": {
                        "title": "Must-have criteria",
                        "type": "array",
                        "description": "Selection requirements that matter most. The actor flags courses that appear to match or miss these criteria and explains missing evidence when public pages do not expose enough data.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "certificate",
                                "hands-on projects",
                                "beginner-friendly",
                                "advanced depth",
                                "under 10 hours",
                                "free or audit option",
                                "recognized provider",
                                "team suitable"
                            ],
                            "enumTitles": [
                                "Certificate",
                                "Hands-on projects",
                                "Beginner-friendly",
                                "Advanced depth",
                                "Under 10 hours",
                                "Free or audit option",
                                "Recognized provider",
                                "Team suitable"
                            ]
                        },
                        "default": [
                            "hands-on projects"
                        ]
                    },
                    "budgetPreference": {
                        "title": "Budget preference",
                        "enum": [
                            "best-value",
                            "lowest-price",
                            "premium-ok",
                            "free-first"
                        ],
                        "type": "string",
                        "description": "How price should affect ranking. Best overall value balances price and quality, cheapest first favors low cost, quality over price rewards proof signals, and free options first favors free or audit-friendly courses.",
                        "default": "best-value"
                    },
                    "platforms": {
                        "title": "Platforms to search",
                        "minItems": 1,
                        "type": "array",
                        "description": "Course platforms to prospect. Coursera uses public search pages. Skillshare uses its public class sitemap because the search page blocks HTTP requests.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "coursera",
                                "skillshare"
                            ],
                            "enumTitles": [
                                "Coursera",
                                "Skillshare"
                            ]
                        },
                        "default": [
                            "coursera",
                            "skillshare"
                        ]
                    },
                    "maxCoursesPerPlatform": {
                        "title": "Max courses per platform",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of course candidates to keep from each platform. Use 3 to 10 for quick recommendations or 20 to 50 for broader L&D research.",
                        "default": 5
                    },
                    "datasetId": {
                        "title": "Dataset ID",
                        "type": "string",
                        "description": "Optional existing Apify dataset ID to append the same recommendation rows to, in addition to the default run dataset."
                    },
                    "runId": {
                        "title": "Run ID",
                        "type": "string",
                        "description": "Optional identifier copied to output rows for downstream tracing in larger workflows."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
