If you supply software, equipment or consulting services to public bodies, a useful tender feed starts with a specific question: which notices match your sector, and what has appeared since your last check?
You can build that feed from official sources. TED provides published procurement notices through a search API. The UK government's Find a Tender service provides notices as Open Contracting Data Standard (OCDS) JSON. This walkthrough collects notice metadata, remembers delivered IDs and exports new rows to CSV. There is also a no-code option below.
1. Choose the sources and the scope
TED: its public Search API accepts expert queries at POST https://api.ted.europa.eu/v3/notices/search, without authentication. Request only the fields you need. CPV codes describe the procurement category; buyer country and place of performance are separate filters. Official TED Search API documentation.
Find a Tender: the official release-package endpoint is GET https://www.find-tender.service.gov.uk/api/1.0/ocdsReleasePackages. An ocid identifies a procurement process, while a release represents a published notice or update within that process. GOV.UK Open Contracting documentation.
Neither source should be described as a complete list of every public purchasing opportunity. A notice feed is also different from a list of contracts you can still bid for. Check the notice type, current status and submission deadline before treating a result as an opportunity.
2. Collect new notice metadata with Python
Install the dependency with python -m pip install requests, then save this as tender_feed.py.
The example searches TED for recent IT-service competition notices from German buyers. It also collects recent UK releases across all stages, so an award or cancellation is not silently presented as a new invitation to tender. Adjust the TED filters for your market.
import csv
import json
from datetime import datetime, timedelta, timezone
from pathlib import Path
import requests
TED = "https://api.ted.europa.eu/v3/notices/search"
UK = "https://www.find-tender.service.gov.uk/api/1.0/ocdsReleasePackages"
STATE = Path("seen-notices.json")
MAX_PAGES = 100
def text(value):
if isinstance(value, dict):
value = value.get("eng") or next(iter(value.values()), "")
if isinstance(value, list):
value = value[0] if value else ""
return str(value or "")
def ted_rows(http, since):
query = (
f"publication-date>={since:%Y%m%d} "
"AND buyer-country=DEU "
"AND classification-cpv IN (72000000) "
"AND notice-type IN (cn-standard cn-social cn-desg)"
)
body = {
"query": query,
"fields": ["publication-number", "publication-date", "notice-title"],
"limit": 100,
"paginationMode": "ITERATION",
}
for _ in range(MAX_PAGES):
response = http.post(TED, json=body, timeout=60)
response.raise_for_status()
data = response.json()
notices = data.get("notices", [])
for notice in notices:
notice_id = notice["publication-number"]
yield {
"key": f"TED:{notice_id}",
"source": "TED",
"process_id": "",
"notice_id": notice_id,
"published": text(notice.get("publication-date"))[:10],
"stage": "competition notice",
"title": text(notice.get("notice-title")),
"url": f"https://ted.europa.eu/en/notice/-/detail/{notice_id}",
}
token = data.get("iterationNextToken")
# TED keeps returning a token: stop on a short or empty page.
if not token or len(notices) < body["limit"]:
return
body["iterationNextToken"] = token
raise RuntimeError("TED page cap reached; narrow the date window.")
def uk_rows(http, since, until):
url = UK
params = {
"updatedFrom": since.strftime("%Y-%m-%dT%H:%M:%S"),
"updatedTo": until.strftime("%Y-%m-%dT%H:%M:%S"),
"limit": 100,
}
for _ in range(MAX_PAGES):
response = http.get(url, params=params, timeout=60)
response.raise_for_status()
data = response.json()
for release in data.get("releases", []):
ocid, notice_id = release["ocid"], release["id"]
yield {
"key": f"FTS:{ocid}:{notice_id}",
"source": "UK Find a Tender",
"process_id": ocid,
"notice_id": notice_id,
"published": release.get("date", ""),
"stage": ", ".join(release.get("tag", [])),
"title": (release.get("tender") or {}).get("title", ""),
"url": f"https://www.find-tender.service.gov.uk/Notice/{notice_id}",
}
url = (data.get("links") or {}).get("next")
if not url:
return
params = None # Follow the returned cursor URL unchanged.
raise RuntimeError("UK page cap reached; narrow the date window.")
def main():
until = datetime.now(timezone.utc).replace(microsecond=0)
since = until - timedelta(days=2)
seen = set(json.loads(STATE.read_text(encoding="utf-8"))) if STATE.exists() else set()
fresh = {}
with requests.Session() as http:
http.headers["User-Agent"] = "tender-feed-example/1.0"
for row in ted_rows(http, since):
if row["key"] not in seen:
fresh[row["key"]] = row
for row in uk_rows(http, since, until):
if row["key"] not in seen:
fresh[row["key"]] = row
# Only replace the output and advance state after both sources succeed.
fields = ["key", "source", "process_id", "notice_id", "published", "stage", "title", "url"]
output = Path("new-notices.csv")
temporary = output.with_suffix(".tmp")
with temporary.open("w", newline="", encoding="utf-8") as handle:
writer = csv.DictWriter(handle, fieldnames=fields)
writer.writeheader()
writer.writerows(fresh.values())
temporary.replace(output)
state_tmp = STATE.with_suffix(".tmp")
state_tmp.write_text(json.dumps(sorted(seen | set(fresh))), encoding="utf-8")
state_tmp.replace(STATE)
print(f"{len(fresh)} new notice records saved to {output}")
if __name__ == "__main__":
main()
TED's iteration token retrieves subsequent result pages. For the UK endpoint, follow links.next rather than constructing a cursor yourself. The page cap is a safety limit in this example, not an API limit; reaching it stops the export with an error. TED pagination documentation, Find a Tender endpoint reference.
The UK API parameters have no timezone suffix; this example passes a UTC-based window. Verify the publisher's date handling for your integration and keep an overlap. The two-day window is an example setting, not a guarantee against late publication or longer outages.
3. Turn the export into a recurring check
Run python tender_feed.py once and inspect new-notices.csv. Then run it daily with your operating system's scheduler, using the same working directory and persistent seen-notices.json. Avoid overlapping runs. A fresh state file treats every result in the window as new.
The script replaces the CSV on each successful run, including a header-only file when there are no new records. Archive or consume each export before the next run. It does not send notifications. If you add delivery to another system, acknowledge delivery before marking records as delivered, and retain a retryable copy.
For a production monitor, add bounded retries for transient failures, respect Retry-After, and record failed runs. Expand the lookback after an outage. Keep separate IDs for a notice and a procurement process: deduplicating only on ocid would hide later releases.
To answer “is this still open?”, use the current procurement record and inspect deadlines and status. Simply keeping the last release you fetched is not a general substitute for OCDS compilation: a release can contain only part of a process. The OCDS releases and records guide explains the distinction.
4. Things that need a manual check
- Location: a buyer's address does not establish where the work takes place.
- Missing values: an absent budget or deadline is unknown, not zero or unlimited time.
- Language: a keyword in one language can miss notices written in another. Use CPV categories alongside carefully chosen keywords.
- Deadlines: check the original notice, lot and submission portal, including the time and timezone.
- Amendments: a newly delivered notice may amend an existing process. Preserve the relationship instead of counting each notice as a different contract.
The example exports IDs, titles, stages and source links. It does not export contact people, email addresses or award winners.
5. No-code option
I built EU & UK Public Tenders on Apify for a configured search and a flat export. It supports TED and Find a Tender, plus optional US federal tenders via SAM.gov with your own free key, with filters for countries, keywords, CPV categories and a publication window. Deadline and estimated-value fields are included where the source provides them.
Start with a narrow search. For a UK-only search, select UK and keep includeUk enabled. For a recurring discovery feed, enable onlyNew and keep the same monitorName and filters. Save the input as a task, inspect the first result, and add a daily Apify schedule.
Two limits matter:
- The Actor excludes building cleaning, caretaker, winter service and grounds maintenance tenders, as well as award notices. It does not add national opportunities absent from its sources.
- Its current UK “only new” mode remembers procurement IDs. Once a process has been delivered, later releases for that process are skipped. Use a separate update-tracking workflow if deadline changes matter. An unknown deadline also requires manual checking;
onlyOpenis not proof that every returned notice is still actionable.
Review the current Store pricing and run limits before scheduling.
(Disclosure: I built it. The Python example works independently of the Actor.)
Which matters more for your workflow: discovering new opportunities or tracking changes to ones you already follow?
Sources: TED, © European Union; UK Find a Tender. Contains public sector information licensed under the Open Government Licence v3.0.
Top comments (9)
I like that you explicitly separate "new opportunity discovery" from "procurement tracking." A lot of tender-monitoring examples stop at collecting notices, but in practice amendments, deadline changes, and award notices can be just as important as the original publication.
The distinction between OCDS releases and records is also something many developers overlook when building procurement integrations.
Thanks! Agreed, for alerts the change is the event. In OCDS terms the releases give you the history and the record's compiledRelease gives the current state, so a tracker usually needs both: releases to notice that something changed, the compiled state to show what it is now.
That's a really useful distinction, and it mirrors how a lot of event-driven systems work outside procurement too.
The release answers "what changed?" while the compiled record answers "what is true right now?".
I've seen a similar mistake in business reporting where people keep only the latest state and accidentally lose the story of how they got there. For monitoring, the history often contains the signal. If a deadline moved three times or a budget was revised twice, that sequence can be more informative than the current value alone.
It also explains why update tracking is so much harder than opportunity discovery. Finding a new notice is a lookup problem. Understanding how a procurement process evolves over time is closer to maintaining a timeline. Thanks for clarifying that. 👍
Exactly. And once each release is stored with its date, "the deadline moved" is a cheap check: compare
tender.tenderPeriod.endDatebetween consecutive releases for the sameocid.That's a neat way to make the change detectable without adding much complexity. Comparing
tender.tenderPeriod.endDateacross consecutive releases for the sameocidalso gives you a clear audit trail: not just that the deadline changed, but when the change first appeared. I'd be careful to distinguish an actual date change from a field being missing or a release not carrying the updated value, but the core check is simple and useful.Good point, and OCDS makes it a real case: a release isn't required to repeat unchanged fields, so a missing tenderPeriod.endDate means "not stated in this release", not "removed". Comparing each release against the last one that actually contained the field (or against the compiledRelease) avoids reporting that as a change.
Exactly. Treating an omitted field as a deletion is one of those subtle mistakes that can quietly corrupt an otherwise sound change-detection system. The distinction between “not stated in this release” and “explicitly changed or removed” is crucial, especially with OCDS releases that only contain incremental updates. Comparing against the last release that actually declared the field, while keeping the compiledRelease as a reference point, seems much more defensible. It also makes the audit trail far more useful because you're tracking real changes rather than artifacts of incomplete data.
Nice walkthrough. One addition from the buyer side: key your dedupe on the notice's stable identifier plus its version or publication date, not the ID alone. Tenders get corrigenda, deadline extensions and cancellations, and those usually arrive as new releases for the same process (the ocid in OCDS). If you only store delivered IDs, an extended deadline or a cancellation never reaches the user, and they keep preparing a bid for something that's gone. Storing a hash of the fields that matter (status, deadline, value) lets you flag "changed since last seen" separately from "new". CPV-only filtering also misses a lot, since buyers often pick broad codes, so a keyword pass on titles is a cheap second net.
Thanks, agreed on all three. The script in the post already keys UK rows on ocid plus release ID, so a corrigendum or cancellation published as a new release comes through as a new row with its stage, and TED rows are keyed per notice rather than per procedure. What it doesn't do is your second step: comparing status, deadline and value against the last seen version and flagging "changed" separately from "new". That's the right next step, and it's also the gap I listed for the Actor's UK "only new" mode, which currently remembers procurement IDs only. And yes on CPV: buyers often pick broad codes, which is why the Actor takes keywords and CPV codes together.