# EU & UK Tenders Scraper: TED + Find a Tender (`meridianlabs/eu-uk-tenders-scraper`) Actor

Public procurement tenders from the EU's TED and the UK's Find a Tender official APIs: buyer, CPV, value, deadline, winners and a plain-English summary per notice. Keyword, CPV, country and value filters, daily monitor mode. $3 per 1,000 notices.

- **URL**: https://apify.com/meridianlabs/eu-uk-tenders-scraper.md
- **Developed by:** [Meridian Labs](https://apify.com/meridianlabs) (community)
- **Categories:** Lead generation, Business, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 notices

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

**EU & UK Tenders Scraper** returns public procurement notices from the two official open-data APIs: **TED** (Tenders Electronic Daily, the EU's journal of public procurement, covering every EU and EEA country plus the EU institutions) and the UK government's **Find a Tender** service. Both come back in **one clean format** (buyer, country, CPV codes with English labels, procedure, estimated value, bid deadline, lots, and winners with the awarded value on award notices) plus a **plain-English summary line** per notice, such as *"Open tender: The Education Training Collective wants education and training services, est. GBP 75K, bids due 2026-10-16"*. A **monitor mode** returns only notices you haven't seen before, so a daily schedule becomes a tender alert feed. The input form is pre-filled, so the easiest way to try it is to click **Start** (at most 20 notices, about $0.06).

It's built for **bid and sales teams selling to the public sector**, **bid writers and consultants** tracking opportunities for clients, **market and competitor analysts** who want to know who wins which contracts, **procurement researchers and journalists**, and **AI agents** that need structured, reliable tender data.

### What data do you get for each notice?

- 📝 **Plain-English summary** (`summary`): one line built from the notice's own fields: what kind of notice, who is buying, what (the CPV label in English), the estimated value and the deadline. Award notices say who won and for how much. No AI, so it is fast, free and repeatable.
- 🏛️ **Buyer:** `buyer_name`, `buyer_country` (ISO code) and `buyer_country_name`, `buyer_city`, `buyer_website`. Organisations only: contact names, personal e-mails and phone numbers are never returned.
- 🏷️ **What is bought:** `cpv_main_code` and `cpv_main_label`, plus every CPV code on the notice with its official English label (`cpv_codes`, `cpv_labels`), and `contract_nature` (works, services or supplies).
- 📅 **Dates:** `publication_date`, `submission_deadline` (the earliest over the lots), `submission_deadline_datetime` with the time, `deadline_type` (bids, or requests to participate) and `days_to_deadline`.
- 💶 **Money:** `estimated_value` and `estimated_value_currency`, `lots_count`; on awards, `award_value`, `award_currency`, `winners` and `winner_countries`.
- 🌍 **Title in English where the buyer gave one, plus the original:** `title`, `title_original`, `title_language`, `title_is_english`. Most EU notices are published only in the buyer's language; the summary is always in English.
- 🔗 **Normalised across both sources:** `notice_type` (contract\_notice, award, prior\_information, other), `procedure_type` (open, restricted, negotiated, competitive\_dialogue, competitive\_flexible, direct\_award …), the source's own codes in `notice_subtype` (TED `cn-standard`, UK `UK4` …), a stable `id` and a link to the official notice page (`url`).
- ©️ **Attribution on every row** (`attribution`), as the two licences ask: © European Union for TED, the Open Government Licence v3.0 for Find a Tender.

### Why use this tenders scraper?

- 🇪🇺🇬🇧 **EU and UK in one run and one format.** Since Brexit, UK notices are no longer on TED. This Actor reads both official APIs and gives you the same fields for each, so one pipeline covers 30+ countries.
- 🗣️ **A summary you can read in a list.** Scanning 200 notices in 20 languages is slow; scanning 200 one-line English summaries isn't. They also make clean input for e-mail alerts, Slack messages or an AI agent.
- 🔁 **Monitor mode for daily alerts.** Each monitor remembers which notices it returned, so a scheduled run returns, and charges, only new ones. Use a different monitor name per client or alert.
- 🧾 **You pay only for notices you get.** No start fee. Filtered-out notices, notices your monitor already returned, failed searches and invalid input are free.
- ✅ **Official sources only.** TED's search API and Find a Tender's OCDS API, both free, public and meant for reuse. No browser, no proxies, no logins, robots.txt obeyed, and each API's published rate limits respected.
- 🛡️ **No personal data.** Buyers are organisations; contact persons, e-mails and phone numbers are not read. Award winners that look like a private individual (a sole trader's own name) are withheld and counted in `winners_withheld`.
- 🤖 **AI-agent ready.** Documented output schema, table views, stable IDs, and it works from the API, Make, n8n, Zapier and MCP clients.

### How do I find public tenders for my business?

1. Pick the **sources** (TED, Find a Tender, or both).
2. Add **keywords** (any of), **CPV codes** for your sector, and optionally **countries**, a **buyer name**, a **value** range or a **bid deadline** window. Set *Bid deadline on or after* to today to get only tenders still open.
3. Choose **notice types**: open tenders (contract notices), awards, prior information, or others.
4. Click **Start**. Open the **Notices** view (or **Awards** for winners), or export JSON, CSV or Excel.

#### How do I get a daily tender alert?

Set **Mode** to *Monitor: only notices new since the last run*, give the monitor a name, set *Published in the last N days* to 3 (it covers weekends and late publication), save the input as a task and schedule it daily. Each run returns only notices that monitor hasn't returned before. The first run sees every match as new. Changing the search (keywords, CPV, countries, types, value or deadline filters) starts a fresh memory for it, so an edit can never hide notices.

#### How do I see who won public contracts?

Choose **Contract awards** as the notice type and open the **Awards** view: buyer, winning organisations, their countries, the awarded value and a one-line summary per award, e.g. *"Award: Gmina Wierzbica awarded refuse and waste related services to Usługi Ekologiczne Eko-Jas for PLN 5.5M"*.

### How much does it cost?

**$3 per 1,000 notices ($0.003 per notice returned).** That's the only charge.

- ✅ **Charged:** each notice saved to your dataset. The dataset holds only notices, so its item count is exactly what you pay for.
- 🆓 **Free:** notices your filters leave out; notices your monitor already returned; searches that fail or that the source rejects; invalid input (the run stops before any request); anything past your spending limit or `maxNoticesPerSource`.
- Examples: the pre-filled run = up to 20 notices = $0.06; 500 open tenders in your sector = $1.50; a daily monitor that finds 30 new notices = $0.09 that day.
- **Free to try:** Apify's free plan includes $5 of usage every month, which covers about **1,600 notices** here. Platform usage is included in the price.
- Set a **maximum cost per run** and the Actor stops exactly there; the source status says how many matching notices weren't saved, and in monitor mode those stay new for next time.

### Output example

A row from the **Notices** view (all fields; descriptions shortened):

```json
{
  "record_type": "notice",
  "id": "uk:093572-2026",
  "source": "uk",
  "source_name": "Find a Tender (UK)",
  "notice_id": "093572-2026",
  "url": "https://www.find-tender.service.gov.uk/Notice/093572-2026",
  "title": "Football Delivery Partner - Redcar and Cleveland College",
  "title_original": "Football Delivery Partner - Redcar and Cleveland College",
  "title_language": "en",
  "title_is_english": true,
  "summary": "Open tender: The Education Training Collective wants education and training services, est. GBP 75K, bids due 2026-10-16",
  "notice_type": "contract_notice",
  "notice_type_label": "Contract notice",
  "notice_subtype": "UK4",
  "notice_subtype_label": "Tender notice",
  "is_update": false,
  "procedure_type": "open",
  "procedure_type_original": "Below threshold - open competition",
  "contract_nature": "services",
  "buyer_name": "The Education Training Collective",
  "buyer_country": "GB",
  "buyer_country_name": "United Kingdom",
  "buyer_city": "Thornaby",
  "buyer_website": "http://www.the-etc.ac.uk",
  "cpv_main_code": "80000000",
  "cpv_main_label": "Education and training services",
  "cpv_codes": ["80000000"],
  "cpv_labels": ["Education and training services"],
  "publication_date": "2026-10-02",
  "submission_deadline": "2026-10-16",
  "submission_deadline_datetime": "2026-10-16T12:00:00+01:00",
  "deadline_type": "tender",
  "days_to_deadline": 13,
  "estimated_value": 75000,
  "estimated_value_currency": "GBP",
  "lots_count": 1,
  "award_value": null,
  "award_currency": null,
  "winners": [],
  "winner_countries": [],
  "winners_withheld": 0,
  "place_of_performance_countries": ["GB"],
  "description": "Football Delivery Partner for the ISE Men's Football Academy at Redcar & Cleveland College…",
  "attribution": "Contains public sector information licensed under the Open Government Licence v3.0. Source: Find a Tender, Cabinet Office, https://www.find-tender.service.gov.uk. Fields normalised and summarised by Meridian Labs.",
  "scraped_at": "2026-10-03T14:58:19Z"
}
```

A TED notice in Portuguese, summarised in English:

```json
{
  "id": "ted:681476-2026",
  "url": "https://ted.europa.eu/en/notice/-/detail/681476-2026",
  "title": "0100007.292027 - Aquisição de Material de Consumo Clinico de Ginecologia e Obstetricia",
  "title_language": "pt",
  "title_is_english": false,
  "summary": "Open tender: Unidade Local de Saúde de Entre Douro e Vouga, EPE wants medical consumables, est. EUR 435K, bids due 2026-10-30 (46 lots)",
  "notice_subtype": "cn-standard",
  "procedure_type": "open",
  "buyer_country": "PT",
  "cpv_main_code": "33140000",
  "cpv_main_label": "Medical consumables",
  "submission_deadline": "2026-10-30",
  "estimated_value": 434788.4,
  "estimated_value_currency": "EUR",
  "lots_count": 46,
  "attribution": "Source: TED (Tenders Electronic Daily), © European Union, https://ted.europa.eu. Notices reused under the Commission's reuse policy (Decision 2011/833/EU); editorial content CC BY 4.0. Fields normalised and summarised by Meridian Labs."
}
```

The **Source status** output (key-value record `SOURCES`, free) has one line per source: what was searched, how many notices were scanned, matched, saved and charged, and why it stopped (for example *"Reached maxNoticesPerSource (100); newer notices come first."*).

### Input

| Field | What it does |
|---|---|
| `sources` | `ted` (EU), `uk` (Find a Tender), or both (default) |
| `keywords` | Words or phrases, any of. TED searches its full text in every language; UK notices are matched on title, description and CPV label |
| `cpvCodes` | CPV codes, any of. A broad code covers everything under it (45000000 = all construction) |
| `countries` | Buyer countries as ISO codes or names (FR or FRA, UK or GBR …). A list without the UK skips the UK source, free |
| `buyerName` | Part of the buyer's name, e.g. NHS, Lyon, Bundesamt |
| `noticeTypes` | `contract_notice` (default), `award`, `prior_information`, `other` |
| `publishedWithinDays` | Publication window ending today (default 7), or set `publishedAfter` / `publishedBefore` (YYYY-MM-DD, up to 366 days) |
| `deadlineAfter`, `deadlineBefore` | Bid deadline window. Notices without a deadline are left out when set |
| `minValue`, `maxValue`, `valueCurrency` | Estimated value (awarded value for awards) in the notice's own currency; set `valueCurrency` to compare one currency only |
| `maxNoticesPerSource` | Newest first; default 100, 0 = no limit |
| `mode`, `monitorName` | `all`, or `newSinceLastRun` to return only notices this monitor hasn't returned before |
| `tedQuery` | Advanced: extra TED expert-search clause, added with AND (TED only) |
| `failOnErrors` | For schedules: fail the run (so Apify alerts you) if a source can't be searched |

#### Switching from another tenders Actor?

The filters use the names most TED Actors use (`keywords`, `cpvCodes`, `countries`, `noticeTypes`, `buyerName`). Field names in the output: `publicationNumber` → `notice_id`, `buyerName` → `buyer_name`, `buyerCountry` → `buyer_country` (now ISO alpha-2, e.g. FR), `totalValue` / `estimated_value` → `estimated_value`, `deadlineDate` → `submission_deadline`, `detailUrl` / `url_ted` → `url`, `winner_name` → `winners` (a list). Buyer e-mails and phone numbers are deliberately not returned.

### How do I send tenders to Google Sheets, Make, Zapier, n8n or an AI agent?

- **Google Sheets (one formula):** save your input as a task and schedule it, then put this in cell A1 of a sheet and click **Allow access** on the yellow bar Sheets shows about external data:
  `=IMPORTDATA("https://api.apify.com/v2/acts/meridianlabs~eu-uk-tenders-scraper/runs/last/dataset/items?status=SUCCEEDED&format=csv&view=notices&token=YOUR_TOKEN")`
  It loads your latest successful run, and picks up a newer one when Google refreshes imported data (about once an hour) or when you reopen the sheet. Anyone who can open the sheet can see the token, so create one with limited permissions in Console → Settings → API & Integrations. For a saved task, use `actor-tasks/<your-username>~<task-name>/runs/last/...` instead.
- **Make:** Apify "Run an Actor" (Run synchronously: Yes) → Apify "Get Dataset Items" → Google Sheets, add rows (or e-mail / Slack for alerts).
- **n8n:** Apify trigger "Actor Run Finished" → Apify "Get Items" (Datasets) with the run's `defaultDatasetId` → Google Sheets, append.
- **Zapier:** trigger "Finished Actor run" → "Fetch dataset items" → Google Sheets.
- **Webhooks:** Integrations → **HTTP webhook** on "Run succeeded" sends the run details to your URL.
- **AI agents (MCP):** add `https://mcp.apify.com?tools=meridianlabs/eu-uk-tenders-scraper` to your MCP client (Claude, Cursor, VS Code and others). The agent can then search open tenders by keyword, sector or country and read the one-line summaries.

Python (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("meridianlabs/eu-uk-tenders-scraper").call(run_input={
    "keywords": ["cleaning services"],
    "countries": ["IE", "UK"],
    "deadlineAfter": "2026-10-05",
})
for row in client.dataset(run.default_dataset_id).iterate_items():
    print(row["submission_deadline"], row["summary"], row["url"])
```

For a daily alert, run it as a scheduled task in monitor mode (see *How do I get a daily tender alert?*).

### Limitations

- **Two sources today:** TED (EU/EEA and EU institutions) and Find a Tender (UK, above-threshold and Procurement Act notices). UK Contracts Finder (low-value UK notices), SAM.gov and national portals are not included.
- **TED:** notices in eForms, TED's format since October 2023, are fully normalised; older notices come back with fewer fields filled. TED publishes Monday to Friday.
- **Find a Tender's API only filters by date**, so keywords, CPV codes, buyer and value are applied here after reading every UK notice in your window (about 450 a day). So UK searches take longer: we pace requests the way the API asks (about 6-8 a minute), so a week of UK notices takes about 5 minutes and a month about 20. If the API still asks us to wait, the run waits as asked or ends that source early with a free status saying so.
- **Values** are compared in each notice's own currency (EUR, GBP, PLN, SEK …), with no exchange-rate conversion. Placeholder values such as 0 or 1 are treated as missing.
- **Titles:** most EU notices exist only in the buyer's language; we don't machine-translate them. The summary and the CPV labels are always in English.
- **People's names in free text** (for example inside a description) are not removed; e-mail addresses and phone numbers of individuals are.

### FAQ

#### Where does the data come from, and can I reuse it?

From the official APIs only: TED's search API (`api.ted.europa.eu`, no account needed) and Find a Tender's OCDS release API. TED's legal notice says procurement notices "can be freely reused, for commercial or non-commercial purposes", with TED's editorial content under CC BY 4.0 (credit © European Union). Find a Tender content is under the Open Government Licence v3.0. Every row carries the matching credit in `attribution`; keep it when you republish.

#### Does it collect personal data?

No. Buyers and winners are organisations. Contact points (which often name a person), e-mail addresses and phone numbers are never read into the output; personal e-mails and phone numbers inside descriptions are removed (generic role mailboxes such as tenders@ stay); winner names that look like a private individual are withheld and counted in `winners_withheld`.

#### Can I use it with the API, AI agents or MCP?

Yes. Run it from the Apify API or any client, or add it to an MCP client (see above). The dataset schema documents every field, the `summary` line is ready for an agent to read, and `id` stays the same across runs, so you can de-duplicate on it.

#### What happens if a run times out or restarts?

Notices already saved are neither saved nor charged again, and finished sources aren't searched again. If the time limit gets close, the run stops starting new pages and finishes successfully with what it has.

### More from Meridian Labs

- **[Greenhouse, Lever & Ashby Jobs Scraper](https://apify.com/meridianlabs/greenhouse-lever-ashby-jobs-scraper)**: open jobs from companies on six hiring systems, with salary normalised to min, max, currency and period. $2 per 1,000 jobs.
- **[Competitor Keyword Research](https://apify.com/meridianlabs/competitor-keywords)**: every keyword a website ranks for in Google, with position, ranking page, search volume and estimated traffic, plus a plain-English summary per domain. $0.03 per domain + $2 per 1,000 keywords.
- **[Backlink Checker](https://apify.com/meridianlabs/backlink-checker)**: domain rank, backlinks, referring domains and spam score for up to 1,000 domains. $0.03 per domain + $4 per 1,000 rows.
- **[Keyword Search Volume & CPC API + Google Trends](https://apify.com/meridianlabs/keyword-search-volume)**: monthly search volume, CPC, competition and difficulty for keyword lists, plus a Google Trends summary. From $3 per 1,000 keywords.
- **[Google Trends Scraper & API](https://apify.com/meridianlabs/google-trends-scraper)**: interest over time, by region and rising related searches for hundreds of keywords. $5 per 1,000 keyword lookups.
- **[Startup Funding Rounds & Founders API](https://apify.com/meridianlabs/sec-form-d-funding-rounds)**: US startups that just raised, from SEC Form D filings: amount raised, investor count, founders and executives, and a one-line summary. $10 per 1,000 filings.

### Support

A notice that doesn't look right, or a source or field you need? Open an issue on the **Issues** tab with the notice link or your input. We read every one.

If this saved you time, a rating helps others find it; if something's off, open an issue and we'll fix it fast.

# Actor input Schema

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

Where to search. ted = TED (Tenders Electronic Daily), the EU's official journal of public procurement: all EU/EEA countries plus EU institutions. uk = Find a Tender, the UK government's official service (Procurement Act 2023 and older notices).

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

Words or phrases to find in the notice, e.g. software, road resurfacing, cleaning services. A notice matches if it contains ANY of them. TED searches its full text in every language (its index includes translated CPV labels, so English words also find many non-English notices); UK notices are matched on title, description and CPV label. Leave empty for all notices.

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

Common Procurement Vocabulary codes, e.g. 72000000 (IT services), 45233000 (road works), 90910000 (cleaning). Broader codes include everything under them: 45000000 matches all construction work. 45233000-9 and short prefixes like 452 are accepted.

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

Country of the contracting authority, as ISO codes or names: FR or FRA, DE or DEU, UK or GBR, Ireland … Leave empty for all. A list without the UK skips the UK source (free).

## `buyerName` (type: `string`):

Part of the contracting authority's name, e.g. Lyon, NHS, Bundesamt.

## `noticeTypes` (type: `array`):

contract\_notice = open calls for tenders you can still bid on. award = who won and for how much (organisations only). prior\_information = planned purchases and market engagement. other = changes, cancellations, completions.

## `publishedWithinDays` (type: `integer`):

Publication window ending today. Ignored when 'Published on or after' is set. TED publishes Monday to Friday.

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

YYYY-MM-DD. Replaces 'Published in the last N days'. Windows up to 366 days.

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

YYYY-MM-DD. Default today.

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

YYYY-MM-DD. Set it to today to get only tenders still open. Notices without a deadline are left out when a deadline filter is set.

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

YYYY-MM-DD.

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

Estimated value (awarded value for awards), in the notice's own currency. Notices without a value are left out when a value filter is set.

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

Same rules as the minimum.

## `valueCurrency` (type: `string`):

Optional 3-letter code (EUR, GBP, PLN, SEK …). When set, only notices valued in this currency pass the value filter, so EUR and SEK amounts are never compared.

## `maxNoticesPerSource` (type: `integer`):

Newest first. 0 = no limit (a week of every TED notice is about 17,000). You pay only for notices saved.

## `mode` (type: `string`):

Monitor mode remembers which notices it returned (per monitor name and search), so a daily schedule returns, and charges, only new ones. The first run sees every match as new.

## `monitorName` (type: `string`):

Separate names keep separate memories, e.g. one per client or alert. Only used in monitor mode.

## `tedQuery` (type: `string`):

Added with AND to the TED search, in TED's expert-search syntax, e.g. place-of-performance-country-proc IN (IRL). Not applied to UK notices.

## `failOnErrors` (type: `boolean`):

For schedules: the run is marked failed (so Apify can alert you) if TED or Find a Tender couldn't be searched or changed its format. Notices already saved stay saved and charged; failures are never charged.

## Actor input object example

```json
{
  "sources": [
    "ted",
    "uk"
  ],
  "keywords": [
    "software"
  ],
  "noticeTypes": [
    "contract_notice"
  ],
  "publishedWithinDays": 7,
  "maxNoticesPerSource": 10,
  "mode": "all",
  "monitorName": "default",
  "failOnErrors": false
}
```

# Actor output Schema

## `notices` (type: `string`):

One row per notice with the plain-English summary (dataset view 'notices'). Every dataset row is one charged notice.

## `awards` (type: `string`):

Award notices: winners and awarded values (dataset view 'awards').

## `sources` (type: `string`):

One free row per source: what was searched, scanned, saved and charged, and why it stopped.

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

Every field of every notice, including CPV lists, description and attribution.

# 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"
    ],
    "keywords": [
        "software"
    ],
    "noticeTypes": [
        "contract_notice"
    ],
    "maxNoticesPerSource": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("meridianlabs/eu-uk-tenders-scraper").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",
    ],
    "keywords": ["software"],
    "noticeTypes": ["contract_notice"],
    "maxNoticesPerSource": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("meridianlabs/eu-uk-tenders-scraper").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"
  ],
  "keywords": [
    "software"
  ],
  "noticeTypes": [
    "contract_notice"
  ],
  "maxNoticesPerSource": 10
}' |
apify call meridianlabs/eu-uk-tenders-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,meridianlabs/eu-uk-tenders-scraper"
        }
    }
}
```

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/0VsQ0W5I921SzPKz3/builds/di4yzM0Efnvs2zR1f/openapi.json