# TED Procurement Radar - EU Tender Leads (`actorpilot/ted-procurement-radar`) Actor

Monitor EU public tenders from the official TED Search API with keyword, CPV, country, value, bid-status, deadline, lead-score, stable IDs, record hashes, and run summaries.

- **URL**: https://apify.com/actorpilot/ted-procurement-radar.md
- **Developed by:** [S. Klein](https://apify.com/actorpilot) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

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

## TED Procurement Radar - EU Tender Scraper (ted.europa.eu)

Monitor and extract EU public procurement notices from TED (Tenders Electronic Daily) through the official TED Search API. Search by keyword, CPV code, country, or notice number and get structured results for procurement intelligence, market research, and lead generation.

Try it free - about $0.001 per 10 notices.

Default runs are intentionally small and cheap: the Actor searches `software`, saves up to 5 notices, and writes a `RUN_SUMMARY` record to the default key-value store.

***

### Who uses TED Procurement Radar

- **Business Development Managers** at IT services and consulting firms monitoring contracts in their sector
- **Procurement Officers** tracking competitor awards and market rates
- **Sales Teams** at construction, engineering, and technology companies identifying actionable leads
- **Market Researchers** analyzing public spending patterns by country and sector
- **Automation Engineers** building tender-alert pipelines with n8n, Zapier, or custom webhooks

***

### What does TED Procurement Radar do?

This Actor uses the official TED Search API and returns normalized procurement data that is ready for analysis, export, and integration.

In one run you can:

- Monitor new tenders by keyword
- Look up specific notice IDs
- Filter by country or CPV code
- Prioritize opportunities by value, deadline, and bid status
- Export structured procurement data into your CRM or BI workflow

***

### Why use TED Procurement Radar?

#### Official TED API, not HTML scraping

- More stable than browser scraping
- Faster and cheaper to run
- No JavaScript rendering needed
- Better resilience when TED changes its frontend

#### Useful for procurement intelligence

| Your need | How this Actor helps |
|---|---|
| Tender monitoring | Track fresh notices automatically |
| Market research | Filter by country, buyer type, and sector |
| Procurement intelligence | Analyze award winners, values, and deadlines |
| App development | Get normalized JSON instead of raw code-heavy API output |
| Lead generation | Filter to actionable notices with `canBid: true` |

#### Normalized output

The Actor converts raw procurement codes into human-readable labels, including CPV, NUTS, buyer legal type, and notice metadata.

***

### How to use TED Procurement Radar

1. Click **Try for free**
2. Enter a keyword or notice number in `searchPhrase`
3. Set `maxItems`
4. Enable `includeNoticeDetails` for richer output
5. Start the run
6. Download results as JSON, CSV, Excel, or XML

For ongoing monitoring, schedule daily or weekly runs on Apify.

***

### Input

| Field | Type | Description | Default |
|---|---|---|---|
| `searchPhrase` | string | Keyword or notice number | required |
| `maxItems` | integer | Maximum notices to return | 5 |
| `includeNoticeDetails` | boolean | Fetch full detail fields | true |
| `onlyLatestVersions` | boolean | Skip older amended versions | true |
| `maxRequestsPerCrawl` | integer | Limit fetched API pages | 5 |
| `searchCountry` | string | ISO 2-letter country code such as `DE` | none |
| `searchCpv` | string | CPV prefix such as `45` | none |
| `minEstimatedValueEur` | integer | Minimum contract value in EUR | 0 |
| `includeLeadScore` | boolean | Calculate a lead score | true |
| `maxRetries` | integer | Retries for temporary TED API failures | 2 |
| `requestTimeoutSecs` | integer | Timeout per TED API request | 30 |
| `testMode` | boolean | Tiny stable health-check run | false |

Example input:

```json
{
  "searchPhrase": "solar energy",
  "maxItems": 50,
  "includeNoticeDetails": true,
  "onlyLatestVersions": true,
  "maxRequestsPerCrawl": 10,
  "searchCountry": "DE",
  "searchCpv": "09",
  "minEstimatedValueEur": 100000,
  "includeLeadScore": true,
  "maxRetries": 2,
  "requestTimeoutSecs": 30
}
```

***

### Key CPV Code Reference

CPV (Common Procurement Vocabulary) codes classify contracts by type. Use the `searchCpv` input to filter by sector.

| CPV Prefix | Sector |
|---|---|
| `09` | Energy (electricity, gas, oil, nuclear) |
| `30` | Office and computing machinery |
| `33` | Medical equipment and pharmaceuticals |
| `45` | Construction works |
| `48` | Software packages and information systems |
| `50` | Repair and maintenance services |
| `71` | Architectural and engineering services |
| `72` | IT services (consulting, programming, support) |
| `79` | Business services (legal, marketing, recruitment) |
| `90` | Environmental services |

Tip: Use a 2-digit prefix (e.g. `72`) to catch all IT sub-categories, or a full 8-digit code for precision.

***

### Output

Each item represents one TED procurement notice.

Example output item:

```json
{
  "recordType": "tender_notice",
  "source": "TED Search API",
  "scrapedAt": "2026-07-03T12:30:00.000Z",
  "searchPhrase": "solar energy",
  "expertQuery": "FT=\"solar energy\" SORT BY publication-number DESC",
  "recordHash": "a2f2...",
  "noticeId": "391694-2026",
  "url": "https://ted.europa.eu/en/notice/-/detail/391694-2026",
  "noticeTitle": "Electricity - Solar photovoltaic installation for community energy sharing",
  "noticeType": "Contract or concession notice - standard regime",
  "noticeStatus": "open",
  "canBid": true,
  "country": "Spain",
  "publicationDate": "2026-06-08",
  "deadlineDate": "2026-07-16",
  "deadlineDaysRemaining": 37,
  "urgencyFlag": false,
  "buyerName": "Pleno del Ayuntamiento de Talayuela",
  "buyerLegalType": "Local authority",
  "estimatedValueNum": 2601897.21,
  "estimatedValueCurrency": "EUR",
  "cpvMain": "09310000",
  "cpvMainLabel": "Electricity",
  "contractSizeCategory": "large (>1M EUR)",
  "leadScore": 80,
  "leadScoreReason": "Strong lead: EUR 2,601,897.21 contract value, 37 days to bid."
}
```

Key output fields:

- `recordType`, `source`, `scrapedAt`, `searchPhrase`, `expertQuery`, `recordHash`
- `noticeId`, `url`, `noticeTitle`, `noticeType`
- `noticeStatus`, `canBid`
- `buyerName`, `buyerLegalType`, `buyerCountry`
- `publicationDate`, `deadlineDate`, `deadlineDaysRemaining`
- `estimatedValueNum`, `estimatedValueCurrency`
- `cpvMain`, `cpvMainLabel`
- `leadScore`, `leadScoreReason`, `leadScoreFactors`

The default key-value store also contains `RUN_SUMMARY`:

```json
{
  "record_type": "run_summary",
  "status": "SUCCEEDED",
  "requested_items": 5,
  "saved_items": 5,
  "total_notice_count": 456303,
  "warnings": [],
  "errors": []
}
```

***

### Use with AI agents via Apify MCP

This Actor can be used from Claude, Codex, Cursor, VS Code, Windsurf, Zed, and other MCP-compatible AI tools through Apify's Actors MCP server.

Important: this Actor is not a standalone remote MCP server. You connect Apify's Actors MCP server once, then ask your assistant to use the TED actor.

#### MCP setup

Add this MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server"],
      "env": {
        "APIFY_TOKEN": "your_apify_api_token_here"
      }
    }
  }
}
```

#### Copy-paste prompt for AI tools

If your assistant can configure MCP for you, paste this:

```text
Please set up Apify's Actors MCP server in my MCP configuration.

Use this package:
- command: npx
- args: -y @apify/actors-mcp-server

Set my APIFY_TOKEN in the MCP environment.

After setup, use the Apify actor "ted-procurement-radar" and help me search TED tenders from chat.
```

#### Example prompts after setup

- Use the `ted-procurement-radar` actor to find open German tenders for `cybersecurity` with at least EUR 100,000 estimated value.
- Search TED for `solar energy` notices in Spain and summarize the best opportunities.
- Look up notice `391742-2026` and explain whether it is still open for bidding.
- Run the actor for CPV code `45` and return the most urgent opportunities with deadlines in the next 14 days.

#### Client notes

- Claude, Codex, Cursor, VS Code, Windsurf, and Zed can usually use the stdio MCP config above directly.
- n8n, LangChain, OpenAI Agents SDK, Gemini, and custom apps can use the same Apify actor capability, but the exact MCP plumbing depends on the client environment.

***

### How much does it cost to scrape TED notices?

| Run size | Estimated cost |
|---|---|
| 10 notices | ~$0.001 |
| 100 notices | ~$0.01 |
| 1,000 notices | ~$0.10 |
| 10,000 notices | ~$1.00 |

New Apify accounts receive $5 in free monthly credits.

***

### Tips

- Use specific technical keywords instead of broad generic terms.
- Use local-language keywords for country-specific notice discovery.
- Schedule daily runs with `onlyLatestVersions: true` for monitoring workflows.
- Filter downstream to `canBid: true` if you only want active opportunities.
- Use direct notice IDs in `searchPhrase` for exact lookup.
- Use `testMode: true` for a tiny health-check run that should finish quickly and cheaply.

#### Understanding the lead score

The lead score helps prioritize open notices. Higher scores usually indicate a combination of disclosed value, active deadline, useful bidding window, and strong commercial relevance.

***

### Automate Tender Monitoring

For ongoing monitoring, combine Apify scheduling with a notification channel:

**Apify Schedule + Webhook to Slack**

1. Open the Actor on Apify and click **Schedule**
2. Set a daily or weekly trigger
3. Under **Webhooks**, add a Slack incoming webhook URL
4. The Actor posts new tenders directly to your Slack channel

**Apify + n8n Pipeline**

1. Use the Apify n8n node to trigger the Actor on schedule
2. Filter results in n8n where `canBid: true` and `deadlineDaysRemaining < 30`
3. Create HubSpot deals or send email alerts for matching notices

**Direct API Integration**
Run the Actor via the Apify API and pull results into your CRM or BI tool:

```json
POST https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs
Authorization: Bearer YOUR_TOKEN
```

***

### FAQ

**Is this an official EU tool?**
No. This is an independent Actor built on the public TED Search API.

**Is it legal to use?**
TED publishes procurement notices as public information. You remain responsible for compliant use under applicable rules and Apify terms.

**Why not use the TED API directly?**
You can, but this Actor already handles pagination, normalization, label mapping, and export.

**Does it work for all EU countries?**
Yes, TED covers all EU member states and additional participating jurisdictions.

**What happens if TED returns no matching notices?**
The run finishes successfully with no dataset rows and a `RUN_SUMMARY.status` of `NO_RESULTS`. Source/API failures still fail the run.

**What is a CPV code and how do I find the right one?**
CPV codes are standardised EU product/service classification codes. Use the table above as a starting point. For precise targeting, search the official CPV database at simap.ted.europa.eu.

**How do I get notified when new tenders appear?**
Schedule the Actor to run daily with `onlyLatestVersions: true`. Use Apify Webhooks or the n8n integration to push new results to Slack, email, or your CRM automatically.

**Can I monitor multiple countries at once?**
Run the Actor without a `searchCountry` filter to get results across all EU member states. Then filter downstream by the `country` field in the output.

**Do you support custom procurement workflows?**
Yes. Contact us through the Apify platform for custom monitoring or integration work.

# Actor input Schema

## `searchPhrase` (type: `string`):

Search term used on TED. Use a keyword such as software, a notice ID such as 460644-2026, or a TED expert query.

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

Maximum number of tender notices to save to the dataset.

## `includeNoticeDetails` (type: `boolean`):

Request additional buyer, CPV, value, procedure, winner, and deadline fields from the TED API.

## `onlyLatestVersions` (type: `boolean`):

Use TED's latest-version filter to avoid older changed notice revisions where possible.

## `searchCountry` (type: `string`):

Optional ISO 2-letter country code. Leave empty for all countries.

## `searchCpv` (type: `string`):

Optional CPV prefix such as 45 for construction work, 72 for IT services, or a full CPV code for precision.

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

Only save notices with an estimated contract value at or above this amount. Use 0 to disable.

## `includeLeadScore` (type: `boolean`):

Calculate a 0-100 sales-opportunity score from value, deadline, notice type, buyer type, and award status.

## `maxRequestsPerCrawl` (type: `integer`):

Safety limit for TED API page requests during one run.

## `maxRetries` (type: `integer`):

How many times to retry temporary TED API failures such as HTTP 429, 5xx, or network timeouts.

## `requestTimeoutSecs` (type: `integer`):

Timeout in seconds for each TED API request.

## `testMode` (type: `boolean`):

Use a tiny stable software search and save at most 3 notices. Useful for Apify health checks and quick tests.

## Actor input object example

```json
{
  "searchPhrase": "software",
  "maxItems": 25,
  "includeNoticeDetails": true,
  "onlyLatestVersions": true,
  "searchCountry": "",
  "searchCpv": "72",
  "minEstimatedValueEur": 100000,
  "includeLeadScore": true,
  "maxRequestsPerCrawl": 10,
  "maxRetries": 2,
  "requestTimeoutSecs": 30,
  "testMode": false
}
```

# Actor output Schema

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

No description

## `runSummary` (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 = {
    "searchPhrase": "software",
    "maxItems": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("actorpilot/ted-procurement-radar").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 = {
    "searchPhrase": "software",
    "maxItems": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("actorpilot/ted-procurement-radar").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 '{
  "searchPhrase": "software",
  "maxItems": 5
}' |
apify call actorpilot/ted-procurement-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=actorpilot/ted-procurement-radar",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/OJPpMtIK27d6tkkDx/builds/BOtbaIMr9VkQLJIEm/openapi.json