# Public Tenders API — TED, Find a Tender & Contracts Finder (`insight.solutions/public-tenders-api`) Actor

EU and UK public tenders in one dataset: TED notices from across the EU/EEA, UK Find a Tender and Contracts Finder. Filter by keyword, CPV code, country, stage, dates, deadline, value and buyer. Deadlines, values, winners and links on one row. No API key.

- **URL**: https://apify.com/insight.solutions/public-tenders-api.md
- **Developed by:** [Insight Solutions](https://apify.com/insight.solutions) (community)
- **Categories:** Business, Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.36 / 1,000 procurement 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 API — TED, Find a Tender & Contracts Finder

Public-procurement notices from three official journals in **one dataset
schema**, with no API key:

| Source | What it covers | Key needed |
|---|---|---|
| **TED** — Tenders Electronic Daily (`ted`) | Every notice above the EU procurement thresholds, from all EU and EEA countries: calls for competition, prior-information notices, contract awards and modifications | None |
| **Find a Tender** (`uk-fts`) | UK notices above the UK thresholds, since the UK left TED at the start of 2021 | None |
| **Contracts Finder** (`uk-cf`) | Lower-value UK public-sector contracts, mostly English buyers | None |

Same columns on every row. `stage`, `buyerName`, `cpvMain`, `deadline`,
`estimatedValue`, `winnerNames` and `url` mean the same thing whether a Slovak
city put an IT tender on TED or an English council put a framework call-off on
Contracts Finder — so "every open IT tender in Europe and the UK this week" is
one query and one table.

No login. No browser. No personal contact data: the UK releases name the
buying officer with an e-mail address and a direct line, and this Actor drops
those contact blocks before anything else is read, never asks TED for its
contact fields, and scrubs any address or number typed into free text.

### At a glance

**Input** — this is the Store prefill; paste it and run:

```json
{ "sources": ["ted", "uk-fts", "uk-cf"], "keywords": [], "cpvCodes": ["72"], "stages": ["tender"],
  "publishedFrom": null, "publishedTo": null, "maxResults": 25, "includeDescriptions": true,
  "language": "eng", "maxConcurrency": 3, "maxRunSecs": 240, "proxyConfiguration": { "useApifyProxy": true } }
```

(`null` dates mean the last seven days; CPV `72` is IT services.)

**Output** — one `notice` row per notice, same columns across all three sources.
The fields you will use most are `source`, `stage`, `title`, `buyerName`,
`buyerCountry`, `cpvMain`, `publishedAt`, `deadline`, `estimatedValue`,
`currency`, `winnerNames`, `awardedValue` and `url` (full list under *Output
reference*). A source that could not be read, found nothing or was skipped comes
back as a free diagnostic row (`ok: false`, `errorType`, `error`) instead of a
charge.

**Price** — $0.60 per 1,000 notices (+ $0.001 per run); diagnostics and empty
runs free; no API key, no browser, limited permissions, works over the Apify MCP
server and with x402.

**From code** — `client.actor("insight.solutions/public-tenders-api").call(run_input={…})`
with `apify-client`, or
`POST https://api.apify.com/v2/acts/insight.solutions~public-tenders-api/run-sync-get-dataset-items`.

***

### What you get

One row per notice. This is a real TED row from the 2026-09-28 capture, trimmed
to the columns that carry something:

```json
{
  "ok": true,
  "rowType": "notice",
  "source": "ted",
  "input": "TED (EU); stages tender; CPV 72; published 2026-09-21..2026-09-28",
  "noticeId": "632847-2026",
  "stage": "tender",
  "noticeType": "cn-standard",
  "formType": "competition",
  "procedureType": "open",
  "title": "Slovakia – IT services: consulting, software development, Internet and support – Rozvoj a prevádzka informačného systému mestskej polície ŽandárIS",
  "buyerName": "Hlavné mesto Slovenskej republiky Bratislava",
  "buyerCountry": "SVK",
  "cpvMain": "72000000",
  "cpvCodes": ["72000000", "72267100", "48810000"],
  "contractNature": "services",
  "placeOfPerformance": ["SK010", "SVK"],
  "performanceCountries": ["SVK"],
  "publishedAt": "2026-09-15",
  "deadline": "2026-10-19",
  "estimatedValue": 378048.78,
  "currency": "EUR",
  "url": "https://ted.europa.eu/en/notice/-/detail/632847-2026",
  "pdfUrl": "https://ted.europa.eu/en/notice/632847-2026/pdf",
  "xmlUrl": "https://ted.europa.eu/en/notice/632847-2026/xml",
  "language": "slk",
  "rank": 4,
  "scrapedAt": "2026-09-28T17:05:12.000Z"
}
```

A UK award fills the award half of the same schema — this is the Home Office row
from the Contracts Finder capture: `stage: "award"`, `buyerName: "Home Office"`,
`winnerNames: ["Encircle Solutions Limited"]`, `winnerSize: "sme"`,
`awardedValue: 232874`, `currency: "GBP"`, `isFramework: true`,
`contractStart: "2026-10-01"`, `contractEnd: "2029-09-30"`, and a `url` on
contractsfinder.service.gov.uk. The release it came from also named the buying
officer with an e-mail address; the row does not.

Three dataset views ship with it: **Notices** (the columns a bid team scans),
**Awards** (who won what, for how much) and **Diagnostics**.

***

### Quick start

Every open IT tender in the EU and the UK published this week:

```json
{ "cpvCodes": ["72"], "stages": ["tender"] }
```

German and Austrian construction tenders over €1m that close in November:

```json
{
  "sources": ["ted"],
  "cpvCodes": ["45"],
  "countries": ["DEU", "AUT"],
  "minValue": 1000000,
  "deadlineFrom": "2026-11-01",
  "deadlineTo": "2026-11-30",
  "maxResults": 0
}
```

Who won UK cyber-security contracts last month:

```json
{
  "sources": ["uk-fts", "uk-cf"],
  "keywords": ["cyber", "security operations"],
  "stages": ["award"],
  "publishedFrom": "2026-08-01",
  "publishedTo": "2026-08-31",
  "maxResults": 500
}
```

***

### Input

| Field | Type | Default | TED | Find a Tender / Contracts Finder |
|---|---|---|---|---|
| `sources` | multi-select | all three | `ted` | `uk-fts`, `uk-cf` |
| `keywords` | string\[] | `[]` | Full-text search, server-side | Matched here against title, description, buyer and CPV labels (the UK APIs have no working keyword filter) |
| `cpvCodes` | string\[] | `[]` | `classification-cpv`, 2–8 digits; `72` covers every `72…` code | Prefix match on the tender and item codes |
| `countries` | string\[] | `[]` | Buyer country, alpha-3 (`DEU`) or alpha-2 (`DE`) | UK only: skipped with a free row when the list leaves out `GBR` |
| `stages` | multi-select | `["tender"]` | `notice-type` (table below) | Release tag; `stages=` sent when exactly one of planning / tender / award is picked |
| `publishedFrom` / `publishedTo` | ISO date | 7 days ago / today | `publication-date` | Find a Tender: **last updated** (its only window); Contracts Finder: published |
| `deadlineFrom` / `deadlineTo` | ISO date | — | Deadline for tenders (`deadline-receipt-tender-date-lot`), server-side; applied on the rows instead if TED ever refuses the clause | Applied on the rows (`tenderPeriod.endDate`) |
| `minValue` / `maxValue` | number | — | Applied on the rows | Applied on the rows |
| `buyerNames` | string\[] | `[]` | `buyer-name`, server-side | Case-insensitive substring of the buyer name |
| `includeDescriptions` | boolean | `true` | Request the procedure and lot descriptions | Keep `tender.description` |
| `language` | string | `eng` | Which of TED's 24 title translations to return | — |
| `maxResults` | integer | `200` | **Per source**; `0` = no cap. Pages of 20, 50 or 100 notices (TED caps fields × page size at 10,000, so 100 is the working maximum) | **Per source**; pages of 100 releases |
| `maxConcurrency` | integer | `3` | Sources in parallel; pages within one source are sequential | same |
| `maxRunSecs` | integer | `240` | Time budget; rows already returned are kept | same |
| `proxyConfiguration` | object | `{"useApifyProxy": true}` | Datacenter; all three also answered unproxied | same |

Values are compared **in the notice's own currency** — there is no currency
conversion, so `minValue: 1000000` means a million euros on a German notice and
a million zloty on a Polish one. A notice that publishes no value is left out
when `minValue` or `maxValue` is set; a notice with no deadline is left out when
a deadline filter is set.

Every filter that runs on the rows runs **before** the row is written, so a
notice it drops is never billed.

***

### Output reference

Every row carries every column, `null` where it does not apply.

**Envelope** — `ok`, `rowType` (`notice` | `diagnostic`), `input`, `source`,
`sourceUrl`, `scrapedAt`, `error`, `errorType`.

**Identity** — `noticeId`, `ocid` (UK), `stage`, `noticeType`, `formType`,
`procedureType`, `title`, `description`.

**Buyer** — `buyerName`, `buyerCountry` (alpha-3), `buyerCity`, `buyerPostcode`,
`buyerType`, `buyerWebsite`, `buyerId`. Organisation-level only.

**What and where** — `cpvMain`, `cpvCodes[]`, `cpvDescription` (UK),
`contractNature` (`services` / `supplies` / `works`), `procurementCategory`
(the source's own word), `placeOfPerformance[]` (NUTS / ITL codes and
countries), `performanceCountries[]`.

**Dates** — `publishedAt` and `dispatchedAt` (the calendar date as published),
`deadline` (an ISO-8601 UTC instant when a time is published, else the date),
`deadlineTime` (the time of day as published, with its offset).

**Money** — `estimatedValue`, `awardedValue`, `currency`. Null when not
published, never zero.

**Award** — `winnerNames[]`, `winnerCountries[]`, `winnerCount`, `winnerSize`.

**Terms** — `isSmeSuitable`, `isFramework`, `electronicSubmission`,
`contractStart`, `contractEnd`, `contractDurationDays`, `lots`, `legalBasis`.

**Links** — `url` (the human notice page), `pdfUrl` and `xmlUrl` (TED),
`documentsUrl`, `submissionUrl`. Only `http(s)` links; a `mailto:` or an e-mail
address typed into a link field is dropped.

**Run context** — `language` (the notice's original language), `matchedKeywords[]`,
`rank` (1-based within its source for this run).

#### Notes on particular columns

- **`title` on TED rows** is TED's own translation into `language` (English by
  default), falling back to English and then to the original. TED publishes every
  title in all 24 EU languages; the original language is in `language`.
- **Multi-lot notices**: `deadline` is the earliest lot deadline still in the
  future (else the latest), `estimatedValue` is the procedure-level value when
  published, else the sum of the lot values when they share one currency, else
  the first lot's; `lots` counts the lot titles.
- **`description`** is clipped to 4,000 characters and any e-mail address or
  phone number in it is replaced by `[email removed]` / `[phone removed]`.
- **`winnerNames`** are organisations. Where a winner trades under a person's
  name, that is the name it registered as a business.

***

### Stages explained

| `stage` | TED `notice-type` codes | UK release tags |
|---|---|---|
| `planning` | `pin-buyer`, `pin-only`, `pin-tran`, `pin-rtl`, `pin-cfc-standard`, `pin-cfc-social` | `planning`, `planningUpdate` |
| `tender` | `cn-standard`, `cn-social`, `cn-desg`, `qu-sy`, `subco` | `tender`, `tenderUpdate`, `tenderAmendment` |
| `award` | `can-standard`, `can-social`, `can-desg`, `can-tran` | `award`, `awardUpdate`, `contract`, `contractUpdate` |
| `modification` | `can-modif` | `contractAmendment` |
| `other` | `corr`, `brin-eeig`, `brin-ecs`, `veat` and any code not listed | anything else |

`noticeType` keeps the source's own code, so nothing is lost by the mapping.

### Which source covers what

- **TED** carries every notice above the EU thresholds from the EU and EEA —
  for supplies and services from the low hundreds of thousands of euros, for
  works from several million. Below the thresholds, national portals publish
  instead, and those are not in this Actor.
- **Find a Tender** is the UK's replacement for TED since 2021: UK notices above
  the UK thresholds. Its API only offers a **last updated** window, so
  `publishedFrom` / `publishedTo` select notices *updated* in that window — a
  notice published last month and amended yesterday comes back.
- **Contracts Finder** carries lower-value UK contracts, mostly from buyers in
  England, and some above-threshold ones too. Expect a few notices to appear in
  both UK sources.

***

### What you are never charged for

- Notices that were read and then excluded by one of your filters. Every filter
  runs **before** the row is written, so it is never billed.
- Every `diagnostic` row — `no-results`, `skipped`, `bad-query`, `bad-request`,
  `rate-limited`, `blocked`, `http`, `timeout`, `deadline`, `budget`, `partial`,
  `upstream-format`, `invalid-input`, `actor-error`.
- A run that returns nothing. A run whose input was usable but produced nothing —
  no match, filters that excluded everything, UK sources skipped by the country
  filter, a source that refused us or was down — finishes **SUCCEEDED with zero
  results**, a status message that says so and points at the diagnostic rows, and
  nothing charged, start fee included. A run finishes **FAILED** only when there
  was nothing usable to attempt (no source selected) or the Actor itself hit an
  error.

### Pricing

| Event | FREE | BRONZE | SILVER | GOLD |
|---|---|---|---|---|
| Run started | $0.001 | $0.001 | $0.001 | $0.001 |
| **Procurement notice** | **$0.0006** | $0.0006 | $0.00048 | $0.00036 |

**$0.60 per 1,000 notices** at the free tier, whichever source they came from.
300 notices from three sources cost 300 × $0.0006 + $0.001 = **$0.181**.

The run honours `ACTOR_MAX_TOTAL_CHARGE_USD`: when the ceiling is reached it
stops fetching, leaves a free `budget` row, keeps everything already delivered
and finishes successfully.

***

### Use it from an AI agent, or from code

One JSON object in, one flat array out. The Actor runs with **limited
permissions**, uses **pay-per-event** pricing and never enters Standby, so it
works over the Apify MCP server and with x402 agentic payments.

```bash
curl -X POST "https://api.apify.com/v2/acts/insight.solutions~public-tenders-api/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"cpvCodes":["72"],"stages":["tender"],"maxResults":50}'
```

```python
## pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("insight.solutions/public-tenders-api").call(run_input={
    "sources": ["ted", "uk-fts", "uk-cf"],
    "cpvCodes": ["72"],
    "stages": ["tender"],
    "deadlineFrom": "2026-10-15",
    "maxResults": 100,
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["rowType"] != "notice":
        continue
    print(row["source"], row["buyerCountry"], row["buyerName"], row["title"],
          row["deadline"], row["estimatedValue"], row["currency"], row["url"], sep=" | ")
```

For a daily feed, schedule the run with the default seven-day window and
de-duplicate on `source` + `noticeId`.

***

### FAQ

**Do I need a TED or UK API key?**
No. All three search APIs are public and keyless, and this Actor asks you for no
key of any kind.

**Why are there no contact names, e-mails or phone numbers?**
By design. Buyers are organisations, and the rows describe organisations. The UK
releases name the procurement officer with an e-mail address and a direct line,
and TED notices can carry contact persons; this Actor never requests the TED
contact, person or e-mail fields, removes every UK `contactPoint` before
anything else is read, and scrubs addresses and numbers out of free text. The
notice page in `url` is where a bidder finds the official channel for
clarification questions.

**Why are the TED titles in English?**
TED publishes every notice title machine-translated into all 24 EU languages.
This Actor returns the one you pick in `language` (English by default); the
language the buyer actually wrote in is in the `language` column, and the
buyer's name is always as published.

**Why is `awardedValue` empty on some TED award notices?**
TED fills a value the buyer did not disclose with `-1`. No contract is worth
less than nothing, so any negative amount comes back as `null` rather than as a
number to sort on. Likewise a placeholder name such as `"."` is skipped in
favour of the next real one.

**Are values converted to one currency?**
No. `estimatedValue` and `awardedValue` are in the notice's own `currency`.
A value filter compares numbers in that currency, too.

**Why do some UK notices appear twice?**
Some buyers publish the same procurement on both Find a Tender and Contracts
Finder, and the two services number it differently. Within one service the
`ocid` column ties every release of one procurement together; across the two,
match on `buyerName` and `title`.

**Why did my Find a Tender search return an old notice?**
Its API filters on *last updated*, not on publication. A notice amended inside
your window comes back as its latest release, and `publishedAt` is that
release's date.

**What happens when a source is down?**
That source leaves a free diagnostic row saying so and the others keep going.
If none produced a row, the run still finishes SUCCEEDED with zero results, a
"0 results" status message pointing at the diagnostic rows, and nothing charged.

***

### Limitations

- **Above-threshold EU notices only.** National below-threshold portals are not
  in this version.
- **Keyword, CPV, buyer, deadline and value filters on the UK sources run on the
  rows**, because those APIs have no working filter for them. It is correct and
  free to you, but a narrow filter over a wide window reads many pages to find a
  few matches; raise `maxRunSecs` for large windows.
- **TED pages hold at most 100 notices here.** TED's own limit is 250 (a request
  for 251 is refused with `SEARCH_EXCEEDS_MAX_LIMIT`), but it also caps
  *fields × page size* at 10,000, and this Actor asks for 71–73 fields per
  notice, so 100 is the largest page it can use. It steps down on its own if
  TED ever lowers either ceiling.
- **TED field shapes change with eForms versions.** Every field this Actor reads
  was checked against a capture of 120 TED notices carrying all of them —
  tenders, awards and prior-information notices — but every field is still read
  as optional, and one TED no longer recognises becomes a free `upstream-format`
  row naming it rather than a wrong value. A column can go null when TED changes
  what it publishes.
- **The upstream format may change.** These are three independently operated
  government APIs; a shape this Actor does not recognise becomes a free
  diagnostic row, not a charge.
- **No currency conversion**, and no de-duplication across sources.

***

### Sources, terms and attribution

- **TED.** Notices are published by the Publications Office of the European
  Union on Tenders Electronic Daily; reuse is authorised under the European
  Commission's reuse policy, with the source acknowledged.
- **Find a Tender** and **Contracts Finder.** Contains public sector information
  licensed under the Open Government Licence v3.0.

This Actor is independent. It is not affiliated with, endorsed by or sponsored by
the Publications Office of the European Union, the European Commission, the UK
Cabinet Office or the Crown Commercial Service. Nothing here is legal advice, and
you are responsible for using the data lawfully.

### Our other Actors

Every Insight Solutions Actor is pay-per-result with no browser, no login and no API key, and every one of them returns free diagnostic rows instead of billing for failures. Prices are per 1,000 results.

**Video, audio & social**

- [YouTube Transcript API](https://apify.com/insight.solutions/youtube-transcript-api) — captions as timed segments, text, SRT or VTT, with language fallback and translation.
- [YouTube Comments API](https://apify.com/insight.solutions/youtube-comments-api) — comments and replies with likes, pinned and hearted flags, newest or top sort.
- [YouTube Channel API](https://apify.com/insight.solutions/youtube-channel-api) — a channel's videos, Shorts and live streams, plus YouTube search.
- [Podcast Search, Episodes & Charts API](https://apify.com/insight.solutions/podcast-api) — Apple Podcasts search, charts and full episode feeds.
- [Bluesky Scraper](https://apify.com/insight.solutions/bluesky-scraper) — profiles, posts, followers and follows from the public AT Protocol API.
- [Telegram Channel Scraper](https://apify.com/insight.solutions/telegram-channel-scraper) — posts, views and channel stats from public Telegram channels.
- [Substack Scraper](https://apify.com/insight.solutions/substack-scraper) — posts with full free text, comments and publication profiles.
- [Hacker News API](https://apify.com/insight.solutions/hacker-news-api) — stories, comments, users, front page and a structured "Who is hiring?" parser from the official HN APIs.
- [Discourse Forum API](https://apify.com/insight.solutions/discourse-forum-api) — topics, posts and categories from any Discourse community via its own JSON endpoints, usernames only.

**News, documents & the web**

- [Google News Search, Topics & Real Article URLs](https://apify.com/insight.solutions/google-news-api) — news search and topic feeds with the publisher's real URL decoded.
- [Website to Markdown — Content Extractor for LLMs & RAG](https://apify.com/insight.solutions/website-content-extractor) — any site as clean Markdown, text and heading-aware chunks.
- [Internet Archive API](https://apify.com/insight.solutions/internet-archive-api) — archive.org search, item metadata, files and reviews.
- [Wayback Machine Toolkit](https://apify.com/insight.solutions/wayback-toolkit) — archived URL inventories, snapshots and text diffs between dates.
- [Website Technology Detector](https://apify.com/insight.solutions/website-tech-detector) — the tech stack behind any site, with the evidence for each detection.
- [Domain Intelligence API](https://apify.com/insight.solutions/domain-intelligence-api) — DNS, RDAP registration, TLS certificate and HTTP facts in one row per domain.
- [SEO Page Audit](https://apify.com/insight.solutions/seo-page-audit) — sitemap crawl with on-page checks, structured data and broken-link reports.
- [Keyword Suggestions API](https://apify.com/insight.solutions/keyword-suggestions-api) — Google, YouTube, Bing, Amazon and eBay autocomplete with alphabet and question expansions.
- [Website Contact Extractor](https://apify.com/insight.solutions/website-contact-extractor) — emails, phone numbers and social profiles from any list of websites.
- [Web Search Results API](https://apify.com/insight.solutions/web-search-api) — Bing and DuckDuckGo organic results with snippets, no key, no browser.
- [Company Enrichment API](https://apify.com/insight.solutions/company-enrichment-api) — a domain in, a company profile out: firmographics, contacts, tech stack, DNS and hiring signal.
- [Company Dossier API](https://apify.com/insight.solutions/company-dossier-api) — one company in, twelve sections out: profile, tech, contacts, DNS, open roles, news, SEC filings, federal awards, recalls, YC batch and apps.
- [Press Releases API](https://apify.com/insight.solutions/press-releases-api) — GlobeNewswire and PR Newswire releases plus any newsroom feed, by keyword, company, ticker or subject.
- [Federal Register API](https://apify.com/insight.solutions/federal-register-api) — rules, proposed rules, notices and the Public Inspection desk with dockets, comment deadlines and CFR references.
- [Academic Papers Search API](https://apify.com/insight.solutions/academic-papers-api) — OpenAlex, Crossref, arXiv and PubMed in one row per paper: abstract, citations, open-access PDF, authors and venue.
- [RSS & Atom Feed Monitor](https://apify.com/insight.solutions/rss-feed-monitor) — any RSS, Atom or JSON feed (or an OPML file) in, only the new items out, with keyword filters and a webhook.
- [Website Change Monitor](https://apify.com/insight.solutions/website-change-monitor) — watch any pages, diff the text between runs, get change rows with added/removed lines, keyword alerts and a webhook.
- [Wikipedia & Wikidata API](https://apify.com/insight.solutions/wikipedia-api) — article text, search, daily pageviews and Wikidata entity facts, any language edition.

**Business, finance & jobs**

- [Congress & Insider Trades API](https://apify.com/insight.solutions/congress-insider-trades-api) — STOCK Act periodic transaction reports and SEC Form 4 insider trades in one schema.
- [Federal Contracts, Grants & Lobbying API](https://apify.com/insight.solutions/federal-contracts-grants-api) — SAM.gov opportunities, USAspending awards, Grants.gov notices and Senate lobbying filings in one schema.
- [SEC EDGAR API](https://apify.com/insight.solutions/sec-edgar-api) — filings, XBRL financials and full-text search by ticker or CIK.
- [Clinical Trials & FDA API](https://apify.com/insight.solutions/clinical-trials-fda-api) — ClinicalTrials.gov studies plus openFDA recalls, labels, approvals, 510(k)s and adverse-event reports.
- [Product & Vehicle Recalls API](https://apify.com/insight.solutions/product-recalls-api) — CPSC, NHTSA, FDA and USDA recalls, vehicle complaints and ratings, plus a VIN decoder.
- [Y Combinator Companies, Batches & Founders](https://apify.com/insight.solutions/yc-companies-directory) — the YC directory with founders and social links, filterable by batch, industry and hiring status.
- [Career Site Jobs API](https://apify.com/insight.solutions/ats-jobs-api) — jobs straight from Greenhouse, Lever, Ashby, Workable and 10+ other ATS career sites.
- [New Job Postings Monitor](https://apify.com/insight.solutions/job-postings-monitor) — new, closed and changed postings on the career sites you watch.
- [Hiring Signals API — Open Roles & Hiring Surge by Company](https://apify.com/insight.solutions/hiring-signals-api) — one row per company per run: open roles, what opened and closed, department and seniority breakdowns, and a hiring-surge flag.
- [Remote Jobs API](https://apify.com/insight.solutions/remote-jobs-api) — RemoteOK, Remotive, We Work Remotely, Himalayas, Jobicy and more in one schema, deduplicated.
- [Shopify Products API](https://apify.com/insight.solutions/shopify-products-api) — any Shopify store's catalogue, variants, prices and stock signals.
- [Shopify Store Monitor](https://apify.com/insight.solutions/shopify-store-monitor) — price drops, sales, restocks, sell-outs and new products on any Shopify store, one row per change.
- [Nonprofit & IRS 990 Lookup API](https://apify.com/insight.solutions/nonprofit-990-api) — search US nonprofits and get EIN, NTEE code and multi-year Form 990 financials.
- [OpenStreetMap Places API](https://apify.com/insight.solutions/osm-places-api) — businesses and points of interest by category and area from OpenStreetMap: name, address, coordinates, website, phone, opening hours.

**Apps & games**

- [App Store & Google Play Reviews API](https://apify.com/insight.solutions/app-reviews-api) — reviews from both stores with ratings, versions and developer replies.
- [App Store Top Charts & App Search API](https://apify.com/insight.solutions/app-charts-api) — Apple top charts by country and genre, plus app search and details.
- [App Store Keyword Rank Tracker](https://apify.com/insight.solutions/app-store-keyword-rank-tracker) — where any app ranks for any keyword on the App Store and Google Play, with rank changes and ASO suggestions.
- [Steam Reviews API](https://apify.com/insight.solutions/steam-reviews-api) — Steam reviews with playtime, helpfulness and game details.
- [Steam Game Data API](https://apify.com/insight.solutions/steam-store-stats-api) — prices, tags, review scores, live player counts and top charts.

# Actor input Schema

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

Which official procurement journals to read. `ted` is the EU's Tenders Electronic Daily (every above-threshold notice in the EU/EEA). `uk-fts` is the UK's Find a Tender service (above-threshold UK notices since 2021). `uk-cf` is UK Contracts Finder (lower-value public-sector contracts, mostly England). All three are keyless and produce the same columns.

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

Free text. A notice must match at least one. TED searches the full notice text server-side; the UK services have no working keyword filter, so there the words are matched (case-insensitively) against the title, description, buyer name and CPV descriptions before a row is written — never billed if it does not match.

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

Common Procurement Vocabulary codes, 2 to 8 digits: `72` is IT services, `45` construction, `85` health and social work. A short code covers everything under it on every source (TED walks the CPV hierarchy; the UK rows are matched on the code prefix). A check digit like `72000000-6` is accepted.

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

ISO 3166-1 alpha-3 as TED uses them (`DEU`, `FRA`, `NLD`); alpha-2 (`DE`, `FR`, `EL`, `UK`) is accepted and mapped. Filters TED on the buyer's country. The UK sources only publish UK notices: if this list is set and does not include `GBR`, they are skipped with a free row saying so.

## `stages` (type: `array`):

Which stage of the procurement to return. `planning` prior-information and market-engagement notices, `tender` open calls for competition, `award` contract awards, `modification` changes to let contracts, `other` corrigenda and everything else.

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

ISO date, e.g. `2026-09-01`. Leave empty for 7 days before "Published to". On Find a Tender this is the last-updated date — the only window that API offers.

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

ISO date. Leave empty for today.

## `deadlineFrom` (type: `string`):

Keep only notices whose tender deadline is on or after this ISO date. A notice without a published deadline is left out when this is set.

## `deadlineTo` (type: `string`):

Keep only notices whose tender deadline is on or before this ISO date.

## `minValue` (type: `number`):

Keep only notices worth at least this much, in the notice's own currency (no currency conversion): the estimated value, else the awarded value. A notice publishing neither is left out when this is set.

## `maxValue` (type: `number`):

Keep only notices worth at most this much, in the notice's own currency.

## `buyerNames` (type: `array`):

Contracting-authority names or parts of them, e.g. `Home Office`, `Stadt`. TED matches them server-side; the UK rows are matched as a case-insensitive substring of the buyer name.

## `includeDescriptions` (type: `boolean`):

Return each notice's description (clipped to 4,000 characters). Descriptions are most of a TED response, so turning this off makes TED runs lighter. Keyword matching on the UK sources still reads them either way.

## `language` (type: `string`):

TED publishes every title in all 24 EU languages (machine-translated). Which one to return; falls back to English, then to the notice's own language. The original language is always in the `language` column.

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

How many paid notices each selected source may return. `0` means no cap (bounded by the time budget). A three-source run at the default tops out at 600 notices.

## `maxConcurrency` (type: `integer`):

How many sources are read at once. Pages within one source are always read one after another, with a pause between them.

## `maxRunSecs` (type: `integer`):

Stop fetching after this many seconds and keep everything already returned.

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

All three APIs answered from Apify's datacenter proxy and from no proxy at all in testing, so the cheap datacenter pool is the default and a cleared field still works.

## Actor input object example

```json
{
  "sources": [
    "ted",
    "uk-fts",
    "uk-cf"
  ],
  "keywords": [],
  "cpvCodes": [
    "72"
  ],
  "countries": [],
  "stages": [
    "tender"
  ],
  "publishedFrom": "",
  "publishedTo": "",
  "deadlineFrom": "",
  "deadlineTo": "",
  "buyerNames": [],
  "includeDescriptions": true,
  "language": "eng",
  "maxResults": 25,
  "maxConcurrency": 3,
  "maxRunSecs": 240,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per notice, in one schema across all three sources, plus free diagnostic rows. Delivered as JSON items in the default dataset.

# 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-fts",
        "uk-cf"
    ],
    "keywords": [],
    "cpvCodes": [
        "72"
    ],
    "stages": [
        "tender"
    ],
    "includeDescriptions": true,
    "language": "eng",
    "maxResults": 25,
    "maxConcurrency": 3,
    "maxRunSecs": 240,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("insight.solutions/public-tenders-api").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-fts",
        "uk-cf",
    ],
    "keywords": [],
    "cpvCodes": ["72"],
    "stages": ["tender"],
    "includeDescriptions": True,
    "language": "eng",
    "maxResults": 25,
    "maxConcurrency": 3,
    "maxRunSecs": 240,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("insight.solutions/public-tenders-api").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-fts",
    "uk-cf"
  ],
  "keywords": [],
  "cpvCodes": [
    "72"
  ],
  "stages": [
    "tender"
  ],
  "includeDescriptions": true,
  "language": "eng",
  "maxResults": 25,
  "maxConcurrency": 3,
  "maxRunSecs": 240,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call insight.solutions/public-tenders-api --silent --output-dataset

```

## MCP server setup

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

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/njGp8eNAOgEaiwn3Q/builds/VzZ5PaSJRw8eDh0WX/openapi.json