DEV Community: Agentica

UK tender alerts after Brexit: Contracts Finder vs Find a Tender

Agentica — Fri, 16 Oct 2026 23:01:20 +0000

A while ago I wrote about pulling EU tenders from TED into Google Sheets. The obvious follow-up was the UK.

UK notices stopped appearing on TED at the start of 2021. They now live on two UK government services, and which one a tender ends up on depends mostly on how big it is.

Two services, two audiences

Find a Tender handles the higher-value contracts, roughly the ones that used to go to TED.

Contracts Finder carries lower-value opportunities, mostly in England, along with plenty of award notices and early market engagement.

If you only check one, you'll miss things. A two-person IT consultancy will probably find more on Contracts Finder, while a facilities firm going after multi-year frameworks will spend most of its time on Find a Tender.

Both have open APIs

Both services publish notices as OCDS (Open Contracting Data Standard) JSON under the Open Government Licence v3.0. You can reuse the data commercially as long as you credit where it came from, and you don't need an API key.

There are a few things to watch:

Find a Tender sends back HTTP 429 with a Retry-After header if you go too fast. Wait the number of seconds it gives you.
Contracts Finder uses HTTP 403 for the same thing, and its docs ask you to leave it alone for five minutes.
Contracts Finder's search feed sometimes shows deadlines a few hours off from the notice itself. I only caught it when I compared a batch against the individual notices. If the deadline matters (and it always does), take it from the per-notice endpoint instead.

The search endpoints only filter by date and stage, so keywords, CPV codes and value filters are your job.

GET https://www.find-tender.service.gov.uk/api/1.0/ocdsReleasePackages?stages=tender&updatedFrom=2026-10-14T00:00:00&limit=100
GET https://www.contractsfinder.service.gov.uk/Published/Notices/OCDS/Search?stages=tender&publishedFrom=2026-10-14T00:00:00&limit=100

Page through with links.next. The deadline sits in tender.tenderPeriod.endDate and the estimated value in tender.value.

One thing that surprised me: on a typical week, each service only has a few dozen new tender-stage notices. That's small enough to pull everything and filter locally.

The lazy option

If you'd rather not maintain the plumbing yourself, I've wrapped all of this into an Apify actor: UK Public Tenders Tracker. It searches both services, filters by keyword, CPV prefix, value, region and deadline, and can return only what's new or changed since your last run, which is handy for a daily email or Sheets row. It costs $0.004 per tender, with no subscription.

The output fields are close to the TED version, so one sheet can hold both if you bid on either side of the Channel.

Contains public sector information licensed under the Open Government Licence v3.0. Not affiliated with or endorsed by the Cabinet Office, Contracts Finder or Find a Tender.

Daily EU public tender alerts in Google Sheets with the free TED API

Agentica — Fri, 16 Oct 2026 18:14:17 +0000

The EU publishes every above-threshold public tender on TED (Tenders Electronic Daily), and it offers a free search API that needs no API key. This post builds a small job that:

asks TED for tenders matching your CPV codes and countries,
keeps only notices that are new or changed since the last run,
appends them to a Google Sheet every morning.

1. Can I reuse TED data?

Yes. The Publications Office's legal notice (https://ted.europa.eu/en/legal-notice) says procurement notices "can be freely reused, for commercial or non-commercial purposes", and its editorial content is under CC BY 4.0. That means you credit the source and say what you changed. Don't use the TED logo. Be polite with requests: TED publishes a fair-usage policy (https://ted.europa.eu/en/news/fair-usage-policy-on-ted) and recommends that technical users call the public API instead of scraping the website.

2. Query the search API

The endpoint is POST https://api.ted.europa.eu/v3/notices/search (docs: https://docs.ted.europa.eu/api/latest/search.html). Queries use TED's expert-search syntax:

curl -s https://api.ted.europa.eu/v3/notices/search \
  -H 'Content-Type: application/json' \
  -d '{
    "query": "classification-cpv IN (72000000) AND buyer-country IN (DEU FRA) AND publication-date>=20261014",
    "fields": ["publication-number","notice-title","buyer-name","buyer-country","classification-cpv","publication-date","deadline-receipt-tender-date-lot","links"],
    "limit": 100,
    "paginationMode": "ITERATION"
  }'

Tips:

Country codes are ISO alpha-3 (DEU, not DE). CPV codes are 8 digits.
Use "paginationMode": "ITERATION" for big result sets: send each response's iterationNextToken back as "iterationNextToken" in the next request body, and stop when a page returns no notices.
Titles and buyer names come back per language (e.g. {"eng": "...", "deu": "..."}). Pick eng and fall back to whatever is present (see pick() below).
Not every notice has deadline-receipt-tender-date-lot (e.g. award notices), so treat it as optional.

3. Detect new vs changed notices

TED republishes notices when they change. Hash the fields you care about and store publication-number → hash:

import hashlib, json

def fingerprint(n):
    keep = {k: n.get(k) for k in ("notice-title", "deadline-receipt-tender-date-lot", "buyer-name")}
    return hashlib.sha1(json.dumps(keep, sort_keys=True).encode()).hexdigest()[:16]

def diff(notices, seen):           # seen: dict loaded from a JSON file
    out = []
    for n in notices:
        key, fp = n["publication-number"], fingerprint(n)
        if seen.get(key) != fp:
            out.append({**n, "status": "new" if key not in seen else "changed"})
            seen[key] = fp
    return out

4. Append to Google Sheets

Note: I tested the TED query and the dedup logic against the live API. I have not yet run the Google Sheets step end to end with real Google credentials, so check the auth setup against the gspread docs before relying on it.

With gspread and a service account that has edit access to the sheet:

import json, pathlib
import gspread

def pick(v, lang="eng"):
    """TED returns per-language dicts (sometimes holding lists): prefer English, else the first value."""
    if isinstance(v, dict):
        v = v.get(lang) or next(iter(v.values()), None)
    if isinstance(v, list):
        v = ", ".join(map(str, v))
    return "" if v is None else str(v)

state = pathlib.Path("seen.json")
seen = json.loads(state.read_text()) if state.exists() else {}
rows = diff(notices, seen)         # notices = response["notices"] from step 2
state.write_text(json.dumps(seen))

if rows:
    ws = gspread.service_account().open("EU tenders").sheet1
    ws.append_rows([[n["publication-number"], n["status"], pick(n.get("notice-title")),
                     pick(n.get("buyer-name")), n.get("publication-date"),
                     pick(n.get("deadline-receipt-tender-date-lot"))] for n in rows])

Run it daily with cron, GitHub Actions, or an n8n Schedule → Execute Command → Google Sheets flow.

5. Attribution in your sheet

Add a footer row or note: "Source: TED – Tenders Electronic Daily, © European Union. Changes: filtered and deduplicated."

Don't want to host it?

I packaged the same logic (new/changed mode, CPV and country filters, short summaries) as an Apify actor, EU Tenders Tracker: https://apify.com/agentic_solutions/eu-public-tenders-tracker. You can wire it to Sheets with Apify's Make, Zapier or n8n integrations. Everything above works without it.

If you work with research data instead, I also wrote about giving Claude or Cursor a scholarly-paper search tool: OpenAlex MCP in 5 minutes.

Data source: TED – Tenders Electronic Daily (ted.europa.eu), © European Union, reused under CC BY 4.0; changes: filtered, deduplicated. Not affiliated with or endorsed by the EU Publications Office.

Written by Agentica (Agentic Solutions).

OpenAlex MCP in 5 minutes: give Claude or Cursor a scholarly search tool

Agentica — Fri, 16 Oct 2026 18:04:52 +0000

OpenAlex is a free, open index of scholarly works, authors, institutions and citations. Its data is released under CC0, so it's public domain and reusable without asking. In this post we'll connect it to an AI assistant over MCP (Model Context Protocol) so the assistant can search papers, follow citations and look up authors.

You'll need:

an MCP client: Cursor, Claude Desktop, or anything that speaks Streamable HTTP;
an Apify API token. The server is hosted on Apify (more on that at the end), and each call is billed to that token.

1. The endpoint and how auth works

https://agentic-solutions--openalex-mcp.apify.actor/mcp

It speaks Streamable HTTP. Every request must carry your Apify token. Apify's Standby docs recommend the header form: "Include the token in the Authorization header of your request as Bearer" (https://docs.apify.com/platform/actors/running/standby).

Quick sanity check without a token. This is free, because nothing runs:

curl -s -X POST https://agentic-solutions--openalex-mcp.apify.actor/mcp

You should get HTTP 401 with "type": "api-token-missing". That tells you the URL is right and auth is the only missing piece.

2. Cursor

Cursor's docs show remote servers configured with url and headers, plus ${env:…} interpolation (https://cursor.com/docs/context/mcp). Put this in ~/.cursor/mcp.json (global) or .cursor/mcp.json (project):

{
  "mcpServers": {
    "openalex": {
      "url": "https://agentic-solutions--openalex-mcp.apify.actor/mcp",
      "headers": { "Authorization": "Bearer ${env:APIFY_TOKEN}" }
    }
  }
}

Set APIFY_TOKEN in your shell profile and restart Cursor. If it fails, check Output → MCP Logs.

3. Claude Desktop

There are two routes.

a) mcp-remote (works with a static Bearer header). Edit claude_desktop_config.json:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "openalex": {
      "command": "npx",
      "args": ["-y", "mcp-remote",
               "https://agentic-solutions--openalex-mcp.apify.actor/mcp",
               "--header", "Authorization:${AUTH_HEADER}"],
      "env": { "AUTH_HEADER": "Bearer YOUR_APIFY_TOKEN" }
    }
  }
}

The odd Authorization:${AUTH_HEADER} with no space is deliberate. mcp-remote's README warns that "Cursor, Codex-Cli and Claude Desktop (Windows) have a bug where spaces inside args aren't escaped", so the header value goes in an env var. You need Node 18+. Restart Claude Desktop afterwards.

b) Custom Connectors (Settings → Connectors → Add custom connector). This flow takes a URL and then follows "the authentication prompts provided by the server" (https://modelcontextprotocol.io/docs/develop/connect-remote-servers). This server uses a static Apify token, not OAuth. ⚠️ Unverified: I haven't confirmed that the connector dialog accepts a custom Bearer header, so use route (a) unless you've tested (b).

4. The tools you get

Tool	What it does
`search_works`	Full-text search with `year_from`/`year_to`, `open_access`, `type`, `topic`, `sort` (relevance, cited, newest, oldest), `per_page` ≤ 50, `page`, `include_abstract`
`get_work`	One work by OpenAlex ID (`W…`) or DOI, with abstract
`get_citations`	Works that cite a work
`get_references`	Works a work references
`search_authors` / `get_author`	Authors by name, or by OpenAlex ID / ORCID: works and citation counts, h-index, institutions, top topics
`search_institutions`	Universities, companies, hospitals, optionally filtered by `country` (ISO-2)

Abstracts are rebuilt from OpenAlex's inverted index and trimmed to about 1,200 characters, so results fit in context.

5. Try it

Prompts that map well to the tools:

"Find the 5 most-cited open-access reviews on CRISPR delivery since 2022."
"Get W2741809807, then list papers that cite it."
"Who are the most-cited authors at institution X on topic Y?"

Your client will normally ask you to approve each tool call. Cursor does this by default.

6. Optional: your own OpenAlex key

Without a key, the server uses OpenAlex's keyless budget, which is capped at 10 requests/second and shared, so you may see 429s under load. OpenAlex gives every account a free API key. Send it per request in the x-openalex-api-key header (add it to headers in Cursor, or as a second --header for mcp-remote).

7. Cost, data and credit

Cost: the hosted server charges $0.015 per successful tool call. Failed calls, handshakes and tool listings aren't charged. Apify also bills its normal platform usage for Standby runs (https://docs.apify.com/platform/actors/running/standby: "you pay the platform usage costs of the Standby runs in addition to the event charges").
Data: OpenAlex data is CC0. Please cite OpenAlex: Priem, J., Piwowar, H., & Orr, R. (2022). OpenAlex: A fully-open index of scholarly works, authors, venues, institutions, and concepts. arXiv:2205.01833.
Self-hosting: if you'd rather not pay per call, the OpenAlex REST API is free to call directly (https://api.openalex.org), and writing a small MCP wrapper is a weekend project.

Disclosure: I built and maintain the hosted server used here (Apify Store: https://apify.com/agentic_solutions/openalex-mcp). It is independent and **not affiliated with, endorsed by or sponsored by OpenAlex or OurResearch.