# Dutch Public Procurement — TenderNed Scraper, No Login Required (`studio-amba/tenderned-scraper`) Actor

Search and extract Dutch public procurement tenders from TenderNed. Filter by keyword, CPV code, contract type, or date range. Returns tender name, contracting authority, deadline, procedure type, and full announcement details. No cookies, no login.

- **URL**: https://apify.com/studio-amba/tenderned-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 73.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 result scrapeds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Dutch Public Procurement Scraper — TenderNed Tenders

Search and extract Dutch public procurement tenders from TenderNed, the Netherlands' official government procurement platform. Filter by keyword, contract type, scope, or date range. Returns tender title, contracting authority, deadline, procedure type, CPV codes, NUTS region codes, and full announcement details. No cookies, no login required.

### How to scrape TenderNed data

This actor queries the official TenderNed publication API to deliver structured tender data. TenderNed is the Dutch government's mandatory publication platform — all Dutch authorities are legally required to publish their procurement tenders here. That means this actor gives you access to every public tender in the Netherlands, covering services, supplies, and works contracts across central government, municipalities, provinces, water boards, and public enterprises.

The actor fetches both the list overview and detailed publication pages, extracting CPV classification codes, NUTS region codes, legal framework info, and PDF links that are not available from the list view alone.

#### Who benefits from this data?

- **Government contractors** — Monitor new opportunities daily. Filter by your industry CPV codes and never miss a relevant tender.
- **Consultancies and advisory firms** — Track procurement patterns across Dutch government bodies for market intelligence.
- **B2B sales teams** — Identify which government bodies are buying what you sell. Build targeted prospect lists.
- **Market researchers** — Analyze procurement volumes, trends, and seasonal patterns across sectors.
- **Compliance and legal teams** — Monitor competitor contract awards and procurement procedural compliance.

#### Search by keyword

Enter any keyword to find relevant tenders. The actor searches across tender titles, descriptions, and contracting authority names. Use Dutch for the best results — "IT diensten", "bouw", "schoonmaak", "software", "advies", "beveiliging".

#### Filter by status, contract type, and scope

- **Status**: Open (active tenders you can bid on), closed, or all
- **Contract type**: Services (diensten), supplies (leveringen), or works (werken)
- **Scope**: EU tenders (above EU thresholds, ~EUR 215K for services) or national tenders for smaller opportunities

#### Date range filtering

Set publication date filters to monitor new tenders, or search historically for market research. The `publishedAfter` and `publishedBefore` fields accept YYYY-MM-DD format.

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQuery` | String | `ICT` | Keywords to search in tender titles, descriptions, and organizations |
| `tenderStatus` | Enum | `open` | Filter: `open`, `closed`, or `all` |
| `contractType` | Enum | `all` | Filter: `all`, `services`, `supplies`, or `works` |
| `scope` | Enum | `all` | Filter: `all`, `eu`, or `national` |
| `publishedAfter` | String | — | Only tenders published on or after this date (YYYY-MM-DD) |
| `publishedBefore` | String | — | Only tenders published on or before this date (YYYY-MM-DD) |
| `maxResults` | Integer | `100` | Maximum number of tenders to return (1–10,000) |
| `proxyConfiguration` | Object | NL residential | Apify proxy settings |

### What data does this scraper extract?

| Field | Type | Description |
|-------|------|-------------|
| `title` | String | Tender title (aanbestedingNaam) |
| `referenceNumber` | String | TenderNed reference number (e.g., TN-592549) |
| `organization` | String | Contracting authority name |
| `status` | String | Tender status (Gepubliceerd, Gesloten, etc.) |
| `publicationDate` | String | Publication date (YYYY-MM-DD) |
| `deadline` | String | Bid submission deadline (ISO timestamp, if set) |
| `estimatedValue` | String | Estimated contract value (when available) |
| `currency` | String | Always EUR |
| `contractType` | String | Services, Supplies, or Works |
| `scope` | String | EU or National |
| `procedureType` | String | Open, restricted, negotiated, etc. |
| `publicationType` | String | Announcement type (market consultation, contract notice, etc.) |
| `category` | String | Nature of the contract |
| `cpvCodes` | Array | CPV classification codes with descriptions and primary flag |
| `nutsCodes` | Array | NUTS region codes with descriptions |
| `region` | String | Human-readable region from NUTS codes |
| `description` | String | Full tender description |
| `isDigital` | Boolean | Whether digital submission is available |
| `legalFramework` | String | Applicable procurement law |
| `url` | String | Direct link to tender on TenderNed |
| `pdfUrl` | String | PDF announcement URL |
| `scrapedAt` | String | ISO timestamp of when the data was scraped |

### Example output

```json
{
    "title": "Marktverkenning ISMS-, PIMS- en risicomanagementtooling (GRC)",
    "referenceNumber": "TN-592549",
    "organization": "Gemeente Emmen",
    "status": "Gepubliceerd",
    "publicationDate": "2026-05-27",
    "deadline": "",
    "estimatedValue": "",
    "currency": "EUR",
    "contractType": "Leveringen",
    "scope": "National",
    "procedureType": "Marktconsultatie",
    "publicationType": "Marktconsultatie",
    "category": "",
    "cpvCodes": [
        {
            "code": "48730000",
            "description": "Beveiligingssoftware",
            "isPrimary": true
        },
        {
            "code": "72200000",
            "description": "Softwareprogrammering en -advies",
            "isPrimary": false
        }
    ],
    "nutsCodes": [
        {
            "code": "NL131",
            "description": "Noord-Drenthe"
        }
    ],
    "region": "Noord-Drenthe",
    "description": "De gemeente Emmen organiseert een marktverkenning...",
    "isDigital": true,
    "legalFramework": "Aanbestedingswet 2012",
    "url": "https://www.tenderned.nl/aankondigingen/overzicht/426684",
    "pdfUrl": "https://www.tenderned.nl/papi/tenderned-rs-tns/v2/publicaties/426684/pdf",
    "scrapedAt": "2026-05-27T14:30:00.000Z"
}
````

### Tips for best results

- **Daily monitoring**: Run on a schedule to catch new tenders within hours of publication. Set `publishedAfter` to today's date for fresh opportunities only.
- **CPV code targeting**: After initial results, note the CPV codes relevant to your business. Use them to identify patterns — 72000000 = IT services, 45000000 = construction, 71000000 = architectural services.
- **Competitor intelligence**: Search by competitor names or specific service descriptions to see what contracts they are pursuing.
- **Market sizing**: Run without keyword filters to count total active tenders in a category, useful for business development planning.
- **Combine with other sources**: Pair with [EU TED tenders](https://ted.europa.eu) data for full European procurement coverage.

### How much does it cost to run?

The actor uses the TenderNed public API, which is free. Your only cost is Apify compute time and proxy usage.

| Search size | Estimated time | Estimated cost |
|-------------|---------------|----------------|
| 20 tenders | ~30 seconds | ~$0.01 |
| 100 tenders | ~3 minutes | ~$0.05 |
| 500 tenders | ~15 minutes | ~$0.20 |
| 1,000 tenders | ~30 minutes | ~$0.40 |

Each tender requires one extra API call to fetch detailed data (CPV codes, NUTS codes, PDF link), so times are higher than a simple list-only scrape.

### Use as an API

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/tenderned-scraper").call(run_input={
    "searchQuery": "software",
    "tenderStatus": "open",
    "contractType": "services",
    "maxResults": 50,
})

for tender in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{tender['title']} | {tender['organization']} | Deadline: {tender['deadline']}")
```

### Limitations

- **No server-side text search**: The TenderNed list API does not support keyword filtering. The actor fetches pages and filters client-side by matching against title, description, and organization. For large result sets without keyword filters, the scrape is faster.
- **Deadline may be empty**: Not all tender types have a submission deadline (e.g., market consultations).
- **Estimated value**: TenderNed rarely exposes contract values in the API; this field is often empty.
- **Detail fetching adds time**: Each tender gets an individual API call for CPV/NUTS codes. Set `maxResults` accordingly.

### Other European procurement scrapers

- Check the [Studio AMBA actor catalog](https://apify.com/studio-amba) for more European data scrapers.

### Your feedback

Found a bug or want a feature? Open an issue on the [Issues tab](https://console.apify.com/actors/studio-amba~tenderned-scraper/issues).

# Actor input Schema

## `searchQuery` (type: `string`):

Search tenders by keyword (matched against title and description). Use Dutch for best results. Examples: 'ICT', 'software', 'bouw', 'schoonmaak'.

## `tenderStatus` (type: `string`):

Filter by tender status.

## `contractType` (type: `string`):

Filter by contract type.

## `scope` (type: `string`):

Filter by tender scope.

## `publishedAfter` (type: `string`):

Only tenders published on or after this date. Format: YYYY-MM-DD.

## `publishedBefore` (type: `string`):

Only tenders published on or before this date. Format: YYYY-MM-DD.

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

Maximum number of tenders to return.

## `proxyConfiguration` (type: `object`):

Apify proxy configuration.

## Actor input object example

```json
{
  "searchQuery": "ICT",
  "tenderStatus": "open",
  "contractType": "all",
  "scope": "all",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "NL"
  }
}
```

# 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 = {
    "searchQuery": "ICT",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "NL"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/tenderned-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 = {
    "searchQuery": "ICT",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "NL",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/tenderned-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQuery": "ICT",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "NL"
  }
}' |
apify call studio-amba/tenderned-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=studio-amba/tenderned-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Dutch Public Procurement — TenderNed Scraper, No Login Required",
        "description": "Search and extract Dutch public procurement tenders from TenderNed. Filter by keyword, CPV code, contract type, or date range. Returns tender name, contracting authority, deadline, procedure type, and full announcement details. No cookies, no login.",
        "version": "0.0",
        "x-build-id": "cJgPXyXZYTboBte1h"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~tenderned-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-tenderned-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/studio-amba~tenderned-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-tenderned-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/studio-amba~tenderned-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-tenderned-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQuery": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Search tenders by keyword (matched against title and description). Use Dutch for best results. Examples: 'ICT', 'software', 'bouw', 'schoonmaak'."
                    },
                    "tenderStatus": {
                        "title": "Tender Status",
                        "enum": [
                            "open",
                            "closed",
                            "all"
                        ],
                        "type": "string",
                        "description": "Filter by tender status.",
                        "default": "open"
                    },
                    "contractType": {
                        "title": "Contract Type",
                        "enum": [
                            "all",
                            "services",
                            "supplies",
                            "works"
                        ],
                        "type": "string",
                        "description": "Filter by contract type.",
                        "default": "all"
                    },
                    "scope": {
                        "title": "Scope",
                        "enum": [
                            "all",
                            "eu",
                            "national"
                        ],
                        "type": "string",
                        "description": "Filter by tender scope.",
                        "default": "all"
                    },
                    "publishedAfter": {
                        "title": "Published After",
                        "type": "string",
                        "description": "Only tenders published on or after this date. Format: YYYY-MM-DD."
                    },
                    "publishedBefore": {
                        "title": "Published Before",
                        "type": "string",
                        "description": "Only tenders published on or before this date. Format: YYYY-MM-DD."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of tenders to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy configuration."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```