# Ranked MBA & EMBA Deadline Finder (`trovevault/ranked-mba-emba-deadline-finder`) Actor

Finds current MBA and EMBA application deadlines from official business school pages. Filter by region, country, and program type for applicant and admissions consulting workflows.

- **URL**: https://apify.com/trovevault/ranked-mba-emba-deadline-finder.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** Jobs, News, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 mbas

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

## Ranked MBA & EMBA Deadline Finder

Find current MBA and Executive MBA application deadlines from official business school pages for ranked school cohorts. The actor uses ranking lists as a school universe, then checks each selected school on demand and returns clean application-round rows.

It is built for admissions consultants, MBA applicants, education platforms, and research teams that need regional deadline trackers without manually checking dozens of school websites.

### Why Use This Actor

- Monitor ranked MBA and EMBA programs by region, country, and program type
- Normalize application rounds, deadlines, decision dates, and deadline status
- Build applicant shortlists and consultant dashboards
- Schedule recurring checks for upcoming admissions cycles
- Append results to an existing dataset with `datasetId`

### What It Produces

The dataset contains one row per parsed program round. Public rows do not include source URLs. Source evidence and failed pages are kept in the run summary for operational review.

Typical fields include school name, program name, program type, ranking cohort, ranking band, city, country, intake year, round name, application deadline, decision date, deposit deadline, days until deadline, deadline status, verification status, and optional `runId`.

### Supported Coverage

The first release includes a curated ranked-school seed list covering leading MBA and EMBA programs from FT Global MBA, FT European Business Schools, QS Global MBA, and regional accredited-school research. Rankings and directories define the internal school universe only. Deadline values are collected from official school pages.

Coverage will improve as more school-specific parser rules are added. If a school page cannot be parsed with enough confidence, the actor records it in `RUN_SUMMARY` instead of emitting a misleading dataset row.

### Limitations

- The actor does not claim complete global MBA coverage.
- It does not scrape login-only application portals.
- It does not expose source URLs in the public dataset.
- Some schools publish only month-level or tentative dates; those are skipped until a full date is available.
- Executive education short courses are out of scope for this actor.

### Input Example

```json
{
  "regions": ["Europe"],
  "programTypes": ["MBA", "EMBA"],
  "countries": ["Portugal", "Czech Republic"]
}
````

### Output Example

```json
{
  "schoolName": "INSEAD",
  "programName": "MBA",
  "programType": "MBA",
  "rankingCohort": "ft_global_mba",
  "rankingBand": "Top 25",
  "city": "Fontainebleau / Singapore",
  "country": "France",
  "region": "Europe",
  "intakeYear": null,
  "roundName": "Round 4",
  "applicationDeadline": "2026-08-04",
  "decisionDate": "2026-09-04",
  "depositDeadline": null,
  "daysUntilDeadline": 84,
  "deadlineStatus": "upcoming",
  "verificationStatus": "official_confirmed",
  "changeStatus": "not_compared",
  "changedFields": null,
  "programFormat": "full_time",
  "runId": null
}
```

### Input Reference

- `regions`: regions to search.
- `programTypes`: `MBA` and/or `EMBA`.
- `countries`: optional country-name filter.
- `datasetId`: append results to another Apify dataset.
- `runId`: copy a workflow identifier into every row.

### API Usage

```bash
curl "https://api.apify.com/v2/acts/trovevault~ranked-mba-emba-deadline-finder/runs?waitForFinish=120" \
  -X POST \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"regions":["Europe"],"programTypes":["MBA","EMBA"],"countries":["Portugal"]}'
```

### FAQ

**Does this actor ask users to choose rankings?**\
No. Rankings and directories are internal coverage inputs. Users choose the region, program type, and optional country.

**Why are source URLs not in the dataset?**\
The public dataset is designed for applicant and consultant workflows. Source evidence is kept in run metadata instead.

**Can I monitor only Europe?**\
Yes. Set `regions` to `["Europe"]`.

**What happens when a page cannot be parsed?**\
The actor records the issue in `RUN_SUMMARY` and avoids emitting an uncertain deadline row.

**Does it cover short executive education courses?**\
No. The launch scope is MBA and EMBA admissions deadlines.

**Can this run on a schedule?**\
Yes. Schedule the actor and use `datasetId` to append rows into a long-term monitoring dataset.

### Troubleshooting

If a run returns fewer rows than expected, check `RUN_SUMMARY` for schools with `no_deadlines_found` or `fetch_failed`. Try a broader region or remove the country filter if the selected country has limited supported coverage.

### Related Actors

- Academic conference CFP and registration monitors
- Professional sports results and classifications actors
- Mobile app market intelligence actors

### Changelog

- `0.1`: Initial ranked MBA and EMBA deadline finder with official-page parsing and curated school seed list.

### Support

Open an Apify issue or contact TroveVault with the school, program, and admissions page you expected to be covered.

# Actor input Schema

## `regions` (type: `array`):

Regions to search for MBA and Executive MBA deadlines. Choose the geography you care about; the actor decides which ranked and accredited business schools to check inside that region.

## `programTypes` (type: `array`):

Program types to include. Use MBA for full-time MBA programs, EMBA for Executive MBA programs, or both when building a regional admissions calendar.

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

Optional country filter using country names such as Portugal, Czech Republic, France, Spain, United Kingdom, or United States. Leave empty to search every supported country in the selected regions.

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

ID of an existing Apify dataset to append results to in addition to the default run dataset. Use this for scheduled monitoring pipelines that combine several runs.

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

Optional workflow identifier copied into each output row so downstream tools can connect deadline rows to a client, campaign, or monitoring batch.

## Actor input object example

```json
{
  "regions": [
    "Europe"
  ],
  "programTypes": [
    "MBA",
    "EMBA"
  ]
}
```

# Actor output Schema

## `dataset` (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 = {
    "regions": [
        "Europe"
    ],
    "programTypes": [
        "MBA",
        "EMBA"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/ranked-mba-emba-deadline-finder").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 = {
    "regions": ["Europe"],
    "programTypes": [
        "MBA",
        "EMBA",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("trovevault/ranked-mba-emba-deadline-finder").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 '{
  "regions": [
    "Europe"
  ],
  "programTypes": [
    "MBA",
    "EMBA"
  ]
}' |
apify call trovevault/ranked-mba-emba-deadline-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ranked MBA & EMBA Deadline Finder",
        "description": "Finds current MBA and EMBA application deadlines from official business school pages. Filter by region, country, and program type for applicant and admissions consulting workflows.",
        "version": "0.1",
        "x-build-id": "KaAWzTs1JwnQe58Im"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~ranked-mba-emba-deadline-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-ranked-mba-emba-deadline-finder",
                "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~ranked-mba-emba-deadline-finder/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-ranked-mba-emba-deadline-finder",
                "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~ranked-mba-emba-deadline-finder/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-ranked-mba-emba-deadline-finder",
                "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": [
                    "regions",
                    "programTypes"
                ],
                "properties": {
                    "regions": {
                        "title": "Regions",
                        "type": "array",
                        "description": "Regions to search for MBA and Executive MBA deadlines. Choose the geography you care about; the actor decides which ranked and accredited business schools to check inside that region.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "North America",
                                "Europe",
                                "Asia-Pacific",
                                "Middle East",
                                "Latin America",
                                "Africa"
                            ],
                            "enumTitles": [
                                "North America",
                                "Europe",
                                "Asia-Pacific",
                                "Middle East",
                                "Latin America",
                                "Africa"
                            ]
                        },
                        "default": [
                            "Europe"
                        ]
                    },
                    "programTypes": {
                        "title": "Program Types",
                        "type": "array",
                        "description": "Program types to include. Use MBA for full-time MBA programs, EMBA for Executive MBA programs, or both when building a regional admissions calendar.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "MBA",
                                "EMBA"
                            ],
                            "enumTitles": [
                                "MBA",
                                "Executive MBA"
                            ]
                        },
                        "default": [
                            "MBA",
                            "EMBA"
                        ]
                    },
                    "countries": {
                        "title": "Countries (optional)",
                        "type": "array",
                        "description": "Optional country filter using country names such as Portugal, Czech Republic, France, Spain, United Kingdom, or United States. Leave empty to search every supported country in the selected regions.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "datasetId": {
                        "title": "Dataset ID (optional)",
                        "type": "string",
                        "description": "ID of an existing Apify dataset to append results to in addition to the default run dataset. Use this for scheduled monitoring pipelines that combine several runs."
                    },
                    "runId": {
                        "title": "Run ID (optional)",
                        "type": "string",
                        "description": "Optional workflow identifier copied into each output row so downstream tools can connect deadline rows to a client, campaign, or monitoring batch."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
