# EU Tenders Monitor: TED & TenderNed (only new tenders) (`lowlands-data/eu-tenders-monitor-ted-tenderned-only-new-tenders`) Actor

Daily public procurement alerts from TED (EU) and TenderNed (NL): choose sectors, keywords and countries and get only new tenders, with deadline, value and buyer. Official open data, pay only per notice.

- **URL**: https://apify.com/lowlands-data/eu-tenders-monitor-ted-tenderned-only-new-tenders.md
- **Developed by:** [Lowlands Data](https://apify.com/lowlands-data) (community)
- **Stats:** 2 total users, 1 monthly users, 77.8% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 tender notice delivereds

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

## EU Tenders Monitor: TED & TenderNed (only new tenders)

Get **new public tenders every day** from the two official sources:

- **TED** (Tenders Electronic Daily): all public procurement above the EU thresholds in the 27 EU countries plus
  Norway, Iceland, Liechtenstein and Switzerland, published by the EU Publications Office.
- **TenderNed**: the Dutch government's procurement platform, including **national tenders below the EU thresholds**
  and **market consultations** that never reach TED.

Choose **sectors in plain words** (IT & software, construction, cleaning, …) or exact CPV codes, add keywords,
countries, the type of contract (works, supplies, services), notice types and a minimum value. Turn on **Only new notices** and schedule the Actor
daily: each run returns only what you have not seen yet. You pay per notice delivered; nothing when there is nothing new.

### What you get per notice

- Title in your language and in the original language, the short procedure name (`shortTitle`), a description
- Buyer: name, country, city and the buyer's procurement mailbox when it is a role address (inkoop@, procurement@)
- CPV codes, contract nature (works, supplies, services), procedure type
- Publication date, **deadline** (date and time; `deadlineType` tells whether it is the deadline for tenders or, in
  restricted procedures, for requests to participate)
- Estimated value (TED) with its basis (whole procedure, sum of lots or framework maximum), and for awards the
  **winners** (organisation, country, size) and the awarded value
- Links to the notice, the PDF and the procurement documents
- `daysToDeadline` (for alerts) and `matchedKeywords` (which of your keywords appear in the title or description)

### Typical uses

- **Daily tender alerts** for your sector: keywords + CPV codes + countries, scheduled every morning.
- **Market intelligence**: who wins which contracts, at what value (notice type "Contract awards").
- **Early signals**: prior information notices and market consultations, before the tender itself.
- **Feed a CRM, Slack or Google Sheet** with the Apify integrations.

### Input

| Field | Description |
|---|---|
| `sectors` | Sectors in plain words, each a set of CPV codes: IT & software, construction works, cleaning & facility, consulting, health, transport, energy, … (22 sectors). |
| `contractNatures` | Works, supplies and/or services. Empty = all. |
| `keywords` | Words or phrases (any of them). Add local-language words too: `cleaning`, `schoonmaak`, `Reinigung`. |
| `cpvCodes` | CPV codes. 8 digits include all sub-codes (`90910000` = all cleaning services); shorter codes are prefixes (`72` = all IT services). |
| `countries` | Countries of the buyer (two letters). Empty = all EU/EEA. |
| `noticeTypes` | Contract notices (default), prior information, market consultations, contract awards, direct awards, modifications, corrigenda, cancellations. |
| `sources` | TED and/or TenderNed. With both, European notices come from TED and TenderNed adds the national ones. |
| `publishedWithinDays` | Search window, default 7 days. |
| `onlyNew` | Return only notices this monitor has not delivered before (default on). |
| `monitorName` | Optional name to keep the memory of different saved tasks apart. |
| `memoryStore` | Optional key-value store for the memory (only needed if a run warns that the memory could not be opened). |
| `minEstimatedValueEur`, `includeWithoutValue` | Minimum value, and whether to keep notices that publish no value. |
| `language` | Language of `title` (default English). |
| `maxResults` | Maximum notices per run (default 1,000). |

Filters work together: a notice must match every filter you fill in (sector **and** keyword **and** country …);
within one filter, any value is enough (software **or** ICT).

### Daily alerts in three steps

1. Set your filters and keep **Only new notices** on.
2. Click **Save as a new task** and give it a monitor name.
3. In the task, choose **Schedule** → every day. Add an integration (e-mail, Slack, Google Sheets) if you like.

The default window of 7 days covers notices that TED publishes a few days after the buyer submitted them, while the
memory prevents duplicates.

### Output example

```json
{
  "source": "TED",
  "noticeId": "685636-2026",
  "url": "https://ted.europa.eu/en/notice/-/detail/685636-2026",
  "noticeType": "contract_notice",
  "title": "Netherlands – Supply services of personnel including temporary staff – Managed Service Provider (MSP)",
  "shortTitle": "Managed Service Provider (MSP) voor de inhuur van extern personeel",
  "daysToDeadline": 55,
  "matchedKeywords": [],
  "buyer": {"name": "Gemeente Woerden", "country": "NL", "city": "Woerden", "email": "inkoop@woerden.nl"},
  "cpvCodes": ["79620000"],
  "contractNature": "services",
  "procedureType": "open",
  "publicationDate": "2026-10-13",
  "deadline": "2026-12-07",
  "deadlineTime": "12:00",
  "deadlineType": "tenders",
  "estimatedValue": {"amount": 60000000, "currency": "EUR", "basis": "procedure"},
  "winners": [],
  "documentsUrl": "https://www.tenderned.nl/aankondigingen/overzicht/443565"
}
```

### Pricing

Pay per event: **per notice delivered**. Notices you have already received (with Only new notices on) are not
delivered again and cost nothing. If your maximum cost per run is reached, the remaining notices are delivered in the
next run.

### Sources and terms

- TED notices may be reused freely, also commercially (TED legal notice). Data via the official TED Search API.
- TenderNed publications are open data under CC-0 (data.overheid.nl), via TenderNed's publication web service.
  TenderNed may change this service without notice; if it fails, the run continues with TED and reports a warning.
- This Actor is not affiliated with the EU Publications Office or TenderNed.

### Privacy

No contact persons, no phone numbers, and the buyer's e-mail address only when it is a role mailbox (inkoop@,
procurement@). Award notices show the winning organisations as published by law.

### Memory of "Only new notices"

- The memory is a key-value store called `eu-tenders-monitor-state` in your own Apify account. Delete it (or use a
  new monitor name) to start again.
- **Test runs count too.** Notices you receive while trying out filters will not come again. Test with another monitor
  name, or with Only new notices off, before you schedule the real monitor.
- With a monitor name, you can change the filters and keep the memory; without one, other filters mean a new memory.
- **If a run warns that the memory could not be opened:** create a key-value store under *Storage* in Apify Console
  (any name) and choose it in the input field **Memory store**. The Actor then keeps its memory there; one store can
  serve all your monitors. Until then each run returns all notices in the search window.

### Good to know

- Results are sorted newest first (by publication number). If a run hits its timeout, it stops searching and still delivers the newest
  notices; the status message tells you. If more notices match than `maxResults`, the status message says so too.
- TenderNed details (CPV codes, regions) are read for up to 400 new national notices per run; with Only new notices
  on, the rest follow in the next run, so nothing is skipped.
- A daily run for one country with keywords or CPV codes typically takes well under a minute.

### Limitations

- **Values depend on the buyer.** Publishing an estimated value is optional. Measured in October 2026 on 2,000 open
  tenders: 48% have one, with large differences per country (Italy and Sweden 100%, Czechia 82%, France 49%,
  Netherlands 43%, Belgium 24%, Germany 15%, Poland 16%). Award notices have a value in about 96% of cases.
  TenderNed's national notices publish no value through the open data service.
- The minimum value filter compares amounts in euro; values in other currencies (PLN, SEK, …) count as unknown.
- Keyword search uses TED's full-text search and TenderNed's search; CPV filtering is usually more precise.
- TED titles start with the country and the CPV description (for example "Netherlands – Software implementation
  services – …"); `titleOriginal` holds the title in the original language.

# Actor input Schema

## `sectors` (type: `array`):

The easiest way to choose the kind of work: each sector stands for a set of CPV codes (for example IT & software = CPV 48, 72 and 302). Combine with keywords or exact CPV codes below for more precision.

## `contractNatures` (type: `array`):

Leave empty for all.

## `keywords` (type: `array`):

Words or phrases in the notice (any of them). Leave empty for all notices. Tip: add the words in the local language too, for example cleaning, schoonmaak, Reinigung.

## `cpvCodes` (type: `array`):

Common Procurement Vocabulary codes (any of them). 8 digits include all sub-codes (90910000 = all cleaning services); shorter codes are prefixes (72 = all IT services).

## `countries` (type: `array`):

Leave empty for all EU/EEA countries. TenderNed is only used when the Netherlands is included (or no country is chosen).

## `noticeTypes` (type: `array`):

Default: contract notices (tenders open for bids).

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

When both are used, European notices come from TED (more detail) and TenderNed adds the national ones.

## `publishedWithinDays` (type: `integer`):

Search window. With "Only new notices" on, a daily schedule with the default of 7 days misses nothing and repeats nothing.

## `onlyNew` (type: `boolean`):

Remember what this monitor delivered before and return only new notices (the memory is kept in your own account). Turn off to get everything in the search window.

## `monitorName` (type: `string`):

Give each saved task its own name to keep their memories apart. Without a name, the filters decide which memory is used.

## `memoryStore` (type: `string`):

Only needed if a run warns that the memory for "Only new notices" could not be opened. Create a key-value store under Storage in Apify Console (any name) and choose it here; the Actor then keeps its memory there. One store can serve all your monitors.

## `minEstimatedValueEur` (type: `integer`):

Only notices with an estimated or awarded value of at least this amount.

## `includeWithoutValue` (type: `boolean`):

Many notices (and all TenderNed notices) publish no value. Keep them when a minimum value is set?

## `language` (type: `string`):

Language of `title`. TED translates the country and category part of the title; the name of the procedure (`shortTitle`) stays in its original language.

## `maxResults` (type: `integer`):

Newest notices first. If more match, the status message tells you how many; with Only new notices on, the rest follow in the next run.

## Actor input object example

```json
{
  "sectors": [
    "it_software"
  ],
  "countries": [
    "NL"
  ],
  "noticeTypes": [
    "contract_notice"
  ],
  "sources": [
    "TED",
    "TenderNed"
  ],
  "publishedWithinDays": 7,
  "onlyNew": true,
  "includeWithoutValue": true,
  "language": "eng",
  "maxResults": 1000
}
```

# Actor output Schema

## `notices` (type: `string`):

All notices delivered in this run.

## `overview` (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 = {
    "sectors": [
        "it_software"
    ],
    "countries": [
        "NL"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lowlands-data/eu-tenders-monitor-ted-tenderned-only-new-tenders").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 = {
    "sectors": ["it_software"],
    "countries": ["NL"],
}

# Run the Actor and wait for it to finish
run = client.actor("lowlands-data/eu-tenders-monitor-ted-tenderned-only-new-tenders").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 '{
  "sectors": [
    "it_software"
  ],
  "countries": [
    "NL"
  ]
}' |
apify call lowlands-data/eu-tenders-monitor-ted-tenderned-only-new-tenders --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lowlands-data/eu-tenders-monitor-ted-tenderned-only-new-tenders"
        }
    }
}
```

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/knTitVHEOANyUQMMa/builds/oINLIf2NISJDKJhW7/openapi.json