# Hong Kong Funding & Competition Finder (`gen_one_ai/hong-kong-funding-competitions`) Actor

Discover Hong Kong funding, business, startup and trading opportunities from official websites on each run. Export source links, eligibility and award excerpts with transparent extraction status.

- **URL**: https://apify.com/gen_one_ai/hong-kong-funding-competitions.md
- **Developed by:** [Ivan Tech](https://apify.com/gen_one_ai) (community)
- **Categories:** Business, Education
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00 / 1,000 returned opportunities

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Hong Kong Funding & Competition Finder

Discover fundraising opportunities, business case competitions, startup pitches, awards and trading competitions relevant to Hong Kong. The default **live** mode fetches selected official websites during each run, follows relevant links, and returns structured records with source URLs and retrieval timestamps.

This is a bounded discovery tool, not a complete search of every Hong Kong website. It does not confirm that applications are open or that a person qualifies. Missing dates and eligibility details remain unknown. It does not return historical winners or submit applications.

### What you receive

Each dataset row includes a title, opportunity type, organizer, official URL, description excerpt, eligibility and award excerpts when found, deadline wording, source ID, retrieval time, and extraction status. JSON and CSV exports are available through Apify datasets.

The `SUMMARY` key-value record reports matching and returned counts, source failures, partial coverage, pagination, and whether the spending limit stopped output. An empty filtered result is legitimate. If every selected source fails, the run fails explicitly; it does not substitute old catalogue records.

### Example input

```json
{
  "mode": "live",
  "sources": ["hku-tec", "hkstp", "cyberport", "hkgcc", "cityu", "hksec"],
  "types": ["fundraising", "business", "entrepreneurship"],
  "includePast": false,
  "maxPages": 24,
  "limit": 100
}
```

Use `q: "business case"` to narrow the extracted results. All search words must match somewhere in a record. An empty `types` or `sources` array selects all supported values. Search takes place after the bounded crawl; a narrow query can return zero even when other opportunities were found.

### Official sources

| Source ID | Coverage |
|---|---|
| `hku-tec` | HKU TEC competition event listings and linked event pages |
| `hkstp` | HKSTP programme index and relevant programme pages |
| `cyberport` | Cyberport entrepreneurship programmes |
| `hkgcc` | The configured HKGCC business case competition edition page |
| `cityu` | CityUHK Tech 300 seed and angel funding pages discovered from its index |
| `hksec` | Hong Kong Social Enterprise Challenge programme page |

Coverage is limited to these configured sites and paths. In particular, the HKGCC seed is an edition-specific page and needs maintenance when a new edition URL is announced. Trading is a supported output/filter category, but these initial sources do not promise comprehensive trading coverage. Official websites can change, block automated requests, or require browser rendering. The Actor respects robots.txt and reports failures; it does not bypass access restrictions.

### Input and deadline semantics

- `mode`: `live` by default; `catalogue` explicitly searches the maintained FundXplore website snapshot instead.
- `maxPages`: 6–60 HTML requests, default 24, divided among selected sources. robots.txt requests are additional. Live runs have a 45-second source budget.
- `types`: `fundraising`, `business`, `entrepreneurship`, `trading`. These are broad categories; programmes and awards are not necessarily competitions.
- `q`, `location`, `category`: optional text/category filters. Location is source context, not a guarantee about applicant eligibility.
- `includePast`: false by default. Excludes extracted or listed dates known to be before today in Hong Kong; it cannot exclude all closed opportunities because many deadlines remain unknown.
- `deadlineFrom`, `deadlineTo`: inclusive YYYY-MM-DD bounds. Undated records are excluded when these are used.
- `limit`: 1–1,000 returned records, default 100. `offset`: skip matching records. `sort`: `deadline` or `title`.

Only an unambiguous ISO date in labelled live deadline text is normalized in this version. Other wording is preserved in `deadlineText`. No year, timezone, deadline or funding amount is invented. Live rows have `verificationStatus: automatically-extracted-review-required`; fetching a source is not editorial verification. Automated type classification and organizer attribution use source context and can require correction.

Catalogue rows retain the website's listed milestone date and may include an early, institutional or batch cutoff. `review-required` prevents known ambiguous multi-stage listings from being treated as definitively closed. `lastVerifiedAt` remains null where individual verification evidence is unavailable.

### Pricing and spending limits

The Actor supports one **`opportunity-result`** pay-per-event charge for each newly exported row. The displayed Apify pricing determines the actual price. No custom charge is made for failed pages, filtered-out records, or an empty result. Maximum results and Apify's maximum run charge both bound output. Platform usage charges, if enabled by the publisher, are shown separately in Apify pricing.

Rows already present in the same run's default dataset are skipped when resuming. A new run performs fresh retrieval and produces a new billable export; it is not a change-only subscription. For a stable paginated export, page through the completed dataset rather than launching a separate live run for each offset.

### Freshness and limits

Live output records the actual retrieval time and evidence excerpts. It does not scrape arbitrary user-supplied URLs, run AI prompts found in pages, parse attached PDFs, render JavaScript-heavy pages, assess personal eligibility, or promise funding outcomes. Check linked official terms before applying. Catalogue mode is a build-time snapshot and is updated when the publisher updates the source records and rebuilds the Actor.

Use Apify schedules if you want repeated live discovery. This Actor outputs datasets; it does not itself email deadline reminders.

# Actor input Schema

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

Live fetches official sources on every run. Catalogue searches only the maintained website snapshot. No silent fallback.

## `sources` (type: `array`):

Live mode only. Empty means all supported sources. Sources may block requests or be unavailable.

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

Live HTML page budget, divided among selected sources. robots.txt requests are additional. A time budget may stop earlier.

## `q` (type: `string`):

All words must appear somewhere in the title, description, organizer, eligibility, award, location or university. For example: business case.

## `types` (type: `array`):

Leave empty for all types. Business includes business competitions and awards; entrepreneurship includes pitches and startup programmes.

## `location` (type: `string`):

Case-insensitive match against the catalogue location, not an applicant eligibility check. Leave empty for the full Hong Kong-relevant catalogue, including global opportunities.

## `category` (type: `string`):

Optional source category.

## `includePast` (type: `boolean`):

Include fixed listed dates before today in Hong Kong. Rolling and uncertain multi-stage deadlines are retained regardless; read deadlineText.

## `deadlineFrom` (type: `string`):

YYYY-MM-DD. Filters the catalogue's listed milestone date; excludes records without a date. This may be an early or institutional deadline.

## `deadlineTo` (type: `string`):

YYYY-MM-DD, inclusive. Excludes records without a date.

## `limit` (type: `integer`):

Maximum records to return. The Apify spending limit may stop output earlier.

## `offset` (type: `integer`):

Skip this many matching results. For paging, keep filters fixed and check catalogueVersion has not changed.

## `sort` (type: `string`):

Deadline orders by listed date, with undated records last; title orders alphabetically.

## Actor input object example

```json
{
  "mode": "live",
  "sources": [],
  "maxPages": 24,
  "types": [],
  "category": "",
  "includePast": false,
  "limit": 100,
  "offset": 0,
  "sort": "deadline"
}
```

# Actor output Schema

## `opportunities` (type: `string`):

Returned catalogue records. Export JSON or CSV from the dataset.

## `summary` (type: `string`):

Matching count, catalogue version, paging and spending-limit status.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("gen_one_ai/hong-kong-funding-competitions").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("gen_one_ai/hong-kong-funding-competitions").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 '{}' |
apify call gen_one_ai/hong-kong-funding-competitions --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gen_one_ai/hong-kong-funding-competitions"
        }
    }
}
```

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/fXLkp3gXqeOuWJBkG/builds/NqfCmmws5VZ9zvtwy/openapi.json