# TED Tenders Scraper - EU Public Procurement & Contract Awards (`kadi_bence/ted-tenders-scraper`) Actor

Find open EU public tenders and contract award winners on TED (Tenders Electronic Daily), all EU/EEA countries. Input: keywords, countries, CPV, NUTS, deadline, value, notice type (tenders or awards). Returns per notice: title, buyer, value, winners, deadline, URL. Default: 20. $1.50/1K.

- **URL**: https://apify.com/kadi_bence/ted-tenders-scraper.md
- **Developed by:** [Bence Kadi](https://apify.com/kadi_bence) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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 Public Tenders Scraper (TED): public procurement data API

Export **EU public tenders and contract awards** from **TED (Tenders Electronic Daily)** to JSON, CSV or Excel. One clean row per notice: title, buyer, CPV category, estimated value, deadline, **award winners and awarded values**, NUTS region and links. No API key, no browser, no 15,000-result cap.

### What is the EU Public Tenders Scraper (TED)?

TED is the official journal for public procurement in the European Union. Every working day it publishes about 1,000 new notices from 30+ European countries: calls for tenders, contract awards, planned purchases and more. This Actor reads the official TED API v3 for you, translates simple filters (countries, CPV codes, dates, values) into TED's query language and returns a flat, ready-to-use table.

**Who uses it and why:**

- **Bid and tender managers** get a daily list of new calls for tenders in their CPV codes and countries, with deadlines, in Google Sheets, Slack or their CRM.
- **B2G sales teams** find public buyers that purchase what they sell, and see what those buyers paid in earlier contracts.
- **Competitive intelligence analysts** track which companies win contracts in their market, and for how much (`winners`, `awardedValue`).
- **Market researchers and consultants** size public-sector demand by category, region and value.
- **Tender portals, SaaS products and AI agents** feed fresh EU procurement data into their own search, alerts or matching features.
- **Journalists and NGOs** follow public spending by a specific buyer, such as a city or a hospital.

#### Data fields

Every notice is one dataset item with these fields. Examples are from real runs.

| Field | Description | Example |
|---|---|---|
| `publicationNumber` | TED notice ID (unique) | `685614-2026` |
| `title` | Notice title, in English when the buyer published one | `Software for Manager Skill and Portfolio Analysis` |
| `titleLanguage` | Language of `title` | `en` |
| `description` | Short description of what is being bought (contact data removed) | `The subject of this Procurement is a Platform for portfolio manager analysis.` |
| `noticeType` | Notice type in plain English | `Contract award notice` |
| `noticeTypeCode` | TED eForms notice subtype | `can-standard` |
| `contractNature` | Works, supplies or services | `services` |
| `buyerName` | Contracting authority | `Fjärde AP-fonden` |
| `buyerCountry` | Buyer country (2-letter code) | `SE` |
| `buyerCity` | Buyer city | `Stockholm` |
| `mainCpv` | Main CPV code | `72000000` |
| `mainCpvLabel` | English label of the main CPV code | `IT services: consulting, software development, Internet and support` |
| `cpvCodes` | All CPV codes in the notice | `["72000000", "48000000"]` |
| `estimatedValue` | Estimated value of the whole procedure (empty if not published) | `7500000` |
| `currency` | Currency of `estimatedValue` | `SEK` |
| `awardedValue` | Total value awarded (award notices) | `6030000` |
| `awardedCurrency` | Currency of `awardedValue` | `SEK` |
| `winners` | Names of the winning companies | `["SEI Global Services INC"]` |
| `winnerCountries` | Countries of the winners | `["SE"]` |
| `winnersOmitted` | How many winners were left out because they are natural persons | `0` |
| `publicationDate` | Date TED published the notice | `2026-10-05` |
| `deadline` | Deadline for tenders or requests to participate | `2026-11-04T09:59:00+01:00` |
| `procedureType` | Procedure (open, restricted, negotiated...) | `Open` |
| `placeOfPerformanceNuts` | NUTS regions where the contract is performed | `["DEA2C", "DEA22"]` |
| `placeOfPerformanceCountries` | Countries where the contract is performed | `["DE"]` |
| `lotsCount` | Number of lots | `1` |
| `url` | Notice page on ted.europa.eu | `https://ted.europa.eu/en/notice/-/detail/685607-2026` |
| `pdfUrl` | Official PDF of the notice | `https://ted.europa.eu/en/notice/685607-2026/pdf` |
| `xmlUrl` | Official eForms XML | `https://ted.europa.eu/en/notice/685607-2026/xml` |
| `language` | Original language of the notice | `de` |
| `isNew` | Only in monitoring mode: `true` for notices not seen before | `true` |
| `scrapedAt` | When the Actor saved the item (UTC) | `2026-10-05T00:05:59Z` |

### How to use the TED tenders scraper

1. Open the Actor and click **Try for free** (you need a free Apify account).
2. Pick **Buyer countries** and **Notice types**. "Contract notice" = open calls you can still bid on; "Contract award" = who won and for how much.
3. Set a date window, for example **Published within the last N days** = 7.
4. Optionally add **Keywords**, **CPV codes**, a **minimum value** or **NUTS regions**.
5. Set **Max results** (the prefill is 20 so the first run takes a few seconds) and click **Start**.
6. Open the **Output** tab and download the data as CSV, Excel or JSON, or send it to Google Sheets.
7. For alerts, turn on **Only new notices**, then create a daily **Schedule** (see below).

#### Input guide

**Keywords.** Full-text search over the whole notice, in any EU language. Each line is one search term; several lines are combined with OR.

- Good: `cloud computing`, `Reinigung`, `nettoyage` (TED notices are mostly in the buyer's own language, so add local words).
- Bad: one long sentence like `we sell cloud software to hospitals`. That rarely matches anything. Use short terms and CPV codes instead.

**Buyer countries.** The country of the contracting authority, picked from a list. Leave it empty for all of Europe.

**CPV codes.** The Common Procurement Vocabulary is the EU's product and service catalogue. Every notice has a main CPV code. Sub-categories are included automatically.

- Good: `72000000` (all IT services, including 72100000, 72260000 ...), `45000000` (construction work), or a short prefix such as `72`.
- Bad: `72000000-5`. The digit after the dash is a check digit. The Actor handles it, but the 8 digits alone are enough.
- Tip: to find your codes, run a keyword search first and look at `mainCpv` and `cpvCodes` in the results. Then switch to CPV codes, which are language-independent.

**Notice types.** `contract_notice`, `contract_award`, `prior_information`, `voluntary_ex_ante`, `contract_modification`, `market_consultation`. Leave empty for all.

**Date window.** Use **Published within the last N days** for rolling searches (`7` = the last week, `1` = yesterday and today). Use **Published from / to** (YYYY-MM-DD) for a fixed period, for example a full year of award notices for research. If you set both, both conditions apply, so clear the prefilled `7` when you want a fixed period further back.

- Warning: with no date window, no filters and **Max results** = 0, the Actor would export millions of notices. It logs a warning first.

**Submission deadline on or after.** Only tenders you can still bid on. Accepts a date (`2026-11-01`), `today` or `+14 days` (at least two weeks left to prepare).

**Min / max estimated value.** The estimated value of the whole procedure, in the notice's own currency (most notices use EUR). About half of buyers do not publish a value, and those notices are excluded when you set a minimum or maximum.

**Buyer name contains.** Words in the buyer's name, for example `Charité` or `Stadt München`. Accents do not matter.

**NUTS codes.** The EU's region codes for where the work is done. Sub-regions are included: `DE2` returns every Bavarian region, `FR10` is Île-de-France, `ITC4` is Lombardy.

**Max results.** Stop after N notices. `0` = no limit. This is also your cost cap: 1,000 notices cost $1.50.

**Only new notices (monitoring mode).** The Actor remembers which notices it returned and outputs only new ones on the next run with the same filters. You pay only for new notices. Use a different **Monitor name** for each saved search that should keep its own "already seen" list. Changing any filter also starts a new list.

**Expert query.** A raw TED expert-search query, for example `buyer-country=DEU AND classification-cpv=72000000 AND publication-date>=today(-7)`. It replaces all the filters above. Test it first at ted.europa.eu (Search > Expert search).

**Proxy.** Not needed. TED is an open-data API, so the proxy is off by default.

#### Input example: open IT tenders in Germany and Austria

```json
{
  "countries": ["DE", "AT"],
  "cpvCodes": ["72000000", "48000000"],
  "noticeTypes": ["contract_notice"],
  "publishedWithinDays": 7,
  "deadlineAfter": "today",
  "minEstimatedValue": 100000,
  "maxResults": 500,
  "onlyNewNotices": true
}
```

### Output

Each notice is one item in the run's dataset. This is a real award notice from a run on 2026-10-05:

```json
{
  "publicationNumber": "685614-2026",
  "title": "Software for Manager Skill and Portfolio Analysis",
  "titleLanguage": "en",
  "description": "The subject of this Procurement is a Platform for portfolio manager analysis.",
  "noticeType": "Contract award notice",
  "noticeTypeCode": "can-standard",
  "contractNature": "services",
  "buyerName": "Fjärde AP-fonden",
  "buyerCountry": "SE",
  "buyerCity": "Stockholm",
  "mainCpv": "72000000",
  "mainCpvLabel": "IT services: consulting, software development, Internet and support",
  "cpvCodes": ["72000000", "48000000", "48700000", "72220000", "72250000"],
  "estimatedValue": 7500000,
  "currency": "SEK",
  "awardedValue": 6030000,
  "awardedCurrency": "SEK",
  "winners": ["SEI Global Services INC"],
  "winnerCountries": ["SE"],
  "winnersOmitted": 0,
  "publicationDate": "2026-10-05",
  "deadline": null,
  "procedureType": "Open",
  "placeOfPerformanceNuts": ["SE110"],
  "placeOfPerformanceCountries": ["SE"],
  "lotsCount": 1,
  "url": "https://ted.europa.eu/en/notice/-/detail/685614-2026",
  "pdfUrl": "https://ted.europa.eu/en/notice/685614-2026/pdf",
  "xmlUrl": "https://ted.europa.eu/en/notice/685614-2026/xml",
  "language": "en",
  "scrapedAt": "2026-10-05T00:00:00Z"
}
```

On contract notices, `deadline` holds the tender deadline, for example `"2026-11-04T09:59:00+01:00"`, and the winner fields are empty. `mainCpvLabel` is always in English.

In a live sample of 1,500 recent notices, title, description, buyer, country, city, CPV and links were filled for 100% of notices. For contract notices the deadline was filled for 97%. For award notices the awarded value was filled for 91% and the winners for 90%. The estimated value was filled for about 50%, because many buyers keep it confidential.

**Dataset views.** The **Output** tab shows three tables:

- **Notices**: date, title, type, buyer, country, CPV label, estimated value, deadline, link. Best for daily review.
- **Awards and winners**: buyer, winners, awarded value, CPV, link. Best for competitor analysis.
- **Full details**: description, procedure, all CPV codes, NUTS regions, lots, language, PDF link.

Every run also saves a **Run summary** (`RUN_SUMMARY` in the key-value store) with the TED query used, the number of matching notices, notices saved, notices skipped in monitoring mode and any API problems.

**Export.** Download any view as JSON, CSV, Excel, XML, HTML or RSS from the Output tab or the API. You can also send results straight to Google Sheets with the Google Sheets integration.

### Pricing

This Actor uses **pay per event**: **$1.50 per 1,000 notices** saved ($0.0015 per notice). Apify also charges a start fee of **$0.00005 per run**. Platform compute is included in the price.

| Typical run | Notices | Cost |
|---|---|---|
| First test with the prefilled input | 20 | about $0.03 |
| Weekly export for one country and one CPV area | 1,000 | about $1.50 |
| Daily alert, about 50 new notices a day, for 30 days | 1,500 | about $2.25 per month |
| Bulk research export, one year of award notices | 20,000 | about $30 |

**What is free:**

- In monitoring mode, notices that were already returned in earlier runs are skipped and not charged.
- A search with no matches costs only the $0.00005 start fee.
- Apify's free plan gives you monthly platform credit (see apify.com/pricing), enough for a few thousand notices each month.

You can cap spending with **Max results** or with **Max charge per run** in the run options. When the cap is reached, the Actor stops cleanly and keeps what it already saved.

### Use it via API

Replace `MY_APIFY_TOKEN` with your token from Apify Console > Settings > API & Integrations.

**JavaScript / Node.js** (`npm install apify-client`):

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });
const run = await client.actor('kadi_bence/ted-tenders-scraper').call({
    countries: ['DE', 'AT'],
    cpvCodes: ['72000000'],
    noticeTypes: ['contract_notice'],
    publishedWithinDays: 7,
    deadlineAfter: 'today',
    maxResults: 500,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0]?.title);
```

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("MY_APIFY_TOKEN")
run = client.actor("kadi_bence/ted-tenders-scraper").call(run_input={
    "countries": ["FR"],
    "noticeTypes": ["contract_award"],
    "publishedWithinDays": 30,
    "maxResults": 1000,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["buyerName"], item["winners"], item["awardedValue"], item["awardedCurrency"])
```

**cURL** (runs the Actor and returns the items in one call):

```bash
curl -X POST "https://api.apify.com/v2/acts/kadi_bence~ted-tenders-scraper/run-sync-get-dataset-items?token=MY_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"countries": ["IT"], "cpvCodes": ["45000000"], "noticeTypes": ["contract_notice"], "publishedWithinDays": 1, "maxResults": 100}'
```

**Apify CLI:**

```bash
apify call kadi_bence/ted-tenders-scraper --input '{"countries": ["ES"], "publishedWithinDays": 3, "maxResults": 50}' --output-dataset
```

**MCP (AI agents such as Claude, Cursor or VS Code).** Add this to your MCP client config. The client will ask you to sign in to Apify (or send your token as an `Authorization: Bearer` header):

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com/?actors=kadi_bence/ted-tenders-scraper"}}}
```

Then ask your agent things like "Find open IT tenders in Austria with a deadline after next week".

### Integrations and scheduling

- **Schedules.** In Apify Console go to **Schedules > Create new**, pick this Actor (or a saved task) and set a cron time, for example every weekday at 07:00.
- **Webhooks.** Call your own URL when a run succeeds or fails, and fetch the new items from the dataset.
- **Zapier, Make and n8n.** Use the Apify app or node: "Run Actor" as an action, or "Actor run finished" as a trigger, then send rows to your CRM, Slack, Teams or e-mail.
- **Google Sheets.** Use the Google Sheets integration on the Actor's **Integrations** tab to append each run's results to a sheet.

**Recipe: new tenders in my CPV codes every morning**

1. Set your filters: countries, CPV codes, **Notice types** = Contract notice, **Published within the last N days** = 2, **Submission deadline on or after** = `+7 days`.
2. Turn on **Only new notices** and give the monitor a name, such as `it-dach`.
3. Click **Save as a new task**, then add a schedule: every day at 07:00.
4. Connect the task to Google Sheets or to Slack through Make, Zapier or n8n. Each morning you get only the notices you have not seen yet.

**Recipe: weekly competitor wins.** Notice types = Contract award, your CPV codes and countries, **Published within the last N days** = 7, weekly schedule, export the **Awards and winners** view to a sheet.

### Related actors by the same developer

- [US Federal Contracts Scraper (SAM.gov)](https://apify.com/kadi_bence/sam-gov-scraper): US federal contract opportunities and awards, with NAICS and set-aside filters.
- [UK & Australia Tenders Scraper](https://apify.com/kadi_bence/gov-tenders-scraper): UK Find a Tender, UK Contracts Finder and AusTender notices, with the same field names as this Actor.

### FAQ

**How does it work, and where does the data come from?**
The Actor sends your filters as one query to the official TED Search API v3, run by the Publications Office of the European Union, and pages through all results. No browser and no API key are used. TED notices are open data that you may re-use, also commercially, under the [EU's re-use policy](https://eur-lex.europa.eu/eli/dec/2011/833/oj) (Commission Decision 2011/833/EU, CC BY 4.0). Please keep this attribution when you publish the data: "Source: TED – Tenders Electronic Daily, © European Union, https://ted.europa.eu".

**Are there limits?**
There is no 15,000 cap. TED's normal page-based search stops at 15,000 notices, but this Actor uses TED's scroll (iteration) mode, so it can export any number. TED's fair-usage limit (700 requests per minute) is never reached, because each request returns 250 notices. If TED answers "429 Too Many Requests", the Actor waits and retries.

**How fast is it?**
Usually 3,000 to 6,000 notices per minute. In our tests 1,500 notices took 16 seconds and 17,500 notices took about 5 minutes.

**How fresh is the data?**
As fresh as TED. TED publishes new notices every working day, and the Actor reads them live at run time, so a notice is in your results as soon as it is on ted.europa.eu.

**Why are my results different from the TED website?**
Common reasons: CPV and NUTS sub-codes are always included here; the date filters use the TED publication date; keywords search the full notice text; winners that are natural persons are left out; and new notices appear during the day, so two searches minutes apart can differ. Check `RUN_SUMMARY` to see the exact query the Actor used, and paste it into TED's expert search to compare.

**Why is the estimated value or the deadline sometimes empty?**
Buyers do not always publish them. Award notices have no deadline, and many contract notices keep the value confidential. The Actor never invents values: a TED value of 0 is returned as empty.

**Is it legal? What about personal data?**
Yes. The data is official open data published for re-use. The Actor does not collect contact names, e-mails or phone numbers: e-mails and phone numbers are removed from descriptions, and winners that are natural persons (as flagged by the buyer, or sole traders such as "PFA" or "ditta individuale") are omitted. `winnersOmitted` shows how many were left out. Descriptions written by buyers can still mention people, so handle the data in line with GDPR.

**Are old notices supported?**
Yes. Notices from before eForms (before about 2024) have fewer fields: descriptions and deadlines are often missing, and the title is TED's English headline.

**Can I use it from Python or another program?**
Yes. See **Use it via API** above for JavaScript, Python, cURL, the Apify CLI and MCP for AI agents.

**Can I connect it to Google Sheets, Slack or my CRM?**
Yes, through the Google Sheets integration, webhooks, or the Apify apps for Zapier, Make and n8n. See **Integrations and scheduling**.

**How does "Only new notices" work?**
The Actor stores the IDs of returned notices in a named key-value store in your account. The next run with the same filters and monitor name outputs only notices that are not in that list, marked `isNew: true`. You pay only for those. Change the monitor name to start a fresh list.

**What if a run fails or something looks wrong?**
If TED rejects the query, the run fails with a clear message (for example an invalid expert query) and `RUN_SUMMARY` holds the details. If TED is down, the Actor retries several times before stopping and keeps what it already saved. Please open an issue on the **Issues** tab with the run link. Fixes usually land within 24 to 48 hours.

**What changed recently?**
See the changelog below.

### Related Actors

More low-cost Actors by the same developer, built on official APIs and public data:

- [SAM.gov Scraper](https://apify.com/kadi_bence/sam-gov-scraper) — US federal contract opportunities and awards
- [UK & Australia Tenders Scraper](https://apify.com/kadi_bence/gov-tenders-scraper) — government contracts from the UK and Australia
- [Document to Markdown](https://apify.com/kadi_bence/document-to-markdown) — PDF, Word, PowerPoint and Excel to clean Markdown, with OCR
- [SEC Form D Scraper](https://apify.com/kadi_bence/sec-form-d-funding) — new startup funding rounds from SEC EDGAR
- [New Business Filings USA](https://apify.com/kadi_bence/us-new-business-filings) — newly registered LLCs and companies
- [Website Tech Stack Detector](https://apify.com/kadi_bence/tech-stack-detector) — CMS, ecommerce, analytics and frameworks of any website
- [EURES Jobs Scraper](https://apify.com/kadi_bence/eures-jobs-scraper) — EU job vacancies from 31 countries

All my Actors: [apify.com/kadi_bence](https://apify.com/kadi_bence)

### Changelog

- **1.0 (2026-10-05):** First release. TED API v3 with iteration mode, award winners and values, monitoring mode, CPV/NUTS hierarchy, GDPR filtering.

# Actor input Schema

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

Words or phrases searched in the full notice text, in any EU language, e.g. 'software', 'cloud computing', 'Reinigung'. Several lines = any of them (OR). Notices are mostly in the buyer's language, so add local words. Use short terms, not sentences. Leave empty to get all notices that match the other filters.

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

Country of the contracting authority. Leave empty for all countries.

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

Common Procurement Vocabulary codes, e.g. 72000000 (IT services) or 45000000 (construction work). Sub-categories are included automatically: 72000000 also returns 72100000, 72260000 ... You can also type a short prefix like 72.

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

Leave empty for all types. Pick 'Contract notice' for open calls you can still bid on, 'Contract award' for who won and for how much.

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

e.g. 7 for the last week, 1 for yesterday and today. Leave empty to use the date range below (or no date limit).

## `publishedFrom` (type: `string`):

First publication date (YYYY-MM-DD).

## `publishedTo` (type: `string`):

Last publication date (YYYY-MM-DD).

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

Only tenders you can still bid on: notices whose tender (or request-to-participate) deadline is on or after this date. Tip: also accepts 'today' or '+14 days'.

## `minEstimatedValue` (type: `integer`):

Estimated contract value of the whole procedure, in the notice's own currency (most notices are in EUR). Notices without a published value are excluded when you set this.

## `maxEstimatedValue` (type: `integer`):

Same currency rule as above.

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

Words in the contracting authority's name, e.g. 'Charité' or 'Stadt München'. Accents don't matter.

## `nutsCodes` (type: `array`):

Regions where the contract is performed, e.g. DE2 (Bavaria), FR10 (Paris area), ITC4 (Lombardy). Sub-regions are included.

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

Stop after this many notices. 0 = no limit (there is no 15,000 cap). The default without input (API, MCP and AI-agent calls) is 20.

## `onlyNewNotices` (type: `boolean`):

Remember returned notices and output only NEW ones on the next runs with the same search. Ideal for a daily schedule: you only pay for new notices.

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

Keeps separate 'already seen' lists for different schedules.

## `expertQuery` (type: `string`):

A raw TED expert-search query, e.g. buyer-country=DEU AND classification-cpv=72000000 AND publication-date>=today(-7). Replaces ALL filters above. Test it at ted.europa.eu/en/search/expert-search. Newest first unless you add SORT BY.

## `proxyConfiguration` (type: `object`):

Not needed: TED is an open-data API.

## Actor input object example

```json
{
  "countries": [
    "DE"
  ],
  "noticeTypes": [
    "contract_notice"
  ],
  "publishedWithinDays": 7,
  "maxResults": 20,
  "onlyNewNotices": false,
  "monitorName": "default",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All scraped notices (table view).

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

Award notices with winners and awarded values.

## `noticesFull` (type: `string`):

All scraped notices with every field.

## `summary` (type: `string`):

The TED query used, matching count, notices saved and any problems.

# 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 = {
    "countries": [
        "DE"
    ],
    "noticeTypes": [
        "contract_notice"
    ],
    "publishedWithinDays": 7,
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kadi_bence/ted-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 = {
    "countries": ["DE"],
    "noticeTypes": ["contract_notice"],
    "publishedWithinDays": 7,
    "maxResults": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("kadi_bence/ted-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 '{
  "countries": [
    "DE"
  ],
  "noticeTypes": [
    "contract_notice"
  ],
  "publishedWithinDays": 7,
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call kadi_bence/ted-tenders-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kadi_bence/ted-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/hc5do5hnxeHJxQHX4/builds/FcfeeO9n0elF9TVWG/openapi.json