# EU Public Tenders Monitor - TED & BOAMP (Only New) (`far003/eu-public-tenders`) Actor Monitor public procurement notices from TED (all EU countries) and BOAMP (France) by keyword, country, CPV code, deadline and value. One clean schema, official source links, optional mode that returns only notices you have not received before. No personal data. - **URL**: https://apify.com/far003/eu-public-tenders.md - **Developed by:** [Francesco Antonio Russo](https://apify.com/far003) (community) - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing $1.50 / 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. 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 Monitor — TED & BOAMP tender notices, only the new ones Find public tenders across **all EU countries** (TED, the EU's official procurement journal) and in **France, including the small contracts that never reach TED** (BOAMP), in one clean schema. Filter by keyword, buyer country, CPV code, notice type, offer deadline and value. Turn on **Only new notices**, schedule the Actor, and every run hands you just the tenders you have not seen before. Every record links to the official notice and carries its licence and attribution. It reads the two official open-data interfaces (no browser, no proxy, no login, no workaround), so it keeps working when the portals change their pages. It never delivers the names, e-mail addresses or phone numbers of contact persons: a record is about the procurement and the contracting authority, nothing else. ### Who it is for - **Companies that bid for public contracts** and want a daily list of the tenders in their field, with the deadline and the value in the same row. - **Bid consultants and tender agencies** watching many clients: one feed per client (a *Feed name* each), each remembering what it has already delivered. - **Sales and market analysts** looking at who buys what, where, and for how much, using the award notices. - **Developers** who need a tender API without writing a TED client: one request, JSON out. ### What you get One record per notice: identifiers, type and procedure, title in the buyer's own language (plus the English headline TED builds), description, the contracting authority (name, country, city), the main CPV code with its English name, the estimated value (and the awarded value for award notices), publication date, offer deadline, and a link to the official notice. Anything a notice does not state is `null`: nothing is guessed or filled in. #### Real example: a TED contract notice Run on 19 October 2026 (description shortened for this page): ```json { "id": "ted:722163-2026", "source": "TED", "noticeId": "722163-2026", "procedureId": "c787190e-bcd5-4b10-9fb8-b46298a4d75e", "noticeType": "cn-standard", "noticeTypeLabel": "Contract or concession notice (standard regime)", "noticeCategory": "tender", "procedureType": "open", "procedureTypeLabel": "Open", "contractNature": "services", "title": "Maintenance et acquisition de licences BO SAP et prestations de montée de version", "titleLanguage": "fr", "englishHeadline": "France – Software development services – Maintenance et acquisition de licences BO SAP et prestations de montée de version", "description": "L'accord-cadre sera exécuté par l'émission de bons de commande. Les prestations sont réglées par des prix unitaires et forfaitaires. Les montants estimatifs sont...", "buyerName": "Région Hauts-de-France", "otherBuyers": [], "buyerCountry": "FR", "buyerCountryName": "France", "buyerCity": "Lille", "cpvCode": "72262000", "cpvDescription": "Software development services", "additionalCpvCodes": [], "estimatedValue": 600000, "estimatedValueCurrency": "EUR", "estimatedValueBasis": "procedure", "awardedValue": null, "awardedValueCurrency": null, "publicationDate": "2026-10-19", "dispatchDate": "2026-10-16", "deadlineDate": "2026-11-06", "deadline": "2026-11-06T12:00:00+01:00", "deadlineType": "tender", "deadlines": [{ "type": "tender", "deadline": "2026-11-06T12:00:00+01:00" }], "url": "https://ted.europa.eu/en/notice/-/detail/722163-2026", "alsoOnTed": null, "sourceLicense": "Free reuse, commercial included (European Commission Decision 2011/833/EU, TED legal notice)", "attribution": "Source: TED (Tenders Electronic Daily), Publications Office of the European Union, https://ted.europa.eu - (c) European Union. Notices can be freely reused, for commercial or non-commercial purposes.", "retrievedAt": "2026-10-19T12:36:28.530Z" } ``` #### Real example: a BOAMP notice (a French contract below the EU threshold) ```json { "id": "boamp:26-101070", "source": "BOAMP", "noticeId": "26-101070", "noticeType": "APPEL_OFFRE", "noticeTypeLabel": "Contract notice (avis de marché)", "noticeCategory": "tender", "procedureType": "OUVERT", "contractNature": "services", "title": "Maintenance des systèmes de sureté du MAC VAL - Musée d'art contemporain du Val-de-Marne", "titleLanguage": "fr", "buyerName": "Département du Val-de-Marne", "buyerCountry": "FR", "buyerCity": null, "cpvCode": "50324100", "cpvDescription": "System maintenance services", "additionalCpvCodes": ["35125000"], "estimatedValue": 140000, "estimatedValueCurrency": "EUR", "publicationDate": "2026-10-18", "deadlineDate": "2026-12-04", "deadline": "2026-12-04", "deadlineType": "tender", "url": "https://www.boamp.fr/pages/avis/?q=idweb:26-101070", "sourceLicense": "Licence Ouverte / Open Licence 2.0 (Etalab)" } ``` (This one is shortened: the full record has the same 38 fields as the TED one.) #### Real example: an award notice With `noticeTypes: ["award"]`, the same schema tells you who bought what and for how much. Here `estimatedValue` is what the buyer expected to pay and `awardedValue` what the contract was awarded for: ```json { "id": "ted:722544-2026", "noticeCategory": "award", "title": "Lieferung von elektrischer Energie für die Nord-West Kavernengesellschaft mbH (NWKG) für die Lieferjahre 2027 und 2028", "buyerName": "Nord-West Kavernengesellschaft mbH", "buyerCountry": "DE", "cpvCode": "09310000", "cpvDescription": "Electricity", "estimatedValue": 10600000, "awardedValue": 10780000, "awardedValueCurrency": "EUR", "procedureId": "914ee352-c770-4629-8e1c-3ce98d5435be" } ``` The `procedureId` is shared by the tender and its award, so you can link the two. ### How to use it 1. Start the prefilled input for a first look: tenders published in the last 7 days that mention *cybersecurity*, at most 25 per source. 2. Set your own **keywords**, **countries**, **CPV codes**, **value** and **deadline** filters. 3. For a feed, turn on **Only new notices**, give it a **Feed name**, and put the Actor on a schedule (daily is typical; use *Published in the last N days* = 3 or more, because TED publishes on working days and notices reach it some days after the buyer sends them). #### Input | Field | What it does | |---|---| | `keywords` | Notices that mention any of these words or phrases anywhere in the notice text. Use the language of the notices: `cybersecurity`, `bridge inspection` for TED; `logiciel`, `nettoyage` for the French BOAMP. | | `countries` | Buyer countries: `IT`, `ITA`, `Italy`, `UK`, `Germany`... TED is filtered by the buyer's country. BOAMP is read only if France is on the list (or the list is empty). | | `cpvCodes` | CPV codes with or without the check digit (`72000000` or `72000000-5`). A code covers its branch: `72000000` also finds `72212000`, and `45` finds all construction. | | `noticeTypes` | `tender` (default), `award`, `planning` (prior information), `modification`, `other` (corrections, cancellations, qualification systems...). | | `sources` | `ted`, `boamp`, or both (default). | | `publishedLastDays` / `publishedFrom` / `publishedTo` | The publication window. Default: the last 7 days, today included. | | `minDaysToDeadline` / `deadlineFrom` | Keep tenders you still have time for. Notices without a deadline (awards, most planning notices) are left out when this is set. Both filters look at the deadline for offers or, in restricted and negotiated procedures, for requests to participate. | | `estimatedValueMin` / `estimatedValueMax` | Value range in euro. Values in another currency are not converted and count as unknown. | | `includeUnknownValue` | With a value filter: also deliver the notices that state no value. They are charged. | | `maxResultsPerSource` | The main cost control: at most this many notices from each source, newest first. Default 100. | | `onlyNew`, `stateKey`, `baselineOnFirstRun` | The feed mode, below. | Dirty input is cleaned, not rejected: country codes in any case, CPV codes with or without the check digit or as a short prefix, dates as `2026-10-01` or `20261001`, numbers written as text, quotes and brackets inside keywords. An entry that cannot be understood is skipped with a warning in the log. If **every** entry of a filter is invalid (all your countries unknown, say), the Actor does **not** start a wider search than you asked for: it ends cleanly with the reasons in the `SUMMARY` record and charges nothing. The same goes for a value that cannot be read at all, such as a date that does not exist or `maxResultsPerSource: "ten"`: the cost limit and the filters are never guessed. #### Only new notices (the feed mode) With `onlyNew` on, the Actor remembers every notice it has delivered under your **Feed name** and delivers only the others on the next run. You pay only for what is delivered. On a real test (13 notices matching *software* or *logiciel* from French buyers in the last 3 days, both sources), the first run delivered 13 records and charged for 13; the second run, a moment later with the same input, delivered **0** and charged nothing: it recognised all 13 as already delivered. - A notice is remembered when it is delivered. Notices left out by `maxResultsPerSource` or by your spending limit are **not** remembered, so they come with the next run. - The first run delivers (and charges) everything that matches. Turn on **Skip existing notices on the first run** to make the first run only record what is there now, deliver nothing and charge nothing; later runs deliver only what appeared after that. - A different Feed name is a different feed with its own first run. Use one per client or per set of filters. To start a feed again from zero, delete the key `seen.` in the named key-value store `eu-public-tenders-state`. - The same French tender published on both TED and BOAMP is delivered once. This also holds across runs: if BOAMP shows a tender first and TED publishes it a few days later, the TED copy is recognised and not charged again. #### Output The dataset has a **Tenders** table view (published, title, buyer, country, subject, value, deadline, notice type, link) and an **Awards** view. A `SUMMARY` record in the key-value store tells you, for each source, how many notices matched, how many were read and delivered, why others were left out (not the right type, deadline, value, already seen, duplicate), and whether a limit stopped the run. | Field | Meaning | |---|---| | `id` | Unique key: `ted:` or `boamp:` plus the notice number. Use it as the primary key. | | `source` | `TED` or `BOAMP`. | | `noticeId` | Number of the notice in its source (TED publication number, BOAMP idweb). | | `procedureId` | UUID of the procurement procedure, shared by its tender, award and modifications. `null` when the notice has none. | | `noticeType`, `noticeTypeLabel` | The source's type code (`cn-standard`, `can-standard`, `APPEL_OFFRE`...) and its plain-English name. | | `noticeCategory` | `tender`, `award`, `planning`, `modification` or `other`. | | `procedureType`, `procedureTypeLabel` | Open, restricted, negotiated, competitive dialogue... | | `contractNature` | `works`, `services`, `supplies`, or `mixed`. | | `title`, `titleLanguage` | The title as the buyer wrote it, and its language (ISO 639-1). | | `englishHeadline` | TED only: TED's English headline, "country – what is bought – original title". It translates the country and the subject, not the buyer's own title. | | `description` | Short description in the notice's language, cut at 1,500 characters. | | `buyerName`, `otherBuyers` | The contracting authority (an organisation) and the other authorities of a joint procurement. | | `buyerCountry`, `buyerCountryName`, `buyerCity` | Where the buyer is. | | `cpvCode`, `cpvDescription`, `additionalCpvCodes` | Main CPV code, its English name from the official CPV 2008 list, and the other codes of the notice. | | `estimatedValue`, `estimatedValueCurrency`, `estimatedValueBasis` | The value the buyer states, its currency, and whether it is for the whole procedure, one lot or the sum of the lots. | | `awardedValue`, `awardedValueCurrency` | Award notices: the total awarded. | | `publicationDate`, `dispatchDate` | When the source published the notice; TED also gives when the buyer sent it. | | `deadlineDate`, `deadline`, `deadlineType`, `deadlines` | The deadline to act on: its date (YYYY-MM-DD, same format for both sources, to sort and filter), the deadline with its time and offset when the notice gives them (TED; BOAMP: the date only), and what it is for. `deadlineType` is `tender` (submit offers), `request-to-participate` (apply to take part: the first step of restricted, negotiated, competitive-dialogue and innovation procedures, where offers come later by invitation) or `expression-of-interest`. `deadlines` lists every deadline of the notice as `{ type, deadline }`, earliest first; `deadline` is the latest of them. | | `url` | The official notice. | | `alsoOnTed` | A BOAMP notice that already carries its TED number shows it here. | | `sourceLicense`, `attribution`, `retrievedAt` | The licence, the attribution line to keep, and when the Actor read the notice. | ### How much does it cost? **$1.50 per 1,000 notices** ($0.0015 per delivered notice). One event, **Tender notice**, charged for each notice delivered to the dataset. Everything else is free: notices that do not match your filters, duplicates, notices you already received in feed mode, the silent first run, failed requests. There is no start fee and no fee per search. | You run | Notices delivered | Cost at most | |---|---|---| | A first look at the defaults (25 per source) | ≤ 50 | **$0.075** | | A daily feed of your field, about 30 new notices a day | ~30 a day | **$0.045 a day**, about $1.35 a month | | One country, all tenders of the week | 100–400 | **$0.15–$0.60** | | A backfill of 10,000 award notices | 10,000 | **$15.00** | Your **spending limit** is respected to the notice: the Actor reads how many notices your limit still allows, never delivers more than that, and stops with the reason *budget exhausted* in the `SUMMARY` record. What it did not deliver stays new for the next run in feed mode. If the Actor is started with pay-per-event pricing that does not include the Tender notice event, it refuses to run. ### Limits to know - **TED covers the procurements above the EU thresholds** (and those buyers publish voluntarily). The many national contracts below the thresholds are in each country's own portals, which this Actor does not read. **France is the exception**: BOAMP carries the French contracts below the threshold too, including the *marchés à procédure adaptée* under €90,000. - **Publication delay.** A notice reaches TED some days after the buyer sends it. In a sample of 1,000 notices, the median was 3 days between the buyer's dispatch and TED's publication, 90% within 4 days, the longest 25 days. BOAMP is updated twice a day, seven days a week. For a scheduled feed use a window of 3 days or more: the memory prevents repeats. - **Keywords match the whole notice text**, not only the title, in the notice's own language. TED's full-text operator is used; BOAMP's search covers the title and the whole notice body. A keyword that appears in a side paragraph will match. - **BOAMP data is less uniform than TED's.** BOAMP carries notices in several formats. The Actor reads the CPV code, value, description and city when the notice states them in a structured way: on a sample of 100 recent BOAMP notices of all types, about 88% had a CPV code, 70% a description, 89% a city and 21% a value. The others are `null`. A CPV filter reads every BOAMP notice of the window and keeps those whose codes match, so use a short window with it. - **Many notices state no value**: about 55% of the tender notices in the sample above. Buyers are not obliged to publish it, and some enter a token amount such as `1` instead; it is delivered as published. A value filter drops the notices without a (euro) value unless `includeUnknownValue` is on. - **Restricted and negotiated procedures** publish a deadline to *request to participate*, not to submit offers (those come later, by invitation). That date is the deadline of the record, and `deadlineType` says so. The deadline for clarification questions is not a submission deadline and is not delivered. A buyer's time zone offset is reported as the notice gives it. - **Dates and deadlines are as published.** Corrections and extensions come as new notices (category `other` on BOAMP; TED publishes corrigenda too): check the official notice before you bid. - **Notices published before 2024** may use TED's older format, in which the buyer's own title, the description and the deadline are not available. They are delivered with what they have; the rest is `null`. - **A read stops after 100,000 notices per source**; the `SUMMARY` says so. Narrow the window or the filters to reach the rest. A single BOAMP day above 10,000 notices (it never happens in practice) is read up to the service's limit, and the `SUMMARY` says so. - **Politeness.** One request at a time. TED publishes no rate limit: the Actor spaces its requests by 0.7 seconds, waits for the `Retry-After` delay on a `429`, and retries `5xx` answers and network errors with growing delays. BOAMP's open-data service reports a daily quota of two million calls for the whole dataset; the Actor spaces its calls by 0.3 seconds. ### What it does not do - It does not deliver **contact persons** (names, e-mail, phone) and does not read the winners' names: only the contracting authority and the procurement. A buyer or a title can still contain a person's name when the authority is a sole trader or the title quotes one; you remain responsible for how you use the data. - It does not read the tender documents (specifications, forms) or download attachments. - It does not convert currencies, rank tenders, or tell you whether a tender suits you. - It does not cover other countries' national portals below the EU thresholds, nor non-EU systems such as SAM.gov. ### FAQ **Which data sources does it use, and may I reuse the data commercially?** TED, through the public Search API of the Publications Office of the European Union (no key needed), and BOAMP, through the open-data API of the French *Direction de l'information légale et administrative*. The TED legal notice (read on 19 October 2026) says: *"Unless otherwise noted, the procurement notices published in the Supplement to the Official Journal of the European Union can be freely reused, for commercial or non-commercial purposes."* The BOAMP dataset is published by the French Prime Minister's services on data.gouv.fr under the **Licence Ouverte** (Open Licence), which allows commercial reuse provided the source is named. Each record carries `sourceLicense` and `attribution`: keep them when you pass the data on, and do not suggest that the European Union or the French State endorse your product. The TED logos are not part of the licence and are not used. This is not legal advice. **Is the same tender ever delivered twice?** A notice has one `id` and is delivered once per run. A French tender found on both sources is delivered once, from TED (it is recognised by its procedure identifier, or by the TED number BOAMP shows). In feed mode a notice is not delivered again in a later run. A tender and its later award are two different notices, two phases of one procedure with the same `procedureId`. A corrected notice is a new publication and is delivered as such. **Why did my keyword return nothing from BOAMP?** BOAMP notices are in French: search `logiciel`, not `software`. TED notices are in the buyer's language too, and most buyers write in their own, so list the words in the languages of the countries you target. **Why is the deadline of a French notice only a date?** The open BOAMP data stores the time of day without its time zone, so the Actor gives the date only. The exact hour is in the official notice. **Can I get tenders for one city or region?** There is no city or region filter. The Actor delivers the buyer's city (`buyerCity`) when the notice states it, so you can filter in your own tool after filtering by country and keyword. **What if a source is down?** The Actor retries, then reports the source as failed in the `SUMMARY` and carries on with the other one. If no source answers, the run fails, and nothing is charged for what was not delivered. **What does a run cost me besides the notices?** Nothing: no start fee, no search fee. Platform compute for a run is a fraction of a cent (in a local test a thousand notices took about 7 seconds and under 150 MB). ### Use it from code Replace `YOUR_TOKEN`. The Actor is called `far003/eu-public-tenders`. **JavaScript** ```js import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: 'YOUR_TOKEN' }); const run = await client.actor('far003/eu-public-tenders').call({ keywords: ['software', 'logiciel'], countries: ['FR', 'DE'], noticeTypes: ['tender'], minDaysToDeadline: 14, estimatedValueMin: 100000, onlyNew: true, stateKey: 'client-acme', publishedLastDays: 3, }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); for (const notice of items) console.log(notice.deadline, notice.buyerName, notice.title, notice.url); ``` **Python** ```python from apify_client import ApifyClient client = ApifyClient("YOUR_TOKEN") run = client.actor("far003/eu-public-tenders").call(run_input={ "keywords": ["software", "logiciel"], "countries": ["FR", "DE"], "noticeTypes": ["tender"], "minDaysToDeadline": 14, "estimatedValueMin": 100000, "onlyNew": True, "stateKey": "client-acme", "publishedLastDays": 3, }) for notice in client.dataset(run["defaultDatasetId"]).iterate_items(): print(notice["deadline"], notice["buyerName"], notice["title"], notice["url"]) ``` **Schedule and notify.** In Apify, add a Schedule for the Actor (for example every morning), keep the same *Feed name*, and add a webhook or an integration (Slack, e-mail, Make, Zapier, Google Sheets) on *Run succeeded*: each run delivers only the tenders that appeared since the last one. ### Attribution Tender data: **TED (Tenders Electronic Daily), Publications Office of the European Union, https://ted.europa.eu, © European Union**, reused under Commission Decision 2011/833/EU. French data: **BOAMP, Direction de l'information légale et administrative (Premier ministre), https://www.boamp.fr**, Licence Ouverte / Open Licence. CPV names come from the official CPV 2008 list of the Publications Office of the European Union (9,454 codes, English names, as distributed with its open eForms SDK). This Actor is not affiliated with, or endorsed by, the European Union, the Publications Office, DILA or the French State. # Actor input Schema ## `keywords` (type: `array`): Keep notices that mention at least one of these words or phrases (any of). Both sources match them anywhere in the notice text (TED with its full-text search, BOAMP in the title and the whole body), so use the language of the notices you want: "cybersecurity", "software development" for TED, "logiciel" for the French BOAMP. Quotes, brackets and wildcards are ignored. Empty = no keyword filter. ## `countries` (type: `array`): Only notices published by buyers in these countries. Two-letter or three-letter ISO codes or English names: IT, ITA, Italy, FR, Germany, UK. TED notices are filtered by the buyer's country. BOAMP only covers France, so it is read only when France is on the list (or the list is empty). Empty = all countries. ## `cpvCodes` (type: `array`): Common Procurement Vocabulary codes of the subject: 72000000 (IT services), 45214200 (school building works), 34100000 (motor vehicles). With or without the check digit (72000000-5). A code covers its whole branch: 72000000 also finds 72212000 (software development services), and a short prefix works too: 45 = all construction. A notice matches if any of its lots has one of the codes. BOAMP notices carry a CPV code only in some formats; those without one cannot match a CPV filter. Empty = all subjects. ## `noticeTypes` (type: `array`): Which kinds of notice to return. tender = contract notices and calls for competition (the opportunities to bid on). award = contract award notices (who won, for how much). planning = prior information notices (upcoming tenders). modification = contract modifications. other = corrections, cancellations, qualification systems, voluntary ex-ante and the like. Default: tender. ## `sources` (type: `array`): TED = Tenders Electronic Daily, the EU journal for public procurement above the EU thresholds, all EU countries plus EEA, UK and Switzerland. BOAMP = the French official bulletin, which also carries the smaller French contracts (below 90,000 EUR) that never reach TED. A French tender published on both is delivered once. ## `publishedLastDays` (type: `integer`): Publication window ending today (today counts as day 1): 7 = the last seven days including today. TED publishes on working days only, and a notice appears on TED some days after the buyer sends it, so for a scheduled monitor use 3 or more together with "Only new notices". Ignored for the side of the window you set below. ## `publishedFrom` (type: `string`): First publication date to include, YYYY-MM-DD. Overrides "Published in the last N days" for the start of the window. ## `publishedTo` (type: `string`): Last publication date to include, YYYY-MM-DD. Empty = today. ## `minDaysToDeadline` (type: `integer`): Keep tenders whose deadline is at least this many days from today (0 = not yet expired), so you only get tenders you still have time to answer. The deadline is the one for offers or, in restricted and negotiated procedures, for requests to participate; with several lots or stages the latest counts. Notices with no deadline (awards, planning notices) are left out when this is set. ## `deadlineFrom` (type: `string`): Keep tenders whose deadline (for offers or for requests to participate) is on or after this date, YYYY-MM-DD. If you also set "Deadline at least N days away", the later of the two dates applies. ## `estimatedValueMin` (type: `number`): Keep notices whose estimated value (awarded value for award notices) is at least this amount in euro. Values stated in another currency are not converted: they count as unknown. Many notices state no value at all. ## `estimatedValueMax` (type: `number`): Keep notices whose estimated value is at most this amount in euro. ## `includeUnknownValue` (type: `boolean`): With a value filter on: also deliver the notices that state no value, or one in a currency other than euro. You are charged for them. ## `maxResultsPerSource` (type: `integer`): Deliver at most this many notices from each source (newest first). With two sources the total can be twice this number. This is the main control of what a run can cost. ## `onlyNew` (type: `boolean`): Return only notices you have not received in an earlier run with the same Feed name, and charge only for those. Schedule the Actor and each run gives you just what appeared since the last one. A notice is remembered once delivered; notices left out by "Max notices per source" or by your spending limit stay new for the next run. The first run delivers (and charges) every matching notice, unless you also turn on "Skip existing notices on the first run". ## `baselineOnFirstRun` (type: `boolean`): With "Only new notices" on: the first run for a Feed name only records the notices that match now and delivers nothing (and charges nothing). Later runs deliver only what appeared after that. ## `stateKey` (type: `string`): Name of the memory used by "Only new notices". Use a different name for each independent feed (one per client or per filter set): a new name starts a new feed with its own first run. Letters, digits, \_ and - only. ## Actor input object example ```json { "keywords": [ "cybersecurity" ], "countries": [ "IT", "FR", "DE" ], "cpvCodes": [ "72000000", "45214200" ], "noticeTypes": [ "tender" ], "sources": [ "ted", "boamp" ], "publishedLastDays": 7, "publishedFrom": "2026-10-01", "publishedTo": "2026-10-19", "minDaysToDeadline": 14, "deadlineFrom": "2026-11-15", "includeUnknownValue": false, "maxResultsPerSource": 25, "onlyNew": false, "baselineOnFirstRun": false, "stateKey": "default" } ``` # Actor output Schema ## `notices` (type: `string`): No description ## `summary` (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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "keywords": [ "cybersecurity" ], "noticeTypes": [ "tender" ], "sources": [ "ted", "boamp" ], "maxResultsPerSource": 25 }; // Run the Actor and wait for it to finish const run = await client.actor("far003/eu-public-tenders").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "keywords": ["cybersecurity"], "noticeTypes": ["tender"], "sources": [ "ted", "boamp", ], "maxResultsPerSource": 25, } # Run the Actor and wait for it to finish run = client.actor("far003/eu-public-tenders").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 '{ "keywords": [ "cybersecurity" ], "noticeTypes": [ "tender" ], "sources": [ "ted", "boamp" ], "maxResultsPerSource": 25 }' | apify call far003/eu-public-tenders --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,far003/eu-public-tenders" } } } ``` 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 ` 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/0Iozd8HxfwcQc8AjX/builds/Jq6VZoPTPR0mfwBeb/openapi.json