# New Zealand GETS Tender Opportunities Scraper (`automation-lab/new-zealand-gets-tender-opportunities-scraper`) Actor

Monitor NZ government tenders from GETS with structured agencies, close dates, categories, regions, contacts, overviews, and source URLs.

- **URL**: https://apify.com/automation-lab/new-zealand-gets-tender-opportunities-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## New Zealand GETS Tender Opportunities Scraper

Extract public tender opportunities from New Zealand GETS (Government Electronic Tender Service) into a structured Apify dataset.

Use this actor to monitor current GETS tenders, enrich public tender detail pages, and feed procurement leads into spreadsheets, CRMs, dashboards, or bid-management workflows.

### What does New Zealand GETS Tender Opportunities Scraper do?

New Zealand GETS Tender Opportunities Scraper visits public GETS tender list pages and public tender detail pages.

It collects tender IDs, titles, buyer agencies, tender types, close dates, open dates, categories, regions, overview text, contact instructions, attachment links, and source URLs.

The default run starts from the current tenders page at `https://www.gets.govt.nz/ExternalIndex.htm`.

You can also provide direct GETS list URLs or direct tender detail URLs.

### Who is it for?

This scraper is built for procurement teams and suppliers that need repeatable New Zealand government tender monitoring.

Typical users include:

- 🧾 Bid teams tracking fresh public-sector opportunities.
- 🏢 Suppliers selling into New Zealand government agencies.
- 📊 Procurement-intelligence platforms enriching opportunity databases.
- 🤝 Consultants preparing tender alerts for clients.
- 🧪 Data teams building public contract opportunity pipelines.

### Why use this scraper?

GETS is public, but manual monitoring is repetitive.

This actor turns tender pages into structured rows that can be filtered, exported, scheduled, and integrated through Apify.

It is useful when you need:

- a daily tender monitor,
- a spreadsheet of current opportunities,
- category or region analysis,
- a CRM feed for bid qualification,
- source URLs for human review,
- repeatable scraping without browser automation.

### Data extracted

Each dataset item represents one tender opportunity.

| Field | Description |
| --- | --- |
| `tenderId` | GETS RFx/tender ID |
| `referenceNumber` | Buyer reference number when listed |
| `title` | Tender title |
| `agency` | Buyer agency or organization |
| `listType` | Current, late, closed, completed, or detail |
| `tenderType` | Full tender type such as Request for Proposals |
| `tenderTypeCode` | Short code such as RFP or NOI |
| `openDate` | Public open date from the detail page |
| `closeDate` | Public close date from list/detail page |
| `status` | Inferred status from the source list |
| `coverage` | Tender coverage when shown |
| `categories` | GETS category labels |
| `regions` | GETS region labels |
| `exemptionReason` | Exemption reason when public |
| `preQualifications` | Required pre-qualifications when public |
| `contact` | Public contact or question instructions |
| `deliveryAddress` | Public delivery instructions |
| `overview` | Tender overview/summary text |
| `attachments` | Public links found in the tender details |
| `detailUrl` | GETS tender detail page URL |
| `sourceListUrl` | GETS list URL where the tender was discovered |
| `scrapedAt` | ISO timestamp for extraction time |

### How much does it cost to scrape New Zealand GETS tenders?

This actor uses pay-per-event pricing. A run costs **$0.008 to start**, plus a plan-tier price for every saved tender. The BRONZE per-tender price is **$0.0024**; higher Apify plans receive the configured tier discount.

At BRONZE pricing, one tender costs about **$0.0104**, 25 tenders cost about **$0.068**, and 100 tenders cost about **$0.248**. These examples include the start fee and assume the run saves the requested number of items.

Pricing is based on measured Apify cloud run costs and current comparable tender-scraping Actors. You can keep first runs cheap by using a low `maxItems` value such as 25.

### Input options

The actor accepts a small input object.

#### `startUrls`

Optional GETS list or detail URLs.

Leave this empty to scrape current tender opportunities.

Examples:

- `https://www.gets.govt.nz/ExternalIndex.htm`
- `https://www.gets.govt.nz/ExternalLateTenderList.htm`
- `https://www.gets.govt.nz/ExternalClosedTenderList.htm`
- `https://www.gets.govt.nz/EECA/ExternalTenderDetails.htm?id=34118706`

#### `maxItems`

Maximum number of tender records to save.

Use a small number for tests and a larger number for monitoring runs.

#### `includeDetails`

When enabled, the actor opens each public detail page and extracts categories, regions, overview text, and contact fields.

Disable this only when you need a very quick list-only run.

#### `includeClosed`

When enabled, the actor also adds late, closed, and completed GETS lists.

Use this for archive or competitive-intelligence workflows.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.gets.govt.nz/ExternalIndex.htm" }
  ],
  "maxItems": 100,
  "includeDetails": true,
  "includeClosed": false
}
```

### Example output

```json
{
  "tenderId": "34118706",
  "referenceNumber": null,
  "title": "Organic Feedstock Availability - Tranche 2",
  "agency": "Energy Efficiency & Conservation Authority",
  "listType": "current",
  "tenderType": "Request for Proposals (RFP)",
  "tenderTypeCode": "RFP",
  "openDate": "Wednesday, 3 June 2026 4:30 PM (Pacific/Auckland UTC+12:00)",
  "closeDate": "Monday, 13 July 2026 9:00 AM (Pacific/Auckland UTC+12:00)",
  "status": "Open",
  "categories": ["77000000 - Environmental Services"],
  "regions": ["Wellington"],
  "overview": "Public tender overview text...",
  "detailUrl": "https://www.gets.govt.nz/EECA/ExternalTenderDetails.htm?id=34118706",
  "scrapedAt": "2026-07-10T00:00:00.000Z"
}
```

### How to scrape current GETS tenders

1. Open the actor on Apify.
2. Keep the default `startUrls` value or leave it empty.
3. Set `maxItems` to the number of tenders you need.
4. Keep `includeDetails` enabled for enriched results.
5. Click **Start**.
6. Export the dataset as JSON, CSV, Excel, XML, or RSS.

### How to monitor GETS daily

Create an Apify task with your preferred input.

Schedule it to run every morning.

Export the dataset to a webhook, Google Sheets, Airtable, or your internal pipeline.

Use `scrapedAt` and `tenderId` to deduplicate records between runs.

### Tips for best results

- Start with `maxItems: 25` to validate the output.
- Increase `maxItems` for full list coverage.
- Use `includeClosed: true` only when you need historical lists.
- Keep `includeDetails: true` if you need categories, regions, or overview text.
- Use direct detail URLs when you need to refresh specific tenders.
- Filter by `agency`, `regions`, or `categories` after export.

### Integrations

Common integration patterns include:

- 🧾 Send current tender rows to a bid qualification spreadsheet.
- 📣 Trigger Slack or email alerts for matching agencies or regions.
- 🏢 Sync opportunities into a CRM as procurement leads.
- 📊 Load daily runs into a warehouse for tender trend analysis.
- 🔎 Combine GETS data with company enrichment or contact research actors.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('automation-lab/new-zealand-gets-tender-opportunities-scraper').call({
  startUrls: [{ url: 'https://www.gets.govt.nz/ExternalIndex.htm' }],
  maxItems: 100,
  includeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')

run = client.actor('automation-lab/new-zealand-gets-tender-opportunities-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.gets.govt.nz/ExternalIndex.htm'}],
    'maxItems': 100,
    'includeDetails': True,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~new-zealand-gets-tender-opportunities-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url":"https://www.gets.govt.nz/ExternalIndex.htm"}],
    "maxItems": 100,
    "includeDetails": true
  }'
```

### MCP usage

You can call this actor from Claude Code, Claude Desktop, Cursor, or VS Code through Apify MCP Server. The Actor-specific server URL exposes this tool only:

`https://mcp.apify.com?tools=automation-lab/new-zealand-gets-tender-opportunities-scraper`

#### Claude Code setup

Register the remote HTTP server from a terminal:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/new-zealand-gets-tender-opportunities-scraper"
```

Run `claude mcp list` to confirm that the `apify` server is connected.

#### Claude Desktop setup

Add this server to the `mcpServers` object in your Claude Desktop configuration, then restart Claude Desktop:

```json
{
  "mcpServers": {
    "apify-gets-tenders": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/new-zealand-gets-tender-opportunities-scraper"
    }
  }
}
```

#### Cursor setup

Create or update `.cursor/mcp.json` in your project (or use the equivalent global Cursor MCP settings):

```json
{
  "mcpServers": {
    "apify-gets-tenders": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/new-zealand-gets-tender-opportunities-scraper"
    }
  }
}
```

#### VS Code setup

Add the remote server to `.vscode/mcp.json`, then start it from VS Code's MCP servers view:

```json
{
  "servers": {
    "apify-gets-tenders": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/new-zealand-gets-tender-opportunities-scraper"
    }
  }
}
```

Authenticate with Apify when your client prompts you. The MCP client can then start the Actor and inspect its dataset without copying an API token into the prompt.

Example prompts:

- "Run the New Zealand GETS tender scraper and summarize tenders closing this week."
- "Find GETS opportunities from Auckland Transport and return the source URLs."
- "Export current New Zealand government tenders and group them by region."

### Legality and responsible use

This actor extracts public GETS tender pages that are available without login.

It does not submit bids, register supplier interest, bypass authentication, or access private supplier-only pages.

Always review the target website terms and use the data responsibly.

### FAQ

#### Why did I get fewer results than `maxItems`?

The available list pages may contain fewer tenders than your requested limit, or you may have supplied a direct detail URL.

#### Why are some fields null?

GETS pages do not show every field for every tender. Null values mean the field was not present publicly on that page.

#### Why are attachments empty?

Some tenders require supplier subscription or login for full documents. The actor only returns public links visible on the page.

### Related scrapers

You may also want these automation-lab actors:

- https://apify.com/automation-lab/au-gov-tenders-scraper
- https://apify.com/automation-lab/eu-funding-tenders-scraper
- https://apify.com/automation-lab/german-tender-scraper
- https://apify.com/automation-lab/contractsfinder-uk-tenders-scraper

### Changelog

See `.actor/CHANGELOG.md` for user-visible changes.

### Support

If the GETS website changes and output looks incomplete, open an Apify issue with the run ID, input, and expected tender URL.

# Actor input Schema

## `startUrls` (type: `array`):

GETS list or detail URLs to crawl. Leave empty to start from the current tenders page.

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

Maximum tender records to save to the dataset.

## `includeDetails` (type: `boolean`):

Visit each public tender detail page to extract categories, regions, overview, contacts, and attachments.

## `includeClosed` (type: `boolean`):

Also crawl public GETS late, closed, and completed tender lists in addition to the start URLs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.gets.govt.nz/ExternalIndex.htm"
    }
  ],
  "maxItems": 20,
  "includeDetails": true,
  "includeClosed": false
}
```

# Actor output Schema

## `overview` (type: `string`):

Dataset items with key tender identifiers, buyer agencies, types, dates, categories, regions, status, and source links.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.gets.govt.nz/ExternalIndex.htm"
        }
    ],
    "maxItems": 20,
    "includeDetails": true,
    "includeClosed": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/new-zealand-gets-tender-opportunities-scraper").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 = {
    "startUrls": [{ "url": "https://www.gets.govt.nz/ExternalIndex.htm" }],
    "maxItems": 20,
    "includeDetails": True,
    "includeClosed": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/new-zealand-gets-tender-opportunities-scraper").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 '{
  "startUrls": [
    {
      "url": "https://www.gets.govt.nz/ExternalIndex.htm"
    }
  ],
  "maxItems": 20,
  "includeDetails": true,
  "includeClosed": false
}' |
apify call automation-lab/new-zealand-gets-tender-opportunities-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/new-zealand-gets-tender-opportunities-scraper"
        }
    }
}

```

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/K1K5zBWGhunuju1oq/builds/4kd2CXchfRP4gYtkA/openapi.json