# SGX Financial Report & Disclosure Document Watch (`nexgenwatch/sgx-financial-report-document-watch`) Actor

Singapore Exchange financial-report and disclosure documents as they are lodged: annual, interim, quarterly, business-review, sustainability and summary…

- **URL**: https://apify.com/nexgenwatch/sgx-financial-report-document-watch.md
- **Developed by:** [NexGen Watch](https://apify.com/nexgenwatch) (community)
- **Categories:** Business, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $33.50 / 1,000 report document deltas

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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## SGX Financial Report & Disclosure Document Watch

Singapore Exchange financial-report and disclosure documents as they are lodged: annual, interim, quarterly, business-review, sustainability and summary reports plus information and disclosure statements, with the issuer, the document date and the SGX document link. SCOPE: this is the open financial-reports document feed. It is NOT the full SGX company-announcements stream, which SGX keeps behind an authorised API.

### Source

SGX public financial-reports document feed (public, logged-out)

- https://api.sgx.com/financialreports/v1.0

Public, logged-out only — no API key, login, cookie or CAPTCHA.

### Two dates, and which one means "new"

Every record carries both, and they are not the same thing:

| field | what it is |
|---|---|
| `document_date` | the **reporting period end** the document covers — and the feed's sort key |
| `broadcast_date` | when SGX actually **published** it — the arrival clock |

The gap between them is large and normal: measured across 6,000 records on 2026-07-27, the
publication lag runs to a **median of 105 days** and a p90 of 114. SoftBank Group's annual
report, for instance, carries `document_date` 2026-03-30 (its 31 March financial year end) and
was broadcast on 2026-07-27 — SGX's own announcement page for it says *Period Ended 31/03/2026*
and *Date & Time of Broadcast 27-Jul-2026 16:30:17*.

**Both dates are in the change signature.** A watch that only signed `document_date` would call
a four-month-old period date "stale" on the day the document was published.

### How deep this Actor reads, and why it isn't a page count

SGX sorts this feed by `document_date`. Because publication lags the period date, **a document
broadcast today is not near the top of the feed** — measured, a trailing-30-day arrival sits at
median rank 103 and was found as deep as rank 2,362.

So depth is decided by **broadcast coverage**, not by a page number. This Actor keeps reading
until **10 consecutive pages carry no document broadcast inside `broadcast_window_days`**
(default 30). Ten is measured, not guessed: the largest observed gap between two pages carrying
a trailing-30-day arrival was 6 pages.

`pages` is a **hard cap** (default 40 = 4,000 records) that bounds the read if coverage is never
reached. **Hitting that cap is reported as a named `PARTIAL` — "DEPTH CAP" — never passed off as
a complete read.** Raise `pages` or narrow `broadcast_window_days` if you see it.

For reference, an earlier build of this Actor read a fixed 2 pages of 100. On the day it was
measured that window saw **89 of the 94** documents broadcast in the trailing 30 days; the other
five were not late, they were permanently invisible.

### Pricing

| Event | Price (FREE tier) |
|---|---|
| Actor start (`apify-actor-start`) | $0.02 one-time |
| Source check (`source-check`) | $0.10 |
| **Per delta (`report-document-delta`)** | **$0.05** |

`source-check` ladder, GOLD-floored: **$0.10 / $0.09 / $0.08 / $0.067**.
Charged once per run after the source enumeration terminates — seed runs and
genuine-zero runs included. It is **not** charged when the source refused the
read: a run that never read the source has not performed a source check.

The per-delta value event (`report-document-delta`) is the **primary** event and is priced at **$0.05 per delta** at the FREE tier. Ladder, GOLD-floored: **$0.05 / $0.045 / $0.04 / $0.0335** (FREE / BRONZE / SILVER / GOLD-PLATINUM-DIAMOND). `source-check` still charges; it is no longer the headline event. Billed deltas are capped at 500 per run and any overflow is reported as a withholding rather than charged.

### Snapshot mode is a PREVIEW

`watch_mode: false` returns at most **25 records**, hard-capped in code
regardless of any input, labeled `output_mode: "preview"`. This actor sells
change detection, not bulk record export.

### Watch semantics

The first watch run stores a private baseline and emits **zero** deltas. Later
runs emit `NEW` / `CHANGED` / `REMOVED` keyed on the source-native id with
`before` / `after` and `changed_fields`. Billed deltas are capped at 500 per
run; the overflow is reported as a named PARTIAL withholding, is never billed,
and is re-detected on the next run.

### Terminal states

`NORMAL` · `SUCCEEDED-0: GENUINE_EMPTY` · `SUCCEEDED-0` (no change) · `PARTIAL` · `BLOCKED`.
A zero with no evidence FAILS loud rather than exiting 0 quietly.

### This feed is seasonal. Budget for the season, not the average.

Arrivals are measured on the **broadcast clock**, and they are lumpy by construction: SGX
issuers file annual reports in a cluster a few months after their financial year ends, and 31
March is the common one.

Measured 2026-07-27 across 6,000 records:

| window | documents broadcast | rate |
|---|---|---|
| trailing 7 days | 4 | 4.0 / week |
| trailing 30 days | 94 | 21.9 / week |
| trailing 90 days | 249 | 19.4 / week |

The daily shape inside that 30-day window shows the season plainly — 9, 12 and 13 documents on
13, 14 and 15 July, then 4, then 1, then roughly one a day through to the end of the month.

So **the 90-day rate is the one to budget against**, not the 30-day peak and not a quiet week.
At $0.05 a delta the value event carries roughly **89% of a weekly-run bill in season** and
about **62% out of it**; on a daily schedule those become 54% and 19%. Either cadence is
defensible here — unlike the low-frequency watches in this fleet, this feed genuinely moves most
days in season, so a daily run buys real timeliness rather than paying for checks.

# Actor input Schema

## `page_size` (type: `integer`):

Documents requested per page from the source.

## `pages` (type: `integer`):

Hard cap on pages read. Depth is normally decided by broadcast coverage, not by this number: the Actor reads until 10 consecutive pages carry no document broadcast inside the window. This bounds the read if coverage is never reached, and hitting it is reported as a PARTIAL rather than passed off as a complete read.

## `broadcast_window_days` (type: `integer`):

How far back on the ARRIVAL clock (broadcastDateTime) this Actor guarantees to read. SGX sorts this feed by documentDate, which is the reporting PERIOD END date and lags publication by about 105 days at the median -- so a document broadcast today is not near the top of the feed. This window, not a page count, decides how deep the read goes.

## `report_types` (type: `array`):

Optional filter, e.g. Annual Report, Interim Report, Quarterly Report, Sustainability Report, Disclosure Statement.

## `company_contains` (type: `array`):

Optional substrings matched against the issuer name.

## `watch_mode` (type: `boolean`):

First run seeds a private baseline and emits ZERO deltas.

## `baseline_id` (type: `string`):

Names the private baseline so several watches can run side by side.

## Actor input object example

```json
{
  "page_size": 25,
  "pages": 1,
  "broadcast_window_days": 30,
  "report_types": [],
  "company_contains": [],
  "watch_mode": true,
  "baseline_id": "default"
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "page_size": 25,
    "pages": 1,
    "broadcast_window_days": 30,
    "report_types": [],
    "company_contains": [],
    "watch_mode": false,
    "baseline_id": "default"
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgenwatch/sgx-financial-report-document-watch").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 = {
    "page_size": 25,
    "pages": 1,
    "broadcast_window_days": 30,
    "report_types": [],
    "company_contains": [],
    "watch_mode": False,
    "baseline_id": "default",
}

# Run the Actor and wait for it to finish
run = client.actor("nexgenwatch/sgx-financial-report-document-watch").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 '{
  "page_size": 25,
  "pages": 1,
  "broadcast_window_days": 30,
  "report_types": [],
  "company_contains": [],
  "watch_mode": false,
  "baseline_id": "default"
}' |
apify call nexgenwatch/sgx-financial-report-document-watch --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgenwatch/sgx-financial-report-document-watch"
        }
    }
}

```

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/nN2aPwNOMZxve3QmY/builds/qL6114aQL94V2tFP8/openapi.json