# LatAm & Global Tender Intelligence - Public Tenders Feed (`stefano_seggio/latam-global-tender-intelligence`) Actor

Public tenders, notices and grants from eight open sources: Santa Fe, Tucuman and Entre Rios (Argentina), Chile Diario Oficial, EU TED, Florida bids, World Bank notices and Regione Lombardia grants. Choose sources per run and receive only new or changed records.

- **URL**: https://apify.com/stefano_seggio/latam-global-tender-intelligence.md
- **Developed by:** [Stefano Seggio](https://apify.com/stefano_seggio) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 tender records

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

## LatAm & Global Tender Intelligence

One Actor, seven open public-procurement sources. Pick the sources for each run and receive only the tenders, notices and grant calls that are **new or changed since your last run**, as clean JSON in the dataset.

Typical users: bid teams and consultants tracking public tenders, grant scouts, procurement analysts and sales teams that sell to governments.

### What is covered

| Source id | What it reads | Scope to know before you rely on it |
|---|---|---|
| `ar_tucuman` | Province of Tucumán (Argentina) public tenders across the upcoming-opening, in-award and awarded registers, with line items, amounts and the tender-document PDF link | Open server-rendered portal. |
| `ar_entrerios` | Province of Entre Ríos (Argentina), Unidad Central de Contrataciones: procedure, object, destination, body and status | The portal publishes **no id and no date per record**. Ids are a hash of the row text, so a silent correction of that text upstream can appear as a new record. There is no date filter. |
| `cl_diario_oficial` | Chile Diario Oficial, electronic edition: laws, decrees, resolutions and notices of **today's** edition, "normas generales" section, with issuing ministry or agency, description and the official PDF link | Only that section is read; the other six sections are held because the site's robots.txt disallows them. |
| `eu_ted` | EU TED contract and award notices (all member states) through the official anonymous TED Search API, filtered by a TED expert-search query (`expertQuery`) | TED documents that its paging gives no consistency guarantee between pages: a notice can be missed or repeated within one run. Repeats are removed; a miss is picked up by the next run. Up to 10,000 notices per run. |
| `us_florida` | State of Florida MyFloridaMarketPlace Vendor Information Portal: state-agency solicitations (ITB, RFP, ITN, RFI and others) | The portal's terms license registered vendors to download content for non-commercial use and do not address automated access. This Actor never registers or logs in and links to attachments instead of downloading them. Whether your downstream use is acceptable is your decision. |
| `world_bank_notices` | World Bank procurement notices (invitations for bids, expressions of interest, general procurement notices, award announcements) from the World Bank's procurement-notices API | ADB and IDB notices are not included. |
| `it_lombardia_grants` | Regione Lombardia regional grants and tenders register ("Anagrafica dei bandi regionali") with a derived UPCOMING / OPEN / CLOSED status | CC BY 4.0, attribution Regione Lombardia, carried in each row's `license` field. The policy-area taxonomy of the earlier Actor is not reproduced. An optional Socrata app token is accepted. |

**Not available (held):** `ar_santafe` (no request from Apify's cloud got an answer: five runs ended `fetch failed` after 53 seconds on 2026-11-03, while the portal answers within a second from Argentina), `ar_cordoba` and `ar_pba` (their portals block non-residential, non-Argentine traffic at the network level, and this Actor does not route around network blocks), `ar_salta` and `ar_mendoza` (held by the Actor publisher's decision), `au_grantconnect` (the host answers HTTP 403 to honestly identified requests and offers no API, CSV or RSS feed for awards), `adb_procurement` (bot-challenge on every path) and `idb_procurement` (robots.txt disallows the programmatic paths). A held source cannot be selected: the input form does not list it, and the platform rejects an API call that names one as invalid input before a run starts, so nothing is charged. Should one ever reach the Actor, the run stops before any request to a source is made and before any record is billed; the platform still charges the start event of a run that has started.

### How to use it

1. Open the **Input** tab and choose one or more `sources`. Start with one. The form is prefilled with a small snapshot (`deltaMode: "all"`, 10 records per source) so that the first run shows data at once; for a scheduled Task set `deltaMode` to `onlyChanged` and raise `maxItemsPerSource`.
2. Run it. The first run of a source treats every record it reads as new (see "Control your spend" below).
3. Put the same input in a **Task** and attach an Apify **Schedule**. Each Task keeps its own delta memory, so later runs deliver only what changed.
4. Read the results from the dataset, the Apify API, or an Apify webhook/integration.

Example input:

```json
{
  "sources": ["ar_tucuman", "us_florida"],
  "sourceOptions": {
    "us_florida": { "includeContactDetails": true }
  },
  "deltaMode": "onlyChanged",
  "maxItemsPerSource": 200,
  "watchlistNames": ["road maintenance"]
}
```

Each source validates its own slice of `sourceOptions` and rejects unknown keys, so a typo fails the run in preflight instead of being ignored.

### Delta modes

| `deltaMode` | Delivers |
|---|---|
| `onlyChanged` (default) | Records seen for the first time, and records whose content changed (for example a status change or an added document) |
| `onlyNew` | Records seen for the first time |
| `all` | Every record, unchanged ones included (tagged `delta_status: "unchanged"`) |

Delta memory is kept per `stateNamespace` (default: one per Task) in a key-value store named `latam-global-tender-intelligence-delta-state` in your account. Give two Tasks that run at the same time different namespaces: a second concurrent run of the same namespace and source is refused. A run that is killed (timeout, abort, out of memory) cannot release its lease, so a restart on the same namespace is refused until 15 minutes after that run's last heartbeat (the refused run still pays the start event); a new namespace would start from an empty memory and deliver, and bill, everything again. To restart a source from scratch, delete its `state.<namespace>.<source>` and `journal.<namespace>.<source>` records.

### Output

Every dataset row carries `engine`, `source`, `record_id`, `delta_status`, `is_new`, `is_watchlist_match`, `matched_watchlist_keyword` and `scraped_at`, plus the fields of the source. A `RUN_SUMMARY` record in the key-value store lists per-source counts, warnings and watchlist accounting.

A run ends `FAILED` when preflight finds a problem (an unknown or held source, a missing credential, an invalid option) before any request, or when every selected source failed and nothing was delivered. If at least one source answered, the run succeeds and the per-source errors stay on `RUN_SUMMARY`: check it in automated pipelines.

### Watchlist

`watchlistNames` is a list of keywords matched case-insensitively as substrings against each record's text (buyer, object, issuing authority and similar). Entries shorter than three characters (letters or digits, not counting punctuation), blank or punctuation-only entries are ignored; with no valid keyword nothing matches. A matching record is flagged `is_watchlist_match` and billed a **Watchlist hit** event on top of its row event. Two hard ceilings apply per run: `maxWatchlistHitsPerRun` (default 200) and `maxWatchlistSpendUsd` (default 50). Use broad keywords with care.

### Pricing

This Actor uses pay-per-event pricing. The **Pricing** tab shows the current price of every event; prices are deliberately not repeated on this page so that it cannot go out of date.

- **Actor start**: charged per GB of memory the run is configured with. This Actor uses 1 GB, so each run starts one start event.
- **One row event per delivered record**, named by source: Tender record (`ar_tucuman`, `ar_entrerios`, `cl_diario_oficial`, `us_florida`); Tender summary record (a `us_florida` row delivered from the listing alone, without a detail page); Procurement notice (`world_bank_notices`); New EU TED notice and Updated EU TED notice (`eu_ted`); New Lombardia grant call and Updated Lombardia grant call (`it_lombardia_grants`).
- **Watchlist hit**: see above.

With `deltaMode: "all"` every delivered record is billed, unchanged ones at the source's "Updated" event (or its only row event). Records that are not delivered are not billed a row event.

#### Control your spend

- The first run of a source delivers up to `maxItemsPerSource` records (default 500, range 1 to 10,000) and bills each one. The Entre Ríos portal alone lists thousands of rows; for a trial set a low value such as 20.
- Use Apify's maximum-cost-per-run setting as an additional ceiling. When the limit is reached the run stops cleanly and `RUN_SUMMARY` says so (`stoppedOnChargeLimit`). The platform refuses a limit below the start event plus the most expensive single event of the Actor and names the minimum in its error.
- Keep `deltaMode` at `onlyChanged` for scheduled runs.

### Reliability notes

Delivery is at-least-once: a progress checkpoint is written every 25 rows and a small journal after every row that was delivered and billed, so after a hard kill at most the one record in flight can be delivered and billed again. A memory record that exists but cannot be read fails its own source instead of being treated as empty.

### Credentials

Only `socrataAppToken` (optional, for `it_lombardia_grants`) is accepted. It is stored encrypted by Apify and never logged.

### Data sources and licences

Records are published by the named public bodies. Lombardia data is under CC BY 4.0 (attribution Regione Lombardia); the EU TED API, the World Bank API and the other portals are used under their publishers' own terms, which you should check for your use case. The Florida portal's terms are summarised in the table above.

### Disclaimer

This Actor reads public portals and reports what they publish. Portals change, lag and sometimes correct or withdraw notices; confirm deadlines and requirements on the official notice before you bid.

### Support

Questions and bug reports: the **Issues** tab of this Actor (https://apify.com/stefano_seggio/latam-global-tender-intelligence/issues/open).

# Actor input Schema

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

Source ids to run in this execution. Held sources are not selectable: au_grantconnect, adb_procurement, idb_procurement, ar_cordoba, ar_salta, ar_mendoza, ar_pba, ar_santafe.

## `sourceOptions` (type: `object`):

Options keyed by source id, e.g. {"us_florida": {"includeContactDetails": true}}. Each source validates its own slice and rejects unknown keys. Put credentials in the secret fields below, not here.

## `deltaMode` (type: `string`):

onlyChanged = new and changed records (default). onlyNew = new records only. all = every record, unchanged ones included.

## `stateNamespace` (type: `string`):

Keeps delta memory separate between Tasks (different watchlists, filters or delta modes would otherwise consume each other's "new" records). Leave empty to use one namespace per Task, or "default" for ad-hoc runs. 1-40 characters: a-z, 0-9, "-".

## `maxItemsPerSource` (type: `integer`):

Upper bound on records taken from each source in one run.

## `watchlistNames` (type: `array`):

Case-insensitive substrings matched against each record's names. Entries shorter than 3 characters, blank or punctuation-only entries are ignored. With no valid keyword nothing matches and the watchlist-hit event is never charged.

## `maxWatchlistHitsPerRun` (type: `integer`):

Hard ceiling on watchlist-hit events charged in one run.

## `maxWatchlistSpendUsd` (type: `number`):

Hard ceiling on USD charged for watchlist-hit in one run.

## `socrataAppToken` (type: `string`):

Bring-your-own credential for it_lombardia_grants. Stored encrypted by Apify and never logged.

## Actor input object example

```json
{
  "sources": [
    "ar_tucuman"
  ],
  "sourceOptions": {},
  "deltaMode": "all",
  "maxItemsPerSource": 10,
  "watchlistNames": [],
  "maxWatchlistHitsPerRun": 200,
  "maxWatchlistSpendUsd": 50
}
```

# Actor output Schema

## `records` (type: `string`):

One dataset row per delivered record: engine, source, record_id, delta_status, is_new, is_watchlist_match, matched_watchlist_keyword and scraped_at, plus the fields of the source.

## `runSummary` (type: `string`):

Per-source counts, warnings and watchlist accounting of this run (the RUN_SUMMARY record of the default key-value store).

# 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": [
        "ar_tucuman"
    ],
    "deltaMode": "all",
    "maxItemsPerSource": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("stefano_seggio/latam-global-tender-intelligence").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": ["ar_tucuman"],
    "deltaMode": "all",
    "maxItemsPerSource": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("stefano_seggio/latam-global-tender-intelligence").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": [
    "ar_tucuman"
  ],
  "deltaMode": "all",
  "maxItemsPerSource": 10
}' |
apify call stefano_seggio/latam-global-tender-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,stefano_seggio/latam-global-tender-intelligence"
        }
    }
}
```

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/P0TcBZFLHpxJdhCRW/builds/Zfhj95YAokWJZ4ZgJ/openapi.json