# Unstop Competitions Scraper (`automation-lab/unstop-public-opportunities`) Actor

Export public Unstop competitions with organizer, posting metadata, visible registration deadlines, closing windows, eligibility and canonical URLs for student opportunity research. Bounded pagination; no account required.

- **URL**: https://apify.com/automation-lab/unstop-public-opportunities.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.58 / 1,000 item extracteds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Unstop Competitions Scraper

Export public **Unstop competitions** listings for student opportunity research and recurring campus opportunity feeds. Each row includes a stable opportunity ID, title, organizer, posting metadata, visible registration deadline and closing-window text, category, eligibility labels and canonical link.

This Actor reads competition listing pages. It does not apply for opportunities, access accounts, submit forms, or fetch private information. Jobs, internships, standalone hackathon boards, scholarships and other opportunity types are outside this release.

### Who is it for?

- Student advisers building a competition calendar.
- Campus communities collecting public opportunities for a reviewed newsletter.
- Researchers comparing organizers and registration windows across repeated snapshots.

### Why use it?

The dataset has one row per unique public competition. Stable source IDs make snapshots easy to compare. Hidden deadlines stay null instead of being guessed from event-end dates. Source status and closing-window labels remain separate, because a listing marked LIVE can have an ended registration window.

The Actor is deliberately narrow: it exports the listing metadata needed for a campus opportunity feed, without downloading banners, adding account dependencies or sending records to an AI provider.

### Getting started

1. Choose the maximum number of competition rows you want.
2. Set a page budget. The source returns 10 raw listings per page, some of which may be excluded as non-public or duplicate.
3. Run the Actor and open the Competitions dataset view.
4. Export JSON or CSV, or connect the dataset to your own workflow.
5. Check the source link and eligibility rules before sharing an opportunity.

Example input:

```json
{"maxItems":20,"maxPages":3}
```

### Inputs

| Input | Default | Meaning |
|---|---:|---|
| maxItems | 100 | Global maximum unique public competition rows, 1–10000. Zero is invalid. |
| maxPages | 10 | Fetch at most this many pages starting at page 1, 1–1000. |

The run stops when the record limit, page limit or source exhaustion is reached. There is no unlimited mode. A page contains at most 10 upstream records; exclusions can reduce delivered results. For example, maxItems=100 with maxPages=1 may return fewer than 10 rows.

There is no keyword search, custom URL input, date filter, status filter or open-only filter. Unsupported input fields fail validation rather than being silently ignored. Page order is the source's returned order; newest-first ordering and complete historical coverage are not guaranteed.

### Extracted fields

| Field | Meaning |
|---|---|
| opportunityId | Stable public Unstop ID represented as a string. |
| title | Public competition title. |
| organizer | Disclosed organization name; null when absent. |
| category | Source type, always competitions in this release. |
| url | Canonical public competition URL. |
| postedDate | Source approved\_date metadata, preserved verbatim. Not necessarily ISO formatted. |
| updatedAt | Source last-update timestamp when present. |
| registrationDeadline | Registration end timestamp only when the source marks the deadline visible. |
| closingWindow | Source remaining-time text, including Ended; not recalculated. |
| status | Source listing status. LIVE does not imply open registration. |
| mode | Source region or mode such as online. |
| eligibility | Visible eligibility labels, not the full admission rules. |
| scrapedAt | Extraction timestamp in UTC. |

### Output example

A representative public listing returned during development:

```json
{
  "opportunityId": "1720769",
  "title": "iCEO : The Gamified Business Development Competition (July Edition - MBA)",
  "organizer": "Gogo Pogo",
  "category": "competitions",
  "url": "https://unstop.com/competitions/iceo-the-gamified-business-development-competition-july-edition-mba-gogo-pogo-1720769",
  "postedDate": "2026-07-20 09:41:05 GMT+0530",
  "updatedAt": "2026-07-20T09:41:05+05:30",
  "registrationDeadline": "2026-07-25T00:00:00+05:30",
  "closingWindow": "Ended",
  "status": "LIVE",
  "mode": "online",
  "eligibility": ["Postgraduate", "Management"],
  "scrapedAt": "2026-10-01T06:10:00.000Z"
}
```

The extraction timestamp is illustrative. Dates are source metadata, not promises of availability. Missing fields are null or an empty eligibility array.

### How much does it cost to collect Unstop competitions?

Pay-per-event pricing has a $0.002 start event and one item event per saved competition. Spend tiers follow qualifying aggregate monthly Apify Store spend, not the number of competitions collected from this Actor.

| Spend tier | Price per competition |
|---|---:|
| FREE | $0.003036 |
| BRONZE | $0.00264 |
| SILVER | $0.0020592 |
| GOLD | $0.001584 |
| PLATINUM | $0.001584 |
| DIAMOND | $0.001584 |

At BRONZE, 20 competitions cost approximately $0.0548, 100 cost $0.266, and 1000 cost $2.642 including the start event. Your actual price depends on the applicable spend tier and delivered record count.

Failed, duplicate, private and rejected source rows are not item-charged. The start event is charged after valid input is accepted, including a valid run that finds no public results. Budget controls can stop collection before the requested record limit.

Cost examples are estimates rather than guaranteed invoices. Refunds, fraud, disputes, taxes, corrections and contractual clawbacks can affect finalized amounts or payouts. No external paid API account or proxy is required. No undisclosed off-platform payment is used.

### Tips and limitations

Use a moderate page budget first. The underlying public endpoint can change, limit or reorder listings. The feed may contain older or ended competitions and does not prove that an opportunity is accepting entries. Always follow the canonical link before making an eligibility or registration decision.

Only public competitions are delivered. The Actor does not enrich details, awards, contact information or admission rules. It does not create alerts or compare snapshots itself. A schedule reruns the feed; any downstream change comparison belongs to your workflow.

### Integrations

- Export CSV to a spreadsheet and sort registrationDeadline, checking null values separately.
- Schedule runs in Apify, then compare opportunityId and updatedAt in your own database.
- Connect a dataset webhook to Make, Zapier or n8n for a reviewed campus digest.
- Use canonical URLs in your student portal rather than republishing application instructions without checking them.

### API usage

Replace the token placeholder with your own Apify credential. Keep it private.

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~unstop-public-opportunities/runs' \
  -H 'Authorization: Bearer YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"maxItems":20,"maxPages":3}'
```

The asynchronous response identifies a run and its default dataset. Wait for the run to finish before exporting its items.

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/unstop-public-opportunities').call({maxItems:20,maxPages:3});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/unstop-public-opportunities').call(run_input={'maxItems':20,'maxPages':3})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

### MCP

For Claude Code, add the Actor-specific Apify endpoint:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/unstop-public-opportunities"
```

For Claude Desktop, Cursor, and VS Code, use the equivalent remote HTTP configuration supported by your client:

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com?tools=automation-lab/unstop-public-opportunities"}}}
```

Authenticate with your Apify account when requested. Client configuration formats can differ. Example prompts: “Collect 20 public Unstop competitions from at most 3 pages”; “Summarize the returned organizers and show which records have a visible registration deadline.” Missing deadlines must not be inferred.

### Legality and data handling

Unstop is named to identify the source. This Actor is independently operated and is not affiliated with or endorsed by Unstop. Use collected data responsibly and comply with applicable law, source rights and Apify's standard user terms. Public availability does not authorize spam or unrestricted republication.

The Actor collects public opportunity metadata and organization names, not applicant profiles, email addresses or account data. It uses no runtime AI and sends no input or scraped records to an AI service. Processing uses Unstop's public endpoint and Apify hosting/storage. No proxy or additional paid recipient is enabled. Generated icon artwork is only a Store asset, not runtime AI processing.

Results and logs remain in your Apify run storage under your account's retention settings until deletion or expiration. The Actor creates no global cache, persistent session or external backup and does not set a separate retention period. Delete run datasets and logs through your account when no longer needed. Logs contain counters and request failure reasons, not full response bodies, tokens or applicant data.

### Troubleshooting

A malformed limit fails before extraction. A denied, non-JSON or malformed upstream response fails the run instead of pretending the feed is empty. Temporary network failures, 429 and 5xx responses receive at most three attempts. No paid proxy fallback occurs.

A failed run may have partial results from earlier pages. Check run status as well as dataset count. A legitimate empty public page can return zero records, with the start event still applicable. Increasing a page budget does not fix access denial.

### FAQ

**Why are some deadlines missing?** The source may omit or hide registration deadlines. They are not substituted with event end dates.

**Why does LIVE appear with Ended?** Listing status and registration status are distinct source signals. The Actor preserves that distinction.

**Can I search by keyword or fetch internship listings?** Not in this release. Input supports only bounded competition feed collection.

**Can I monitor changes?** Schedule snapshots and compare their stable IDs in your own integration. Built-in change alerts are not included.

### Related Actors

For a different source of student competitions, see our [Devpost Scraper](https://apify.com/automation-lab/devpost-scraper). Its coverage and fields differ; this Actor only reads Unstop.

### Support

Open an issue in the Actor's Apify Issues tab with your input, run link and expected behavior. Avoid posting credentials or private participant information. Source changes and limitations are recorded in the changelog.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/unstop-public-opportunities/changelog.md

# Actor input Schema

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

Global run limit on unique public competition records. Default 100; 1–10000, zero is invalid. Fewer may be returned when maxPages or the source's available pages are exhausted.

## `maxPages` (type: `integer`):

Maximum pages fetched from page 1, with 10 source records per page. Default 10; 1–1000. Deduplication and non-public exclusions can reduce output. Stops early at maxItems or source exhaustion; does not promise complete catalog coverage.

## Actor input object example

```json
{
  "maxItems": 20,
  "maxPages": 3
}
```

# Actor output Schema

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

Current run records in the default dataset.

# 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 = {
    "maxItems": 20,
    "maxPages": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/unstop-public-opportunities").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 = {
    "maxItems": 20,
    "maxPages": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/unstop-public-opportunities").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 20,
  "maxPages": 3
}' |
apify call automation-lab/unstop-public-opportunities --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/unstop-public-opportunities"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/aPwv8t5WdEdiGdTr8/builds/Y6BLQ0LFPkcQXEaWx/openapi.json