# Public Tenders & Government Contracts Scraper: TED, UK, US, SA (`aria-data/public-tenders-monitor`) Actor

Scrape government tenders, RFPs and contract awards from EU TED, UK Find a Tender, Contracts Finder, US SAM.gov federal contract opportunities and South Africa eTenders in one schema. Filter by keyword, CPV, country, value. Daily alerts. $6 per 1,000 notices.

- **URL**: https://apify.com/aria-data/public-tenders-monitor.md
- **Developed by:** [ARIA Data](https://apify.com/aria-data) (community)
- **Categories:** Lead generation, Automation, Business
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 tender notices

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Public Tenders & Government Contracts Scraper: EU TED, UK, US SAM.gov & South Africa eTenders

**Scrape government tenders, RFPs, public procurement notices and contract awards from five official portals in one run, in one clean schema.** Search EU **TED (Tenders Electronic Daily)**, **UK Find a Tender**, **UK Contracts Finder**, **US SAM.gov (federal contract opportunities)** and **South Africa eTenders** by keywords, CPV codes, buyer country, contract value and publication date. Then switch on **monitor mode (`onlyNew`)** and schedule it daily for **tender alerts** with no duplicates. From **$6 per 1,000 notices** ($4 on Gold), platform usage included.

**Use it for:** bid & tender pipelines · government sales prospecting · competitor award tracking (who won what, for how much) · GovTech / tender-alert apps · public-spending research · feeding AI agents a daily procurement feed.

| Source | Coverage | API used |
|---|---|---|
| 🇪🇺 **TED (Tenders Electronic Daily)** | All EU/EEA above-threshold public procurement (~3,000+ notices per working day) | Official TED Search API v3 |
| 🇬🇧 **UK Find a Tender** | UK above-threshold notices (Procurement Act 2023) | Official OCDS API |
| 🇬🇧 **UK Contracts Finder** | Lower-value UK public sector contracts (England) | Official OCDS API |
| 🇿🇦 **South Africa eTenders** | National Treasury eTender Publication Portal | Official OCDS API |
| 🇺🇸 **SAM.gov** | US federal contract opportunities: solicitations, presolicitations, sources sought, awards | sam.gov public JSON search (no API key needed) |

No browser, no proxies, no scraping of HTML. This Actor uses the **official open-data APIs** published by the European Union, the UK Government (Open Government Licence) and South Africa's National Treasury, plus the public JSON endpoints that power the sam.gov search page. That makes it fast, cheap to run and reliable.

***

### What does Public Tenders Monitor do?

- 🔎 **One search, five portals.** Each portal is queried in parallel and normalised to the same fields: `title`, `buyer`, `country`, `cpv`, `value`, `currency`, `publishedAt`, `deadline`, `procedureType`, `url`, `documents` and more.
- 🔔 **Tender alerts without duplicates.** With `onlyNew`, the Actor remembers every notice it has returned (in a named key-value store) and next time returns **only new notices**. You are never charged twice for the same tender.
- 🎯 **Precise filters.** Keywords (whole-word, phrases allowed), hierarchical CPV codes (`72000000` = all IT services), buyer countries, min/max value, notice stage (open tenders, pipeline or awards) and "only with a future deadline".
- 🏆 **Award intelligence.** Switch `noticeStage` to `award` to see **who won what, for how much**: winners (`suppliers`), awarded value and buyer. That's competitor intelligence for B2B sales teams.
- 📎 **Document links.** Notice PDFs, eForms XML, procurement-document portals and South African bid packs (PDF/ZIP) are listed in `documents`.
- 🛡️ **Robust by design.** Polite per-portal rate limits, automatic retries with back-off (honours `Retry-After`), and **per-source error isolation**: if one government portal is down, the others still deliver and the run summary tells you exactly what happened.

### Who is it for?

- **Bid and tender consultants**: a morning feed of every relevant opportunity across the EU, UK, US federal government and South Africa, ready to triage in a spreadsheet.
- **B2B sales teams selling to government**: spot buyers who are about to purchase what you sell, and use award notices to see which competitors win and at what price.
- **Tender-alert and GovTech startups**: one normalised JSON feed instead of maintaining five integrations. Plug it into your app, Make, Zapier, n8n or a CRM through the Apify API and webhooks.
- **Market researchers and analysts**: track public spending by CPV category, country or buyer over time.

### How to use it

1. Pick your **sources** (all five are selected by default).
2. Add **keywords** (for example `software`, `cyber security`, `cloud hosting`) and/or **CPV codes** (for example `72000000`).
3. Optionally narrow by **countries** (`DE`, `NL`, `GB`, `US`, `ZA`…), **value** and **stage**.
4. Choose the window: **Days back** (default 3) or a fixed **Published since** date.
5. Click **Start**. Results appear in the dataset, with ready-made views: *Overview*, *Bid pipeline* and *Awards & competitors*. Export to Excel, CSV, JSON, or pull them via API.

#### ⏰ Daily tender alerts (scheduling tip)

1. Set `onlyNew: true` and give the search a name in `monitorId` (for example `it-services-dach`).
2. Set `daysBack` to **2 or 3**. The overlap means nothing is missed if a portal publishes late, and `onlyNew` removes the repeats.
3. In Apify Console go to **Schedules → Create schedule**, pick this Actor and its saved input, and run it **daily at 07:00**.
4. Add an **integration** (email, Slack, Google Sheets, Make, Zapier or a webhook) to receive each day's new notices automatically.

Each run then returns only the notices published since the last run, and you only pay for those.

### Input example

```json
{
  "sources": ["ted", "uk_find_a_tender", "uk_contracts_finder", "za_etenders"],
  "keywords": ["software", "cyber security", "cloud hosting"],
  "cpvCodes": [],
  "countries": [],
  "noticeStage": "tender",
  "daysBack": 3,
  "minValue": 50000,
  "includeUnknownValue": true,
  "onlyOpen": true,
  "maxResults": 200,
  "onlyNew": true,
  "monitorId": "it-services",
  "includeDocuments": true
}
```

| Field | What it does |
|---|---|
| `sources` | `ted`, `uk_find_a_tender`, `uk_contracts_finder`, `za_etenders` |
| `keywords` | Matches ANY keyword; whole-word, case-insensitive, phrases allowed |
| `keywordScope` | `title_description` (precise, default) or `full_text` (broader) |
| `cpvCodes` | Hierarchical: `72000000` matches all `72xxxxxx` codes |
| `countries` | ISO alpha-2 buyer countries; portals that can't match are skipped |
| `noticeStage` | `tender` (open opportunities), `planning`, `award`, `all` |
| `publishedSince` / `daysBack` | Publication window |
| `minValue` / `maxValue` | Compared in the notice's own currency (no FX conversion) |
| `includeUnknownValue` | Keep notices that don't publish a value (default on) |
| `onlyOpen` | Drop notices whose deadline has passed |
| `maxResults` | Max notices **per source** |
| `onlyNew` + `monitorId` + `stateStoreName` | Monitor mode: return only notices not returned before |
| `includeDocuments` | Add document links |

### Output example

One item per notice (real record from UK Find a Tender, description shortened):

```json
{
  "source": "uk_find_a_tender",
  "sourceName": "UK Find a Tender",
  "id": "uk_find_a_tender:100749-2026",
  "noticeId": "100749-2026",
  "ocid": "ocds-h6vhtk-078f99",
  "reference": "ID 6637252",
  "stage": "tender",
  "noticeType": "tender",
  "status": "active",
  "title": "ID 6637252 - DfE - SRC - High Performance Liquid Chromatography (HPLC)",
  "titleEnglish": null,
  "description": "Southern Regional College (SRC) requires the Supply, Delivery and Commissioning of two Hi…",
  "buyer": "Southern Regional College",
  "buyerId": "GB-PPON-PBTJ-5492-VBGW",
  "country": "GB",
  "region": "Newry",
  "cpv": ["38000000", "38300000", "38540000", "38434000", "51430000"],
  "cpvMain": "38000000",
  "cpvDescriptions": { "38000000": "Laboratory, optical and precision equipments (excl. glasses)" },
  "mainCategory": "goods",
  "value": 201667.0,
  "currency": "GBP",
  "valueType": "estimated",
  "publishedAt": "2026-10-23T17:22:17+01:00",
  "deadline": "2026-11-18T15:00:00+00:00",
  "procedureType": "Open procedure",
  "procurementMethod": "open",
  "url": "https://www.find-tender.service.gov.uk/Notice/100749-2026",
  "documents": [
    { "title": "Tender notice on Find a Tender", "type": "tenderNotice", "url": "https://www.find-tender.service.gov.uk/Notice/100749-2026", "format": "text/html" }
  ],
  "suppliers": [],
  "contractStart": "2027-02-26T00:00:00+00:00",
  "contractEnd": "2029-02-25T23:59:59+00:00",
  "language": "en",
  "scrapedAt": "2026-10-23T16:30:24+00:00"
}
```

Every field is always present (`null` or `[]` when a portal doesn't publish it). Key fields:

- `id`: globally unique `<source>:<noticeId>`, safe to use as a primary key in your database or CRM.
- `stage`: `tender`, `planning` or `award`. `noticeType` keeps the portal's original type (e.g. TED `cn-standard`, OCDS `tenderUpdate`).
- `title` is in the original language. For TED, `titleEnglish` adds the official English label ("Germany – Servers – …").
- `value` / `currency` / `valueType`: `estimated` for open tenders, `awarded` for award notices.
- `suppliers`: winning companies on award notices.

A per-run **`RUN_SUMMARY`** record in the default key-value store lists each source's status (`ok` / `failed` / `skipped`), notices returned, records scanned, requests made, and any error message.

**UK portal rate limits.** UK Find a Tender (and Contracts Finder) enforce a strict limit of about 12 API requests per window and answer extra requests with HTTP 429 plus a 2-minute `Retry-After`. The Actor paces UK requests about 6 s apart and reads at most 10 Find a Tender pages per run. If a UK portal still throttles (2 consecutive 429s, or it asks to wait more than 30 s), the Actor stops querying that portal for the rest of the run, logs a warning, and lists it under `skippedSources` (e.g. `{"source": "uk_find_a_tender", "reason": "rate limited"}`) in the `RUN_SUMMARY` / `OUTPUT` record. The other sources carry on, and every source has a time budget (`sourceTimeBudgetSecs`, default 120 s), so runs finish in a few minutes instead of timing out. Tip: avoid running several Find a Tender searches at the same moment; stagger scheduled runs by a few minutes.

### Pricing

**Pay-per-event**, platform usage included. You pay only for notices saved to your dataset; pages scanned and filtered-out records are free.

| Event | Free / Bronze | Silver | Gold |
|---|---|---|---|
| `notice-result` (per notice returned) | $0.006 | $0.005 | $0.004 |
| **Cost per 1,000 notices** | **$6.00** | **$5.00** | **$4.00** |
| `apify-actor-start` (per run) | $0.00005 | $0.00005 | $0.00005 |

- With `onlyNew`, notices you already received are skipped and **never charged again**.
- Set a **maximum charge per run** in Apify Console. The Actor stops cleanly when the budget is reached.
- Example: a daily IT-services alert returning ~40 new notices per day costs about **$0.24/day (~$7/month)** on the base price.

### Ready-made examples (one click to run)

- [UK government IT & software tenders](https://apify.com/aria-data/public-tenders-monitor/examples/uk-government-it-software-tenders)
- [EU cybersecurity tenders on TED](https://apify.com/aria-data/public-tenders-monitor/examples/eu-cybersecurity-tenders-ted)
- [South Africa eTenders daily alerts](https://apify.com/aria-data/public-tenders-monitor/examples/south-africa-etenders-daily-alerts)
- [EU construction tenders by CPV code](https://apify.com/aria-data/public-tenders-monitor/examples/eu-construction-tenders-by-cpv)
- [UK contract awards: competitor tracking](https://apify.com/aria-data/public-tenders-monitor/examples/uk-contract-awards-competitor-tracking)
- [High-value public contracts over 1M](https://apify.com/aria-data/public-tenders-monitor/examples/high-value-public-contracts-over-1m)
- [AI & data analytics government tenders](https://apify.com/aria-data/public-tenders-monitor/examples/ai-and-data-analytics-government-tenders)
- [US federal contract opportunities on SAM.gov](https://apify.com/aria-data/public-tenders-monitor/examples/us-federal-contract-opportunities-sam-gov)
- [Renewable energy & solar tenders](https://apify.com/aria-data/public-tenders-monitor/examples/renewable-energy-solar-tenders)
- [Daily public tender feed for AI agents](https://apify.com/aria-data/public-tenders-monitor/examples/daily-public-tender-feed-for-ai-agents)

### US federal contract opportunities (SAM.gov scraper)

SAM.gov is the official US government system where every federal agency (DoD, Army, Navy, VA, DHS, GSA, NASA…) posts **federal contract opportunities**: solicitations, combined synopsis/solicitations, presolicitations, sources sought / RFIs and award notices. Select the `sam_gov` source to get them in the same schema as the other portals:

- **No API key needed.** The Actor reads the same public JSON search the sam.gov website uses. Optionally add your own free api.data.gov key in `samGovApiKey` (SAM.gov → Account Details → Public API Key); it is only used as a fallback if the public route is ever blocked.
- **Keywords** are searched server-side on SAM.gov (phrases in quotes) and, with the default `keywordScope`, re-checked on title and description.
- **Codes**: SAM.gov uses NAICS and PSC instead of CPV, so they appear in `cpv` as `NAICS:541512` and `PSC:DA01` (`cpvMain` is the primary NAICS). When you set a CPV filter, SAM.gov is skipped automatically; use keywords for the US.
- **Stages**: `tender` = Solicitation + Combined Synopsis/Solicitation, `planning` = Presolicitation, Sources Sought, Special Notice, `award` = Award Notices (with awardee in `suppliers` and the awarded amount in `value`, USD).
- `buyer` is the department and contracting office (e.g. `DEPT OF DEFENSE – NAVSUP FLT LOG CTR NORFOLK`), `region` the US state of performance, `mainCategory` the small-business set-aside when there is one, `url` the sam.gov notice page. Attachments are on the notice page (not listed in `documents`).
- Each SAM.gov notice needs one detail request for NAICS/PSC, so very broad searches (no keywords, long windows) are bounded by `maxResults` and the per-source time budget.

### Source notes and limitations

- **TED**: keyword search runs server-side across the original-language title and description and TED's English title. Notices are written in the buyer's language, so add translations (`software`, `Software`, `logiciel`, `programvara`…) or use CPV codes for best EU coverage.
- **UK Find a Tender / Contracts Finder**: the official APIs have no keyword or CPV search, so the Actor pages through the date window and filters locally. Both portals enforce roughly **12 requests per minute**, so the Actor paces itself; long windows (30+ days) take a few minutes. Notice pages on these sites may block non-browser traffic, but the links open normally in a browser.
- **South Africa eTenders**: publishes open tenders only (no awards, no CPV codes, values usually not stated). When you set a CPV filter, eTenders is skipped automatically, so use keywords for South Africa. eTenders has no per-tender web page, so `url` links to the official bid document (PDF), and all bid documents are in `documents`. A few records occasionally break the eTenders API (HTTP 500). The Actor isolates and skips only those records and reports the count in `RUN_SUMMARY`.
- **US SAM.gov**: see the section below.
- Values are compared in each notice's own currency (EUR, GBP, SEK, PLN, ZAR, USD…). No currency conversion is applied.

### FAQ

**Is this legal?**
Yes. All data comes from official open-data APIs that governments publish for re-use: the EU TED reuse policy, the UK Open Government Licence, and South Africa's open data licence (PDDL) for OCDS data. SAM.gov opportunity data is public US government information. Notices describe public bodies and contracts. Contact e-mails or phone numbers included by buyers in notices are not extracted.

**How fresh is the data?**
As fresh as the portals. TED publishes every working day, and the UK and SA portals publish continuously. A daily schedule catches everything.

**Can I get only tenders I can still bid on?**
Yes. Keep `noticeStage: "tender"` and turn on `onlyOpen` to drop notices whose deadline has passed.

**How do I track competitors?**
Run with `noticeStage: "award"` and keywords or CPV codes for your market. Use the *Awards & competitors* view to see winners, buyers and awarded values.

**How does `onlyNew` work across runs?**
Notice ids are stored in a named key-value store (`tenders-monitor-state` by default, one record per `monitorId`) and kept for 180 days. Use a different `monitorId` for each saved search. To reset an alert, delete that record or change the `monitorId`.

**What happens if a portal is down?**
That source is marked `failed` in `RUN_SUMMARY` and the other sources still return results. The run only fails if every selected source fails.

**How do I schedule daily tender alerts?**
Set `onlyNew: true`, a `monitorId` and `daysBack: 2`, then in Apify Console open **Schedules → Create schedule** and run the saved input daily (e.g. 07:00). Each run returns only notices published since the last one.

**Which integrations work?**
Any Apify integration: e-mail, Slack, Google Sheets, Google Drive, Make, Zapier, n8n, Airbyte, webhooks, plus the REST API and Python/JavaScript clients. Export to Excel, CSV, JSON or XML.

**How much does a first test run cost?**
The prefilled input returns at most 10 notices per portal (40 max), i.e. under $0.25, and usually finishes in under two minutes.

**Can I use it from my own code or an AI agent?**
Yes. Call it through the Apify API, the Python/JS clients or Apify's MCP server, and read the dataset as JSON.

**Do you plan more countries?**
US SAM.gov (bring your own free api.data.gov key) is next. Open an issue to request a portal.

# Actor input Schema

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

Official procurement portals to search. All selected sources are queried in parallel; if one portal is down, the others still return results.

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

Notices matching ANY keyword are returned (whole-word, case-insensitive; multi-word phrases allowed, e.g. "cyber security"). TED notices are often in the local language. Add translations (e.g. "Software", "logiciel") for better EU coverage. Leave empty to get everything.

## `keywordScope` (type: `string`):

Where keywords are searched. 'Title & description' is precise. 'Full text' also searches buyer names, CPV labels and document titles (on TED, the full notice text).

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

Common Procurement Vocabulary codes. Matching is hierarchical: 72000000 matches every IT service under 72xxxxxx, 45233120 matches only that code. South Africa eTenders does not publish CPV codes, so it is skipped when a CPV filter is set (use keywords for SA). SAM.gov uses NAICS/PSC codes instead of CPV and is skipped the same way.

## `countries` (type: `array`):

ISO 3166 alpha-2 codes, e.g. DE, FR, NL, GB, US, ZA (UK is accepted for GB). Sources that cannot match the list are skipped automatically. Leave empty for all countries.

## `noticeStage` (type: `string`):

'Open opportunities' = contract notices you can still bid on (including updates and cancellations). 'Planned' = prior information / pipeline notices. 'Awards' = contract award notices with winners and awarded values (great for competitor intelligence). eTenders only supports open opportunities.

## `publishedSince` (type: `string`):

Only notices published on or after this date (YYYY-MM-DD). Overrides 'Days back'.

## `daysBack` (type: `integer`):

Used when 'Published since' is empty: look back this many days from today (0 = today only). For a daily schedule with onlyNew, 2–3 days gives a safe overlap.

## `minValue` (type: `integer`):

Minimum estimated (or awarded) contract value, compared in the notice's own currency (EUR, GBP, SEK, ZAR…). No currency conversion is applied.

## `maxValue` (type: `integer`):

Maximum contract value, in the notice's own currency.

## `includeUnknownValue` (type: `boolean`):

Many notices do not state a value (almost all SA eTenders notices). When a min/max value is set, keep these notices (on) or drop them (off).

## `onlyOpen` (type: `boolean`):

Drop notices whose submission deadline has already passed, or that have no deadline.

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

Maximum number of notices returned from EACH selected source. You are charged per notice returned.

## `onlyNew` (type: `boolean`):

Remember every notice returned and, on later runs, return only notices not seen before. Use with a daily Schedule to get alerts without duplicates (you are never charged twice for the same notice). State is kept in a named key-value store for 180 days.

## `monitorId` (type: `string`):

Name of this alert, used to keep separate 'already seen' lists for different searches (e.g. 'it-services-dach', 'construction-uk'). Only used with onlyNew.

## `stateStoreName` (type: `string`):

Named key-value store where onlyNew remembers seen notice ids. Named stores persist between runs in your Apify account.

## `includeDocuments` (type: `boolean`):

Add links to notice PDFs, procurement documents and tender packs (where the portal publishes them) in the 'documents' field.

## `maxPagesPerSource` (type: `integer`):

Upper bound on API pages fetched per source. UK and SA portals have no server-side keyword search, so very long windows with narrow keywords can scan many pages.

## `sourceTimeBudgetSecs` (type: `integer`):

Each portal gets at most this long per run. When it runs out, that source stops and returns what it found so far (noted in RUN_SUMMARY / OUTPUT under skippedSources), so a slow or rate-limited portal can never stall the whole run.

## `samGovApiKey` (type: `string`):

Not needed: SAM.gov is read keylessly through the public endpoints the sam.gov website uses. Only if that route is ever blocked, a free api.data.gov key you request at https://sam.gov (Account Details > Public API Key) lets the Actor fall back to the official Opportunities API.

## Actor input object example

```json
{
  "sources": [
    "ted",
    "uk_find_a_tender",
    "uk_contracts_finder",
    "za_etenders",
    "sam_gov"
  ],
  "keywords": [
    "software",
    "cloud",
    "cyber security"
  ],
  "keywordScope": "title_description",
  "cpvCodes": [
    "72000000",
    "48000000"
  ],
  "countries": [
    "DE",
    "NL",
    "GB"
  ],
  "noticeStage": "tender",
  "daysBack": 3,
  "includeUnknownValue": true,
  "onlyOpen": false,
  "maxResults": 10,
  "onlyNew": false,
  "monitorId": "default",
  "stateStoreName": "tenders-monitor-state",
  "includeDocuments": true,
  "maxPagesPerSource": 200,
  "sourceTimeBudgetSecs": 120
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `allResults` (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 = {
    "sources": [
        "ted",
        "uk_find_a_tender",
        "uk_contracts_finder",
        "za_etenders",
        "sam_gov"
    ],
    "keywords": [
        "software",
        "cloud",
        "cyber security"
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("aria-data/public-tenders-monitor").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 = {
    "sources": [
        "ted",
        "uk_find_a_tender",
        "uk_contracts_finder",
        "za_etenders",
        "sam_gov",
    ],
    "keywords": [
        "software",
        "cloud",
        "cyber security",
    ],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("aria-data/public-tenders-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "sources": [
    "ted",
    "uk_find_a_tender",
    "uk_contracts_finder",
    "za_etenders",
    "sam_gov"
  ],
  "keywords": [
    "software",
    "cloud",
    "cyber security"
  ],
  "maxResults": 10
}' |
apify call aria-data/public-tenders-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,aria-data/public-tenders-monitor"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/aInWjoZOMro4wsoh8/builds/eDY7K3vbmy8u1uDi2/openapi.json