# Government Tenders Scraper: SAM.gov & EU TED (`carmentara/procurement-radar`) Actor

Get US federal contract opportunities from SAM.gov and EU public tenders from TED in one clean format. Filter by keyword, country, CPV/NAICS code and date. Only new tenders on each run.

- **URL**: https://apify.com/carmentara/procurement-radar.md
- **Developed by:** [Carmentara OU](https://apify.com/carmentara) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 tender notices

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

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

### What does Government Tenders Scraper do?

**Government Tenders Scraper** finds **government tenders** and **RFPs** from **US SAM.gov** (Contract Opportunities) and **EU TED** (Tenders Electronic Daily) and returns them in one clean table. It is a simple way to monitor **public procurement** in the US and Europe: pick keywords, CPV or NAICS codes, countries and dates, and get every matching notice with buyer, deadline, estimated value and a direct link.

- 🇪🇺 **EU TED** works out of the box, no account or key needed
- 🇺🇸 **SAM.gov** works with your own free SAM.gov API key
- 🔎 Filter by **keyword, CPV code (EU), NAICS code (US), country, publication date or deadline, notice type**
- 🆕 **Only new tenders** mode: scheduled runs return only notices you haven't seen yet
- 🧾 One format for both sources, ready for **Excel, CSV, Google Sheets, JSON** or your CRM
- 🔒 Organization-level data only, no personal contact details
- ⚙️ Uses the **official SAM.gov and TED APIs**, not page scraping

### Why use it?

- **Bid and proposal teams**: get a daily list of new opportunities for your CPV/NAICS codes instead of checking two portals by hand.
- **GovCon consultants and agencies**: build tender alerts for several clients from one tool.
- **B2B sales teams**: spot public-sector buyers that are about to purchase what you sell.
- **Market research**: export tender volumes by country, category or buyer.
- **Tender-alert products and AI agents**: feed normalized notices into your own app, Slack channel or AI workflow.

### What data do you get?

Each tender is one row with the same fields, whichever source it comes from:

| Field | What it means | Example |
|---|---|---|
| `source` | Where the notice comes from | `ted` or `sam` |
| `noticeId` | ID of the notice at the source | `da36f7eb-…` |
| `title` | Tender title | France – IT services … |
| `organization` | Buying organization | GIE SESAM-Vitale |
| `country` | Country of the buyer or place of performance | `FRA` |
| `cpvCodes` | EU CPV classification codes (TED) | `["72000000"]` |
| `naicsCodes` | US NAICS codes (SAM.gov) | `["541512"]` |
| `noticeType` | Type of notice | `cn-standard` (contract notice) |
| `publicationDate` | When it was published | 2026-10-02 |
| `deadline` | Submission deadline, when given | 2026-11-04 |
| `estimatedValue`, `estimatedCurrency` | Estimated contract value, when given | 3,240,000 EUR |
| `url` | Link to the full notice | ted.europa.eu/… |
| `shortDescription` | Short summary, when given | |

Fields that a notice doesn't publish (for example a deadline or value) are left out of that row.

### How to use Government Tenders Scraper

1. [Create a free Apify account](https://console.apify.com/sign-up) (no credit card needed).
2. Open **Government Tenders Scraper** and click **Try for free**.
3. Choose your **sources**: EU TED, SAM.gov or both. For SAM.gov, paste your SAM.gov API key (see FAQ).
4. Add **keywords** and/or **CPV / NAICS codes**, and optionally **countries** and a **date range**.
5. Set **Max results** and click **Start**.
6. When the run finishes, open the **Output** tab and download the tenders as **Excel, CSV, JSON or HTML**, or send them to Google Sheets.
7. To get alerts, click **Schedule** and run it daily with **Only new since last run** turned on.

#### Ready-made example tasks

Start from a saved setup and adjust it:

- [Track new EU IT and software tenders daily](https://apify.com/carmentara/procurement-radar/examples/eu-it-software-tenders-daily) (TED, CPV 72000000 and 48000000)
- [Find cybersecurity government tenders in the US and EU](https://apify.com/carmentara/procurement-radar/examples/cybersecurity-tenders-us-eu) (TED, plus SAM.gov with your key)

### Input example

EU IT and software tenders published recently, open calls only:

```json
{
  "sources": ["ted"],
  "cpvCodes": ["72000000", "48000000"],
  "noticeTypes": ["cn-standard"],
  "maxResults": 50,
  "onlyNew": true
}
```

For US opportunities add `"sam"` to `sources`, your `samApiKey`, and NAICS codes such as `["541511", "541512", "541519"]`.

### Output example

Real rows from a test run on 2026-10-03 (trimmed):

```json
[
  {
    "source": "ted",
    "noticeId": "da36f7eb-639c-4eec-9310-a2bb86852ffe",
    "title": "France – IT services: consulting, software development, Internet and support – Assistance technique sécurité",
    "organization": "GIE SESAM-Vitale",
    "country": "FRA",
    "cpvCodes": ["72000000"],
    "noticeType": "cn-standard",
    "publicationDate": "2026-10-02T10:00:00.000Z",
    "estimatedValue": 3240000,
    "estimatedCurrency": "EUR",
    "url": "https://ted.europa.eu/en/notice/-/detail/678030-2026"
  },
  {
    "source": "ted",
    "noticeId": "fb28421e-ca5d-4586-897f-3de6964719e4",
    "title": "Italy – Security software package – Cybersecurity - soluzioni e servizi per la protezione e resilienza di reti e sistemi informativi (ID 2733)",
    "organization": "CONSIP SPA",
    "country": "ITA",
    "cpvCodes": ["48730000", "30200000"],
    "noticeType": "cn-standard",
    "publicationDate": "2026-10-01T10:00:00.000Z",
    "deadline": "2026-11-04T10:00:00.000Z",
    "url": "https://ted.europa.eu/en/notice/-/detail/674254-2026"
  }
]
```

### How much does it cost?

You pay only for the tenders you get. There is no monthly fee and platform usage is not charged separately.

| What | Price |
|---|---|
| One tender notice | $0.003 |
| **1,000 tenders** | **$3** |
| Run start | $0.00005 per run (at the default 512 MB) |

Examples: a daily alert that returns 20 new tenders costs about **$0.06 a day (about $1.80 a month)**. Apify's free plan includes $5 of monthly credit, which covers roughly **1,600 tenders**. Use **Max results** to cap what a single run can cost.

### Integrations

- **Schedules**: run daily or hourly and get only new tenders.
- **API**: start runs and download results from your own code via the [Apify API](https://docs.apify.com/api/v2) (code samples are on the API tab).
- **Zapier, Make, n8n**: send new tenders to email, Slack, Google Sheets, Airtable or your CRM.
- **Webhooks**: trigger your own workflow when a run finishes.
- **AI agents (MCP)**: connect via the [Apify MCP server](https://mcp.apify.com) so Claude, ChatGPT or Cursor can search tenders for you.

### Tips and limits

- **SAM.gov needs your own API key.** Personal keys have a small daily request quota, so keep the number of keywords × NAICS codes small.
- On SAM.gov, keywords match the **title** of the opportunity.
- **CPV codes apply to TED and NAICS codes to SAM.gov.** You can use both in one run.
- By default, closed tenders (deadline passed) and award notices are left out. Turn on **Include closed (past deadline) notices** or **Include award/result notices** to get them.
- **Only new since last run** remembers what you've already received. Turn it off to get the full result list again.
- If one source is temporarily unavailable, the run still returns results from the other source and notes the error in the log.

### FAQ

**Is it legal to collect this data?**
The tool reads official public APIs from SAM.gov and the EU Publications Office (TED). Both publish procurement notices so the public can find and bid on them. Only organization-level data is returned and personal contact details are removed. You are responsible for how you use the data. If you are unsure, check with a legal advisor.

**Do I need a SAM.gov API key?**
Only for US tenders. EU TED works without one. Get a free key by signing in at [SAM.gov](https://sam.gov) and requesting a public API key under your account details, then paste it into the **SAM.gov API key** field. The key is stored as a secret input.

**Which countries are covered?**
The US federal government through SAM.gov, and the EU/EEA plus other countries that publish on TED.

**How fresh is the data?**
Each run queries the sources live. TED publishes new notices on working days and SAM.gov updates continuously.

**Can I get tenders as alerts?**
Yes. Schedule the Actor daily with **Only new since last run** on, and connect it to email, Slack or Google Sheets via Zapier, Make or webhooks.

**Can I search by keyword in another language?**
Yes for TED, which matches keywords in the notice title and description. Many EU notices are published in the buyer's language, so adding local-language keywords finds more results.

### Support

Found a bug or need a field or source we don't cover yet? Open an issue on the **Issues** tab of this Actor and we'll get back to you.

# Actor input Schema

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

Data sources to query

## `includeClosed` (type: `boolean`):

When false (default), exclude notices whose deadline has passed.

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

Keywords to match in title/description

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

List of CPV codes to filter by (TED only), e.g. 72000000

## `naicsCodes` (type: `array`):

List of NAICS codes to filter by (SAM only), e.g. 541511

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

ISO country codes (e.g. US, DE). For TED, buyer or contract location; for SAM, place of performance.

## `dateFilter` (type: `string`):

Which date field to constrain by (publication or deadline).

## `dateFrom` (type: `string`):

Start date inclusive, e.g. 2026-01-01 or 2026-01-01T00:00:00Z

## `dateTo` (type: `string`):

End date inclusive, e.g. 2026-12-31 or 2026-12-31T23:59:59Z

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

Filter by source-specific notice types (e.g., Contract notice, Prior information notice, Sources Sought, Presolicitation). Leave empty for all.

## `includeAwardResults` (type: `boolean`):

When false (default), exclude award/result notices (e.g., can-standard) from open-tender results.

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

Stop after emitting this many results total across sources (0 means no cap).

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

Emit only new notices since the last successful run (per-source dedupe using KV store).

## `includeRaw` (type: `boolean`):

Include a `raw` field with the source payload. GDPR-safe fields only are normalized; raw may contain PII which is stripped before output.

## `samApiKey` (type: `string`):

Your SAM.gov Opportunities API key. Required when querying SAM.gov.

## Actor input object example

```json
{
  "sources": [
    "ted"
  ],
  "keywords": [
    "software"
  ],
  "cpvCodes": [],
  "naicsCodes": [],
  "countries": [],
  "dateFilter": "publicationDate",
  "noticeTypes": [],
  "maxResults": 20,
  "onlyNew": true
}
```

# Actor output Schema

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

Normalized procurement notices. Open the table view for a quick overview.

# 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"
    ],
    "includeClosed": false,
    "keywords": [
        "software"
    ],
    "cpvCodes": [],
    "naicsCodes": [],
    "countries": [],
    "dateFilter": "publicationDate",
    "noticeTypes": [],
    "includeAwardResults": false,
    "maxResults": 20,
    "onlyNew": true,
    "includeRaw": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("carmentara/procurement-radar").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"],
    "includeClosed": False,
    "keywords": ["software"],
    "cpvCodes": [],
    "naicsCodes": [],
    "countries": [],
    "dateFilter": "publicationDate",
    "noticeTypes": [],
    "includeAwardResults": False,
    "maxResults": 20,
    "onlyNew": True,
    "includeRaw": False,
}

# Run the Actor and wait for it to finish
run = client.actor("carmentara/procurement-radar").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"
  ],
  "includeClosed": false,
  "keywords": [
    "software"
  ],
  "cpvCodes": [],
  "naicsCodes": [],
  "countries": [],
  "dateFilter": "publicationDate",
  "noticeTypes": [],
  "includeAwardResults": false,
  "maxResults": 20,
  "onlyNew": true,
  "includeRaw": false
}' |
apify call carmentara/procurement-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,carmentara/procurement-radar"
        }
    }
}
```

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/pzk2egg6t6xxKyOGP/builds/3WRX2GOVjLUqF36L3/openapi.json