# TenderNed Procurement Notices - Netherlands, Per Publication (`nexgensignal/nl-tenderned-procurement-notice-records`) Actor

Netherlands TenderNed national procurement publications as clean per-record data - id, date, type, tender name, contracting authority, procedure and EU-level flag. List endpoint only; description and contacts dropped. CC0. $0.05 per record.

- **URL**: https://apify.com/nexgensignal/nl-tenderned-procurement-notice-records.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $33.50 / 1,000 procurement notice records

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?

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

## TenderNed Procurement Notices - Netherlands, Per Publication

Every Dutch public-procurement publication from **TenderNed** - the Netherlands national procurement platform -
as one clean, flat record. Publication id, date, type, tender name, contracting authority, procedure, contract
type and the EU-level flag, read from the keyless list endpoint. **No free-text description, no contact
persons.**

### What one record represents

The source is **TenderNed** (`www.tenderned.nl/papi/...`), the Dutch national tender platform, read from its
keyless JSON list endpoint (`/papi/tenderned-rs-tns/v2/publicaties`). Each record is **one publication**: its
publication id, publication date, publication type (description and code), the tender name, the contracting
authority, the procedure, the contract type (works/supplies/services), the publication status and code, the
EU-level flag (`is_european`), and a link back to the publication.

### Coverage and volume

The live list holds **145,241** publications - measured at build time from the endpoint's `totalElements`.

**Sol's Wave-4 index put this door at 145,240 EXACT; measured live at build time the endpoint reports 145,241 -
the live figure is what this listing quotes.**

The Actor pages the endpoint 100 publications at a time and stops as soon as your **Maximum records** cap is
met.

### Licence and attribution

TenderNed publications are open data via data.overheid.nl under **CC0 1.0** - a public-domain dedication, free
to use for any purpose. The full notice travels on every record:

> Published as open data via data.overheid.nl under Creative Commons Zero (CC0 1.0) - a public-domain dedication, free to use for any purpose; attribution to TenderNed appreciated.

### Person-data policy

This Actor reads **only the list endpoint** and emits no personal data. The free-text description
(`opdrachtBeschrijving`) is **dropped**, and the per-publication **detail endpoint - which carries contact
persons - is never fetched**. A per-record assertion rejects any contact/person field or the description
(verified with a planted-field test). The contracting authority is an organisation, never a person.

### Interpretation caveat

One record per TenderNed publication from the national procurement list endpoint: publication id, date, type, tender name, contracting authority, procedure, contract type and the EU-level flag (is\_european). The free-text description is dropped and the detail endpoint - which carries contact persons - is never fetched.

Values are reproduced verbatim from the API; the Actor never rewrites a field. The list endpoint does not
carry the tender closing date (that lives on the detail endpoint, which is not fetched for contact-privacy);
this cell delivers the publication-level fields the list endpoint exposes.

### Relationship to EU TED

`is_european` marks the above-threshold notices that also appear on EU TED (about 30% of the Dutch total).
The fleet's EU TED monitor covers the EU-level corpus across all member states; this cell is the **national**
Dutch register, including the large below-threshold segment that never reaches TED. Filter on `is_european` to
isolate the overlap or the Dutch-only remainder; the two datasets combine without double-counting because the
overlap is flagged on the record.

### Provenance and compliance

Every run reads the door host's `robots.txt` at runtime; the gate result (URL, status, byte length, SHA-256
of the policy) is written to the run's `RUN_RECEIPT`, and the data path is confirmed permitted before any
fetch. The endpoint is keyless. The Actor never bypasses a block or fetches through a mirror.

### Data quality and freshness

Boolean columns are delivered as real booleans and numeric columns as real numbers. Delivery is keyed on a
stable composite id, so the dataset is safe to diff, deduplicate or upsert. Every run re-reads the live door,
so the data is as fresh as the source publishes, and each record's `observed_at` stamp dates the snapshot. The
run's `RUN_RECEIPT` records the source URL and how many records were delivered and charged, and confirms
`charge_equals_delivered`.

### Billing and delivery

Pricing is per record: you are billed only for records the Actor actually delivers, at a flat rate, with the
charge raised after each record is pushed (push-then-charge), so a failed or empty run costs nothing. There is
no subscription and no minimum. The **Maximum records** cap bounds every run, so you control the spend
precisely - set it low to sample the shape of the data cheaply, then raise it once you have confirmed the cell
fits your use. Because delivery is incremental and keyed on a stable id, re-running against the same door and
upserting on that id keeps a downstream table current without re-paying for rows you already hold; only the new
and changed records add cost. Every run's receipt reconciles delivered against charged, so the billing is
auditable against the data you received.

### Inputs

- **Maximum records** (`maxRecords`) - hard cap on publication records delivered and billed.

### Output

Records land in the Actor's default dataset and export as JSON, CSV, Excel or via the Apify API. A tabular
overview surfaces publication id, date, type, tender name, contracting authority, procedure and the EU flag.

### Fields in detail

The record leads with `publication_id`, `publication_date`, `publication_type` (and `publication_type_code`),
`tender_name`, `contracting_authority`, `procedure`, `contract_type`, `publication_code`, `publication_status`,
the booleans `is_european`/`is_digital`/`is_early_termination`, the authority `reference` and the `link`. The
provenance block closes every record.

### Typical uses

Dutch bid teams use this cell to keep a live feed of every national tender publication - what was published,
by which authority, under which procedure - filterable by type and date, with the EU flag to separate
above-threshold notices from the Dutch-only segment. Because the record is flat and keyed on the publication
id, it drops into a bid-tracking pipeline as a slowly-changing feed, and a scheduled run keeps it current with
no reconciliation. The `link` field takes a human straight to the full publication when they need the detail.

### Scaling and limits

Set **Maximum records** low to sample or high to pull the full national register. The Actor pages the endpoint
and delivers incrementally, so memory stays flat and you are billed only for what is delivered. Because
TenderNed publishes continuously, re-running picks up new notices, and each record's `observed_at` stamp dates
the snapshot - schedule a run to keep a downstream tender feed current.

### Why the list endpoint only

TenderNed exposes two layers: a list endpoint that returns the publication-level facts, and a per-publication
detail endpoint that carries the full notice including named contact persons at the contracting authority. This
cell reads **only the list layer**. That is a deliberate design choice, not a limitation: the list layer gives
the entire national register - every publication, keyed and typed - without ever touching personal contact
data, so the dataset is clean to redistribute and needs no redaction. If a buyer needs the contact detail for a
specific tender, the `link` field takes a human to the source publication, where the authority publishes it
under its own terms; the Actor does not aggregate it.

### Reading the fields

`publication_type` describes what the notice is - a contract notice, an award notice, a prior information
notice - and pairs with `publication_type_code` for exact filtering. `procedure` names the procurement
procedure (open, restricted, negotiated), and `contract_type` separates works, supplies and services.
`publication_status` tracks whether the notice is current or superseded, and `is_early_termination` flags the
notices that end a procedure early. Together these let a bid team slice the register precisely - for example,
open-procedure service contracts published this month by a given authority - without post-processing, because
every dimension is a first-class field on the record.

### Sibling Actors

It sits beside the fleet-2 EU TED tender monitor (EU-level corpus vs the Dutch national register) and the fleet's other national procurement cells. It shares its engineering - the runtime robots gate, paging, push-then-charge billing and verbatim-value discipline - with the fleet's other records Actors.

# Actor input Schema

## `maxRecords` (type: `integer`):

Maximum records delivered and billed. You are billed only for records actually delivered. Raise it to pull the full set.

## Actor input object example

```json
{
  "maxRecords": 500
}
```

# Actor output Schema

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

The delivered TenderNed procurement notice record.

# 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 = {
    "maxRecords": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/nl-tenderned-procurement-notice-records").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 = { "maxRecords": 500 }

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/nl-tenderned-procurement-notice-records").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 '{
  "maxRecords": 500
}' |
apify call nexgensignal/nl-tenderned-procurement-notice-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/nl-tenderned-procurement-notice-records"
        }
    }
}
```

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/rmbFRC7RdXYe1auHi/builds/qVdFgH08RIH8ucrg3/openapi.json