# EU/UK Procurement Buyer & Award Signals (`ikoles/eu-uk-procurement-buyer-award-signals`) Actor

Normalize recent opportunities and contract awards from TED, Find a Tender, and Contracts Finder into privacy-safe, deduplicated buyer and supplier signals.

- **URL**: https://apify.com/ikoles/eu-uk-procurement-buyer-award-signals.md
- **Developed by:** [Ilya Kalesnichenka](https://apify.com/ikoles) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 procurement signals

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## EU/UK Procurement Buyer & Award Signals

Turn recent public procurement notices into a normalized stream of buyer demand and verified award signals. The Actor queries the official TED, Find a Tender, and Contracts Finder APIs, applies the same local filters across sources, deduplicates overlapping records, explains its ranking, and exports attribution with every row.

### Why use this Actor?

- Monitor opportunities and awards across one EU source and two UK sources in one schema.
- Find demand by keyword, buyer country, CPV prefix, date window, and published value.
- Rank by best fit, newest publication, nearest opportunity deadline, or highest value.
- Merge semantically equivalent notices while preserving every official source reference.
- Continue when one source fails and disclose the failure in the run `OUTPUT` record.
- Use public APIs only: no credentials, browser, or proxy required.

### Quick start

```json
{
  "sources": ["ted", "find_tender", "contracts_finder"],
  "signalTypes": ["opportunity", "award"],
  "keywords": ["cyber security", "software"],
  "buyerCountries": ["GB", "DEU"],
  "cpvCodes": ["72"],
  "publishedAfter": "2026-07-01",
  "minValue": 100000,
  "rankingMode": "bestFit",
  "maxResults": 100
}
````

If `publishedAfter` is omitted, the Actor uses the UTC date two calendar days before the run starts. Date windows are inclusive. Deadline filters apply only to opportunities; award rows are not discarded because they have no tender deadline.

### Input

| Field | Type | Default | Meaning |
| --- | --- | --- | --- |
| `sources` | `string[]` | all three | Any of `ted`, `find_tender`, `contracts_finder`. |
| `signalTypes` | `string[]` | both | `opportunity`, `award`, or both. |
| `keywords` | `string[]` | `[]` | Up to 10 normalized terms matched against title and organization names. |
| `buyerCountries` | `string[]` | `[]` | Up to 30 ISO alpha-2 or alpha-3 codes. `GBR` is normalized to `GB`. |
| `cpvCodes` | `string[]` | `[]` | Up to 20 CPV codes or prefixes, 2–8 digits each. |
| `publishedAfter` | `YYYY-MM-DD` | run date minus 2 days | Earliest publication date. |
| `publishedBefore` | `YYYY-MM-DD` | not set | Latest publication date. |
| `deadlineAfter` | `YYYY-MM-DD` | not set | Earliest opportunity deadline. |
| `deadlineBefore` | `YYYY-MM-DD` | not set | Latest opportunity deadline. |
| `minValue` | nonnegative number | not set | Minimum published value in the record's native currency. Missing values are excluded. |
| `maxResults` | integer | `100` | Maximum eligible rows, from 1 to 1,000, before a spending limit is applied. |
| `rankingMode` | string | `bestFit` | `bestFit`, `newest`, `deadlineSoonest`, or `highestValue`. |

Currency values are not converted. Comparing or filtering values from different currencies is therefore not economically normalized.

### Output

Each Dataset row contains:

- a deterministic `signalId` and `signalType`;
- title, buyer organization reference, and machine-identified awardees when safely available;
- country, CPV, published value and currency, publication/deadline/award/contract dates;
- deterministic `fitScore` and `fitReasons`;
- one or more `sourceReferences` with official notice ID, public URL, license, and retrieval time.

The key-value store `OUTPUT` record summarizes selected/successful/failed sources, scanned and normalized counts, filtering and deduplication counts, free and charged rows, and whether the charge limit stopped delivery.

### Privacy boundary

This is an organization-level market signal, not a contact database. Source payloads can contain personal or direct-contact data such as `contactPoint`, postal details, email, or telephone values. The Actor uses those fields neither for output nor ranking, never stores the raw upstream payload, and exposes only the explicit Dataset schema. Awardees are emitted only when the source provides both a name and a machine identifier; otherwise the incomplete award signal is dropped.

### Pricing

The published Actor uses Apify pay per event:

- Actor start event `apify-actor-start`: **$0.00005**.
- Dataset event `procurement-signal`: **$0.002** per accepted paid signal.
- The first **10 free sample rows** are written without a paid event.
- After the sample, the Actor checks the run event limit before every row and stops cleanly when the limit is reached.
- The implicit default Dataset-item event must remain disabled to prevent double charging.

These event names and exact prices are validated at runtime. The active Store configuration contains no priced `apify-default-dataset-item` event, preventing a second charge for the same Dataset row. Use `maxTotalChargeUsd` when starting a run to set a hard event-charge ceiling; the Actor preserves rows already delivered and reports when the limit stops additional paid signals.

### Data licenses and attribution

- TED material is linked and attributed under the applicable **EU reuse policy**. Consult the official TED legal notice and the source notice for the current terms.
- Find a Tender and Contracts Finder OCDS data are used under the **Open Government Licence v3.0** (`OGL-3.0`).

Every row retains its official source URL, notice ID, license label, and `retrievedAt` timestamp. Do not remove attribution when redistributing the output.

### Limitations

Upstream public APIs differ in coverage, update timing, classification detail, and organization identifiers. Cross-source deduplication is deliberately conservative and may retain near-duplicates rather than incorrectly merge separate procedures. A best-fit score is a prioritization aid, not a legal, eligibility, sanctions, or supplier due-diligence decision. Always verify the linked official record before acting.

### Local development

```bash
npm ci
npm run check
npm run smoke:live
docker build -t eu-uk-procurement-buyer-award-signals .
```

`npm run smoke:live` is a bounded read-only check against the public source APIs. It writes no Apify Dataset rows and performs no publication.

# Actor input Schema

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

Official public procurement feeds to query.

## `signalTypes` (type: `array`):

Collect open opportunities, published awards, or both.

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

Up to 10 terms matched against titles and organization names.

## `buyerCountries` (type: `array`):

ISO 3166-1 alpha-2 or alpha-3 buyer country codes. GBR is normalized to GB.

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

Two- to eight-digit CPV codes or prefixes.

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

Inclusive UTC publication date. Defaults at runtime to two calendar days before the run starts.

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

Optional inclusive latest publication date.

## `deadlineAfter` (type: `string`):

Optional inclusive earliest opportunity deadline. Award rows are unaffected.

## `deadlineBefore` (type: `string`):

Optional inclusive latest opportunity deadline. Award rows are unaffected.

## `minValue` (type: `number`):

Minimum value in each source record's native currency; no currency conversion is performed.

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

Maximum number of eligible normalized signals before a run charge limit is applied.

## `rankingMode` (type: `string`):

Order signals by fit, publication recency, opportunity deadline, or published value.

## Actor input object example

```json
{
  "sources": [
    "ted",
    "find_tender",
    "contracts_finder"
  ],
  "signalTypes": [
    "opportunity",
    "award"
  ],
  "keywords": [],
  "buyerCountries": [],
  "cpvCodes": [],
  "maxResults": 100,
  "rankingMode": "bestFit"
}
```

# Actor output Schema

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

Rows saved to the run's default dataset.

## `summary` (type: `string`):

Collection, normalization, deduplication, delivery, and charge-limit counts.

# 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("ikoles/eu-uk-procurement-buyer-award-signals").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("ikoles/eu-uk-procurement-buyer-award-signals").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 ikoles/eu-uk-procurement-buyer-award-signals --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ikoles/eu-uk-procurement-buyer-award-signals",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EU/UK Procurement Buyer & Award Signals",
        "description": "Normalize recent opportunities and contract awards from TED, Find a Tender, and Contracts Finder into privacy-safe, deduplicated buyer and supplier signals.",
        "version": "0.1",
        "x-build-id": "ckmWREGJb7uEoC0FP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ikoles~eu-uk-procurement-buyer-award-signals/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ikoles-eu-uk-procurement-buyer-award-signals",
                "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/ikoles~eu-uk-procurement-buyer-award-signals/runs": {
            "post": {
                "operationId": "runs-sync-ikoles-eu-uk-procurement-buyer-award-signals",
                "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/ikoles~eu-uk-procurement-buyer-award-signals/run-sync": {
            "post": {
                "operationId": "run-sync-ikoles-eu-uk-procurement-buyer-award-signals",
                "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": {
                    "sources": {
                        "title": "Sources",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Official public procurement feeds to query.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "ted",
                                "find_tender",
                                "contracts_finder"
                            ],
                            "enumTitles": [
                                "TED (EU)",
                                "Find a Tender (UK)",
                                "Contracts Finder (England)"
                            ]
                        },
                        "default": [
                            "ted",
                            "find_tender",
                            "contracts_finder"
                        ]
                    },
                    "signalTypes": {
                        "title": "Signal types",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Collect open opportunities, published awards, or both.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "opportunity",
                                "award"
                            ],
                            "enumTitles": [
                                "Opportunities",
                                "Awards"
                            ]
                        },
                        "default": [
                            "opportunity",
                            "award"
                        ]
                    },
                    "keywords": {
                        "title": "Keywords",
                        "maxItems": 10,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Up to 10 terms matched against titles and organization names.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 100
                        },
                        "default": []
                    },
                    "buyerCountries": {
                        "title": "Buyer countries",
                        "maxItems": 30,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "ISO 3166-1 alpha-2 or alpha-3 buyer country codes. GBR is normalized to GB.",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Za-z]{2,3}$"
                        },
                        "default": []
                    },
                    "cpvCodes": {
                        "title": "CPV codes",
                        "maxItems": 20,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Two- to eight-digit CPV codes or prefixes.",
                        "items": {
                            "type": "string",
                            "pattern": "^\\d{2,8}$"
                        },
                        "default": []
                    },
                    "publishedAfter": {
                        "title": "Published after",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Inclusive UTC publication date. Defaults at runtime to two calendar days before the run starts."
                    },
                    "publishedBefore": {
                        "title": "Published before",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional inclusive latest publication date."
                    },
                    "deadlineAfter": {
                        "title": "Deadline after",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional inclusive earliest opportunity deadline. Award rows are unaffected."
                    },
                    "deadlineBefore": {
                        "title": "Deadline before",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional inclusive latest opportunity deadline. Award rows are unaffected."
                    },
                    "minValue": {
                        "title": "Minimum published value",
                        "minimum": 0,
                        "type": "number",
                        "description": "Minimum value in each source record's native currency; no currency conversion is performed."
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of eligible normalized signals before a run charge limit is applied.",
                        "default": 100
                    },
                    "rankingMode": {
                        "title": "Ranking",
                        "enum": [
                            "bestFit",
                            "newest",
                            "deadlineSoonest",
                            "highestValue"
                        ],
                        "type": "string",
                        "description": "Order signals by fit, publication recency, opportunity deadline, or published value.",
                        "default": "bestFit"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
