This tutorial builds a small pipeline that:

1. Collects UK and EU tender records.

2. Returns structured dataset items.

3. Filters opportunities by deadline and keyword.

4. Removes records already processed.

5. Produces a compact review list.

Data Sources

The example uses:

• UK Contracts Finder

• EU TED

• SAM.gov when an API key is supplied

We will use UK Contracts Finder and EU TED because they can be tested without an additional source API key.

Run a Small Test

Use a narrow input first:

{
  "sources": ["uk_contracts_finder", "ted"],
  "keywords": ["software"],
  "noticeStatus": "active",
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}

The important settings are:

• sources: procurement systems to query

• keywords: terms used to narrow the results

• noticeStatus: limits the search to active opportunities

• maxResults: controls the maximum dataset size

• proxyConfiguration: official APIs normally do not require a proxy

Expected Record Structure

Each normalized result contains fields such as:

{
  "source": "uk_contracts_finder",
  "contractId": "ocds-example-id",
  "title": "Software Support Services",
  "buyerName": "Example Public Authority",
  "buyerCountry": "England",
  "buyerRegion": "London",
  "noticeType": "tender",
  "procurementMethod": "Open procedure",
  "contractValue": null,
  "currency": null,
  "publishedDate": "2026-06-27T05:42:14.000Z",
  "deadlineDate": "2026-07-20T11:00:00.000Z",
  "status": "active",
  "classificationCodes": [],
  "description": "Summary of the procurement requirement",
  "contractUrl": "https://official-procurement-source.example/notice",
  "scrapedAt": "2026-06-28T17:12:43.000Z"
}

A stable contractId is especially useful because it can be used for deduplication.

Run It from Node.js

Install the official API client:

npm install apify-client

Store your Apify token in an environment variable instead of placing it directly in the source code.

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const input = {
  sources: ['uk_contracts_finder', 'ted'],
  keywords: ['software'],
  noticeStatus: 'active',
  maxResults: 10,
  proxyConfiguration: {
    useApifyProxy: false,
  },
};

const run = await client
  .actor('fascinating_lentil/global-government-contracts-aggregator')
  .call(input);

const { items } = await client
  .dataset(run.defaultDatasetId)
  .listItems();

console.log(`Received ${items.length} records`);
console.dir(items, { depth: null });

The Actor call waits for the run to finish. The resulting dataset ID is then used to retrieve the structured records.

Filter Useful Opportunities

A team may only want active software opportunities with future deadlines.

const now = new Date();

const relevant = items.filter((item) => {
  const text = `${item.title ?? ''} ${item.description ?? ''}`.toLowerCase();
  const deadline = item.deadlineDate
    ? new Date(item.deadlineDate)
    : null;

  return (
    item.status === 'active' &&
    text.includes('software') &&
    deadline &&
    deadline > now
  );
});

This is deliberately simple. Production filters could also use:

• Buyer name

• Country or region

• Contract value

• Notice type

• Procurement stage

• Classification or CPV codes

• Deadline window

Prevent Duplicate Alerts

Save processed contract IDs and exclude them from later runs.

const previouslySeen = new Set([
  'ocds-previously-processed-id',
]);

const newOpportunities = relevant.filter(
  (item) => !previouslySeen.has(item.contractId),
);

For a small workflow, the IDs can be stored in a JSON file, spreadsheet, or database table. A larger system can use a persistent key-value store.

Create a Compact Digest

Bid teams rarely need every field in the first notification. A smaller object is easier to review.

const digest = newOpportunities.map((item) => ({
  title: item.title,
  buyer: item.buyerName,
  region: item.buyerRegion ?? item.buyerCountry,
  value: item.contractValue,
  currency: item.currency,
  deadline: item.deadlineDate,
  source: item.source,
  officialUrl: item.contractUrl,
}));

console.table(digest);

The resulting digest can be sent through email, Slack, a webhook, or another workflow tool.

Scheduling the Pipeline

A basic automated workflow can run once per day:

1. Run the collection job.

2. Read the resulting dataset.

3. Apply keyword and deadline filters.

4. Remove previously seen contract IDs.

5. Send only new opportunities.

6. Save the newly processed IDs.

Start with a narrow keyword and a low result limit. Expand only after checking the relevance of the output.

Important Limitations

Public procurement records are not always complete.

• Some notices omit contract values.

• Classification codes may vary between sources.

• Deadlines can be updated after publication.

• Duplicate or related notices may appear under different IDs.

• The official notice should remain the final source of truth.

A pipeline should therefore help prioritize opportunities, not replace procurement review.

Conclusion

The useful engineering problem is not simply collecting tenders. It is converting several source formats into stable records that can be filtered, deduplicated, and delivered consistently.

The Actor used for this technical example is available here:

Global Government Contracts & Tenders Scraper