# Official EU Public Tender Opportunities API (`redfoxxie/official-eu-public-tenders-monitor`) Actor

Monitor active official EU competition notices from TED with bounded date, country, CPV, buyer, notice-type, and language filters plus deadlines, estimated values, source links, and explicit coverage telemetry.

- **URL**: https://apify.com/redfoxxie/official-eu-public-tenders-monitor.md
- **Developed by:** [João Ferreira](https://apify.com/redfoxxie) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 official eu tenders

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 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.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

Unofficial independent tool. It is not affiliated with, sponsored by, or
endorsed by the Publications Office of the European Union or Tenders Electronic
Daily.

Turn active EU procurement competition notices into a bounded, normalized feed
for alerts, research, CRM enrichment, agents, spreadsheets, and opportunity
monitoring. The Actor reads the anonymous official Tenders Electronic Daily
(TED) Search API. It does not scrape a reseller, infer award probabilities, or
claim that a notice is suitable for a particular supplier.

### What does the tender monitor return?

Each row includes the official publication number and date, competition notice
type, preferred-language title and buyers, places-of-performance countries, CPV
classifications, submission deadlines, estimated procedure or compatible lot
value when supplied, the official notice link, source attribution, retrieval
time, and coverage telemetry. The coverage object records the official result
count, number scanned, scan cap, timeout flag, truncation flag, and exact
official query, so a partial source scan cannot look complete.

Only official competition-stage notice types are eligible. Award notices and
planning notices that do not invite competition are excluded. Active API scope
and latest notice versions are requested, then every result is independently
filtered and deduplicated by publication number. This product normalizes the
source and labels that transformation; the official notice remains
authoritative.

### Example

Fetch recent software and IT opportunities:

```json
{
  "publicationStartDate": "",
  "publicationEndDate": "",
  "daysBack": 7,
  "noticeTypes": ["cn-standard", "pin-cfc-standard"],
  "countries": [],
  "cpvPrefixes": ["48", "72"],
  "search": "",
  "preferredLanguage": "eng",
  "scanLimit": 5000,
  "maxItems": 300
}
````

Country filters use ISO alpha-3 codes such as `PRT`, `ESP`, and `DEU`. CPV
filters are prefixes containing two to eight digits, so `72` covers the broad
IT-services family while `72000000` is narrower. Search is case-insensitive and
applies to the normalized title, buyers, country codes, and CPV codes. Explicit
publication dates override `daysBack`; the inclusive date span is capped at 30
days by the input contract.

### Source and reuse behavior

Records come from the official TED Search API at
`https://api.ted.europa.eu/v3/notices/search`. The official TED legal notice is
linked in every output row. TED procurement notices are published for reuse;
this independent product adds filtering, field selection, language preference,
normalization, deduplication, and coverage telemetry. It does not use an EU
institution logo or imply endorsement. Source attribution is retained and the
normalization is explicitly disclosed as a change from the source structure.

Multilingual fields prefer the requested three-letter TED language, then
English, then a deterministic available language. Procedure-level estimated
value takes priority. Lot values are summed only when their currencies are
compatible; otherwise the value is omitted instead of manufacturing a total.
Missing titles, values, or links remain missing. Dates, notice types, buyer
names, and deadlines can be corrected by publishers, so schedule a fresh run
before acting and retain `retrieved_at_utc`.

The API currently permits anonymous search, but availability and rate limits
remain controlled by the source. Pagination is bounded to 5,000 source notices
and 500 returned records. When a source result set is larger, each row says so
through `source_scan_truncated`. This is preferable to silently returning an
apparently complete subset.

### Pricing

The first 10 returned records in each run are free. Each additional
`official_eu_tender` costs **$0.004**. There is no start fee. The launch uses
**Pay per event + usage**, so Apify platform usage is billed separately to the
account running the Actor, including runs that return only free rows. At the
hard `maxItems=500` ceiling, the maximum custom event charge is $1.96.

### Responsible use and support

This feed is discovery infrastructure, not legal, procurement, financial, or
bid advice. Buyers can amend, cancel, postpone, or clarify notices. Users must
read the linked official notice, confirm eligibility, deadlines, documents,
language, jurisdiction, and applicable procurement rules before relying on a
record. For a reproducible parsing or filtering issue, open the Actor's Apify
Issues tab with the run ID, notice ID, query, and official URL.

# Actor input Schema

## `publicationStartDate` (type: `string`):

First inclusive TED publication date in YYYY-MM-DD form. Leave empty to derive it from days back.

## `publicationEndDate` (type: `string`):

Last inclusive TED publication date in YYYY-MM-DD form. Leave empty to use the current UTC date.

## `daysBack` (type: `integer`):

Publication lookback used only when publication start date is empty.

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

Official TED competition notice codes to include. Award and planning-only notices are excluded by design.

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

Optional ISO alpha-3 countries of performance, such as PRT, ESP, or DEU.

## `cpvPrefixes` (type: `array`):

Optional Common Procurement Vocabulary prefixes containing 2 to 8 digits, such as 72 for IT services.

## `search` (type: `string`):

Case-insensitive text matched against normalized notice titles, buyers, countries, and CPV codes.

## `preferredLanguage` (type: `string`):

Three-letter lowercase TED language code used for multilingual titles, buyers, and official notice links.

## `scanLimit` (type: `integer`):

Hard source-side scan cap. Coverage telemetry reports when the official result set exceeds it.

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

Hard cap on returned tender opportunities and possible paid events for one run.

## Actor input object example

```json
{
  "publicationStartDate": "2026-07-19",
  "publicationEndDate": "2026-07-20",
  "daysBack": 1,
  "noticeTypes": [
    "cn-standard",
    "pin-cfc-standard"
  ],
  "countries": [
    "PRT",
    "ESP"
  ],
  "cpvPrefixes": [
    "72",
    "48000000"
  ],
  "search": "software",
  "preferredLanguage": "eng",
  "scanLimit": 5000,
  "maxItems": 200
}
```

# Actor output Schema

## `tenders` (type: `string`):

One normalized row per official active competition notice matching the requested dates and filters.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("redfoxxie/official-eu-public-tenders-monitor").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("redfoxxie/official-eu-public-tenders-monitor").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 '{}' |
apify call redfoxxie/official-eu-public-tenders-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=redfoxxie/official-eu-public-tenders-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Official EU Public Tender Opportunities API",
        "description": "Monitor active official EU competition notices from TED with bounded date, country, CPV, buyer, notice-type, and language filters plus deadlines, estimated values, source links, and explicit coverage telemetry.",
        "version": "0.1",
        "x-build-id": "DRojepWgafANMK4V5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/redfoxxie~official-eu-public-tenders-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-redfoxxie-official-eu-public-tenders-monitor",
                "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/redfoxxie~official-eu-public-tenders-monitor/runs": {
            "post": {
                "operationId": "runs-sync-redfoxxie-official-eu-public-tenders-monitor",
                "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/redfoxxie~official-eu-public-tenders-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-redfoxxie-official-eu-public-tenders-monitor",
                "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": {
                    "publicationStartDate": {
                        "title": "Publication start date",
                        "pattern": "^$|^\\d{4}-\\d{2}-\\d{2}$",
                        "maxLength": 10,
                        "type": "string",
                        "description": "First inclusive TED publication date in YYYY-MM-DD form. Leave empty to derive it from days back.",
                        "default": ""
                    },
                    "publicationEndDate": {
                        "title": "Publication end date",
                        "pattern": "^$|^\\d{4}-\\d{2}-\\d{2}$",
                        "maxLength": 10,
                        "type": "string",
                        "description": "Last inclusive TED publication date in YYYY-MM-DD form. Leave empty to use the current UTC date.",
                        "default": ""
                    },
                    "daysBack": {
                        "title": "Days back",
                        "minimum": 0,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Publication lookback used only when publication start date is empty.",
                        "default": 1
                    },
                    "noticeTypes": {
                        "title": "Competition notice types",
                        "minItems": 1,
                        "maxItems": 7,
                        "type": "array",
                        "description": "Official TED competition notice codes to include. Award and planning-only notices are excluded by design.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "cn-desg",
                                "cn-social",
                                "cn-standard",
                                "pin-cfc-social",
                                "pin-cfc-standard",
                                "qu-sy",
                                "subco"
                            ]
                        },
                        "default": [
                            "cn-desg",
                            "cn-social",
                            "cn-standard",
                            "pin-cfc-social",
                            "pin-cfc-standard",
                            "qu-sy",
                            "subco"
                        ]
                    },
                    "countries": {
                        "title": "Performance countries",
                        "maxItems": 30,
                        "type": "array",
                        "description": "Optional ISO alpha-3 countries of performance, such as PRT, ESP, or DEU.",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Z]{3}$"
                        },
                        "default": []
                    },
                    "cpvPrefixes": {
                        "title": "CPV code prefixes",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Optional Common Procurement Vocabulary prefixes containing 2 to 8 digits, such as 72 for IT services.",
                        "items": {
                            "type": "string",
                            "pattern": "^\\d{2,8}$"
                        },
                        "default": []
                    },
                    "search": {
                        "title": "Title or buyer search",
                        "maxLength": 200,
                        "type": "string",
                        "description": "Case-insensitive text matched against normalized notice titles, buyers, countries, and CPV codes.",
                        "default": ""
                    },
                    "preferredLanguage": {
                        "title": "Preferred TED language",
                        "pattern": "^[a-z]{3}$",
                        "maxLength": 3,
                        "type": "string",
                        "description": "Three-letter lowercase TED language code used for multilingual titles, buyers, and official notice links.",
                        "default": "eng"
                    },
                    "scanLimit": {
                        "title": "Maximum source notices scanned",
                        "minimum": 250,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard source-side scan cap. Coverage telemetry reports when the official result set exceeds it.",
                        "default": 5000
                    },
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on returned tender opportunities and possible paid events for one run.",
                        "default": 200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
