# Italy Automotive Tenders Monitor (`revenuepilot/italy-automotive-tenders-monitor`) Actor

Daily-ready feed of Italian public tenders for vehicles, parts and fleet services from the official EU TED API.

- **URL**: https://apify.com/revenuepilot/italy-automotive-tenders-monitor.md
- **Developed by:** [chatbot chatbot](https://apify.com/revenuepilot) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

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

## Italy Automotive Tenders Monitor

Get a clean, structured feed of **Italian public tenders for vehicles, vehicle
parts, repairs and fleet insurance**, straight from the official EU TED
(Tenders Electronic Daily) Search API. No API key, no scraping, no proxies.

Run it daily or weekly and get one dataset row per tender notice: publication
number, date, title, buyer, CPV codes, estimated value, submission deadline and
a link to the notice on ted.europa.eu.

### Use case

A bus manufacturer's bid team schedules this Actor every morning with `daysBack: 1` and
`keywords: ["autobus"]`, then sends new Italian tenders to Slack or Google Sheets before
competitors see them.

### Who is it for?

- Vehicle, bus, truck and special-vehicle dealers and manufacturers looking for Italian bids.
- Spare-parts distributors, workshops and fleet-maintenance companies.
- Insurance brokers following public fleet-insurance tenders (CPV 66514110).
- Bid consultants and lead-generation teams who need a daily list of new opportunities.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `cpvCodes` | string\[] | 34300000, 34320000, 34330000, 34350000, 34100000, 34110000, 34144000, 50110000, 66514110 | 8-digit CPV codes. A notice matches if any of its lots uses one of them. |
| `daysBack` | integer | 7 | Notices published in the last N days (1-365). |
| `keywords` | string\[] | empty | Optional case-insensitive filter on the title (any keyword matches), e.g. `autocarro`, `ambulanza`, `noleggio`. |
| `maxItems` | integer | 100 | Maximum notices returned (1-5000). |

Example:

```json
{
  "cpvCodes": ["34300000", "34100000", "50110000"],
  "daysBack": 7,
  "keywords": ["autocarro", "ambulanza"],
  "maxItems": 100
}
```

### Output

One item per notice, newest first. Example (real result from the TED API, 21 October 2026):

```json
{
  "publicationNumber": "729505-2026",
  "publicationDate": "2026-10-21",
  "title": "Appalto 39/2026 - Acquisto di furgoni allestiti occorrenti all'unità NU.I.R. del Comune di Milano",
  "buyerName": "Comune di Milano",
  "cpvCodes": ["34130000"],
  "estimatedValue": 648000,
  "currency": "EUR",
  "deadline": "2026-11-23",
  "noticeType": "cn-standard",
  "url": "https://ted.europa.eu/en/notice/-/detail/729505-2026"
}
```

More examples are in `sample-output.json`.

| Field | Meaning |
|---|---|
| `publicationNumber` | TED notice number. |
| `publicationDate` | Publication date (YYYY-MM-DD). |
| `title` | Procedure title, Italian when available, otherwise English or the first available language. |
| `buyerName` | Contracting authority, Italian name when available. |
| `cpvCodes` | All CPV codes found in the notice (not only the ones you searched). |
| `estimatedValue`, `currency` | Sum of the lots' estimated values when published, otherwise `null`. |
| `deadline` | Earliest tender submission deadline (date only), `null` when the notice has none (e.g. contract award notices). |
| `noticeType` | TED notice type, e.g. `cn-standard` (contract notice), `can-standard` (award notice). |
| `url` | Link to the notice on TED. |

### How it works

The Actor sends sequential requests to `POST https://api.ted.europa.eu/v3/notices/search`
with an expert query (`buyer-country=ITA AND classification-cpv IN (...) AND publication-date>=...`),
paginates in pages of 100, and retries with exponential backoff on HTTP 429
and 5xx errors and on network timeouts.

### Run locally (without Apify)

```text
pip install httpx
python -m src --input input.example.json --output results.json
python -m unittest discover -s tests -v
```

### Pricing

Pay per event: **$0.0015 per notice returned** (about $1.50 per 1,000 notices) plus a
tiny actor-start fee. Typical runs return 20-100 notices, i.e. a few cents. No monthly
rental. Set a maximum cost per run in Apify to cap spending.

### Limitations

- Only notices published on TED. Italian tenders below the EU thresholds are
  often published only on national platforms (ANAC / BDNCP) and will not appear.
- TED publishes notices a few days after submission; very recent tenders may be missing.
- `estimatedValue` is the sum of published lot values: it may be missing, and for
  framework agreements with overlapping lots it can overstate the real total.
- `deadline` is the earliest lot deadline, date only, and is empty for award notices.
- The keyword filter looks at the title only and is applied after the CPV search.
- `cpvCodes` matching is on the lot-level CPV classification; a notice can carry
  additional unrelated CPV codes.
- Not legal or bidding advice. Always verify the details on the official notice.

### AI transparency and data source

Built with AI assistance; data comes from the official TED API, reuse subject to
EU open data terms. This Actor is not affiliated with or endorsed by the
European Union or the Publications Office of the EU. The Actor does not use a
generative AI model at runtime: it only queries, parses and formats TED data.

### Search terms

Italian public tenders, appalti pubblici, gare d'appalto veicoli, TED tenders Italy, CPV 34 vehicles, bus and truck tenders, fleet insurance tenders, bid monitoring.

# Actor input Schema

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

8-digit CPV codes (Common Procurement Vocabulary). A notice matches if any of its lots uses one of these codes. Default list covers vehicles, vehicle parts, motor vehicle repair and vehicle insurance.

## `daysBack` (type: `integer`):

Only notices published within the last N days (including today).

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

Case-insensitive. Only notices whose title contains at least one keyword are returned (for example: autocarro, ambulanza, noleggio). Leave empty for no filter.

## `maxItems` (type: `integer`):

Upper limit on returned notices (and on charged results).

## Actor input object example

```json
{
  "cpvCodes": [
    "34300000",
    "34320000",
    "34330000",
    "34350000",
    "34100000",
    "34110000",
    "34144000",
    "50110000",
    "66514110"
  ],
  "daysBack": 7,
  "keywords": [],
  "maxItems": 100
}
```

# Actor output Schema

## `dataset` (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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("revenuepilot/italy-automotive-tenders-monitor").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("revenuepilot/italy-automotive-tenders-monitor").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 '{}' |
apify call revenuepilot/italy-automotive-tenders-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,revenuepilot/italy-automotive-tenders-monitor"
        }
    }
}
```

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/65wx9bIMwemiW4hZK/builds/FZIpy3JBmf4eQTNv3/openapi.json