# NZX Announcements Monitor — New Zealand Market Disclosure Feed (`datadeltas/asx-nzx-announcements`) Actor

Company announcements from the NZX Main Board (NZSX) and Debt Market (NZDX) as a near-real-time change feed. Ticker and price-sensitive filters, PDF permalinks, and only NEW announcements each run — schedule it and pipe disclosures straight into your model, alerting or newsroom workflow.

- **URL**: https://apify.com/datadeltas/asx-nzx-announcements.md
- **Developed by:** [Daniel Matthee](https://apify.com/datadeltas) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 new announcement detecteds

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?

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

## NZX Announcements Monitor — New Zealand Market Disclosure Feed

Every new company announcement from the **NZX Main Board (NZSX)** and **NZX Debt
Market (NZDX)** as a clean, near-real-time change feed: ticker, issuer, headline,
NZX's own price-sensitive flag, a permalink to the announcement PDF, and a UTC
timestamp. Each run emits **only announcements it has never seen before**, so a
schedule gives you a duplicate-free stream you can pipe straight into a model, an
alerting bot or a newsroom workflow.

> **Coverage note — NZX only, no ASX.** ASX's website terms of use reserve ASX
> Market Announcements for investors' "private and personal use only" and require
> ASX's express written authority for any commercial use, so this actor does not
> fetch or redistribute them. Asking for `asx` in the input logs the reason and is
> skipped. If ASX coverage matters to you, licence it directly from ASX
> Information Services.

### Example output

One real record, unmodified:

```json
{
  "exchange": "nzx",
  "market": "NZSX",
  "announcementId": "478910",
  "ticker": "BRW",
  "company": "Bremworth Limited",
  "title": "Preliminary FY26 Unaudited Results Announcement",
  "announcementType": "FLLYR",
  "priceSensitive": true,
  "isThirdParty": false,
  "publishedAt": "2026-08-31T04:34:30Z",
  "publishedAtLocal": "2026-08-31T16:34:30+12:00",
  "pdfUrl": "https://api.nzx.com/public/announcement/478910/attachment/475933/478910-475933.pdf",
  "attachmentCount": 3,
  "url": "https://www.nzx.com/announcements/478910",
  "windowTruncated": false,
  "detectedAt": "2026-08-31T09:56:20Z"
}
```

| Field | What it is |
|---|---|
| `exchange` | `nzx` |
| `market` | `NZSX` (Main Board) or `NZDX` (Debt Market). A release to both boards is emitted once, tagged NZSX |
| `announcementId` | NZX's own id — the stable key to dedupe on |
| `ticker` | Instrument code (`AIR`, `FCG010`, …). NZ RegCo notices carry `REGCO` |
| `company` | Issuer name, security class trimmed. `null` for issuers outside NZX's active-instrument list (most NZDX debt issuers, delisted codes) |
| `title` | Headline as published |
| `announcementType` | NZX type code: `FLLYR`, `HALFYR`, `CORPACT`, `MKTUPDTE`, `MEETING`, `SECISSUE`, `SHINTR`, `HALT`, `ADMIN`, `ANNREP`, `GENERAL` |
| `priceSensitive` | The exchange's own flag, not our guess (~1 announcement in 5) |
| `isThirdParty` | Lodged by a third party (substantial holder, NZ RegCo) rather than the issuer |
| `publishedAt` / `publishedAtLocal` | UTC, and the original NZ-offset timestamp |
| `pdfUrl` | Permalink to the first attached document (`null` if there is none) |
| `attachmentCount` | How many documents the announcement carries |
| `url` | The announcement's page on nzx.com |
| `windowTruncated` | `true` when this row's board listed nothing older than your `sinceHours` cutoff — the source window does not reach that far back, so coverage before its oldest row is incomplete |
| `detectedAt` | When this monitor first saw it |

### Input options

| Input | Type | Default | What it does |
|---|---|---|---|
| `exchanges` | array | `["nzx"]` | Exchanges to monitor. `nzx` only — see the coverage note |
| `tickers` | array | *(empty = all)* | NZX instrument codes. A 3+ character code also matches that issuer's debt series, so `FCG` catches `FCG010` |
| `priceSensitiveOnly` | boolean | `false` | Emit only announcements NZX flagged price sensitive |
| `sinceHours` | integer | `24` | Backfill window on the first run; the scan window afterwards (max 168) |
| `maxItems` | integer | `200` | Cap on new announcements per run. Anything over the cap arrives next run |

**First run seeds, later runs diff.** The first run emits everything inside
`sinceHours`; after that only never-seen announcements are emitted, so a scheduled
run yields zero duplicates. Announcements over `maxItems` carry over rather than
being dropped.

**Window vs source depth.** Each board page lists its ~200 most recent
announcements: about a month on NZDX, about four trading days on the busier NZSX.
`sinceHours` beyond that is limited by the source on NZSX. When a board's oldest
listed announcement is *newer* than your cutoff, the run logs a `COVERAGE GAP`
warning, says so in the run status message, and marks every row from that board
`windowTruncated: true` — so a short list is never mistaken for a quiet period.
Weekends carry no announcements, so a Monday run with `sinceHours=72`
legitimately returns only Monday's items.

Suggested schedule: every 15 minutes between 08:00 and 18:00 NZ time on trading
days — the exchange releases announcements continuously through the session.

### Use cases

1. **"NZX price-sensitive announcement alerts"** — run with
   `priceSensitiveOnly: true` and webhook every new row into Slack, Discord or
   email. You see results, dividends, guidance changes and trading halts as they
   land, with the PDF one click away.
2. **"NZX announcements API for my portfolio"** — set `tickers` to your holdings
   and let the feed watch them for you: capital changes, director interests,
   meeting notices, debt-series terms. `announcementId` makes upserts trivial.
3. **"Scrape NZX disclosures into a dataset"** — leave the filters empty and run
   on a schedule to build a timestamped announcement history with headline, type,
   price-sensitivity and document links, ready for event studies or LLM
   summarisation.

### Pricing (pay per event)

| Event | Price |
|---|---|
| Actor start | $0.005 per run |
| New announcement detected | $0.008 each |

A quiet run costs the start fee alone. A typical NZ trading day publishes roughly
90–120 announcements across both boards, of which about 10–20 are price sensitive.

### Reliability

- One board failing degrades to a warning: the other board still emits and the
  failed board's announcements are picked up on the next run. If **both** boards
  fail the run fails loudly rather than reporting a quiet day.
- Field-level changes at the source log a named schema-drift warning instead of
  crashing the run. If every board fetches but lists zero announcements the run
  fails loudly rather than reporting a quiet day.
- Attachment links are built the way nzx.com builds them for a browser; the
  monitor never hammers NZX's data host.
- Schema checked weekly against the live pages; output changes within v1 are
  additive only.

### Changelog

- **0.1** — first release. NZSX + NZDX boards, ticker and price-sensitive filters,
  PDF permalinks, seen-id change feed with carry-over.

# Actor input Schema

## `exchanges` (type: `array`):

Exchanges to monitor. Only NZX is available: ASX's website terms of use reserve Market Announcements for private, personal, non-commercial use, so this actor does not redistribute them. Asking for 'asx' logs the reason and is skipped.

## `tickers` (type: `array`):

Optional NZX instrument codes, e.g. AIR, FPH, MEL. A 3+ character code also matches that issuer's debt series (FCG matches FCG010). Leave empty for every announcement on the boards.

## `priceSensitiveOnly` (type: `boolean`):

Emit only announcements the exchange itself flagged as price sensitive (NZX's own isPriceSensitive flag — roughly 1 in 5). Cuts routine admin and meeting notices.

## `sinceHours` (type: `integer`):

How far back to look on each run. On the first run this is your backfill; afterwards only announcements never seen before are emitted. The boards themselves list the ~200 most recent announcements (about 4 days of trading), so values above that are capped by the source.

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

Cap on new announcements emitted in a single run (cost control). Anything over the cap is picked up on the next run.

## Actor input object example

```json
{
  "exchanges": [
    "nzx"
  ],
  "tickers": [
    "AIR",
    "FPH"
  ],
  "priceSensitiveOnly": false,
  "sinceHours": 24,
  "maxItems": 200
}
```

# Actor output Schema

## `records` (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 = {
    "tickers": [
        "AIR",
        "FPH"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datadeltas/asx-nzx-announcements").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 = { "tickers": [
        "AIR",
        "FPH",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("datadeltas/asx-nzx-announcements").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 '{
  "tickers": [
    "AIR",
    "FPH"
  ]
}' |
apify call datadeltas/asx-nzx-announcements --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datadeltas/asx-nzx-announcements"
        }
    }
}

```

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/EYy2fAJvA7We7sJJ5/builds/44fBpyYUNDfKqJftl/openapi.json