Dati sulle gare tramite API

Ogni gara arriva in un unico formato ovunque sia stata pubblicata: numero, titolo, ente appaltante con il suo id aziendale, CPV, valore atteso, scadenze nel fuso orario dell'ente e in UTC, stato e un link all'originale. Quando la stessa gara è su più piattaforme ricevi un unico record che elenca ogni luogo di pubblicazione.

Fonti

• Prozorro: gli appalti pubblici dell'Ucraina
• Piattaforme commerciali ucraine e portali di approvvigionamento aziendali
• Unione europea (TED)
• Sistemi nazionali di appalto di altri paesi, tra cui il Regno Unito
• Organizzazioni internazionali, tra cui l'ONU

Aggiornamento

Ogni fonte viene interrogata secondo un proprio calendario: la più frequente ogni pochi minuti, le altre da ogni ora a ogni poche ore. Il campo updated_at indica quando un record è cambiato l'ultima volta.

Campi della gara

Ogni richiesta porta la chiave dell'organizzazione nell'intestazione Authorization: Bearer rdr_live_…. Una chiave appartiene all'azienda, non a una persona: consegnala a un servizio o a un'integrazione.

1. 1Le chiavi vengono create dal titolare o da un amministratore dell'azienda in Tender Radar: Impostazioni → «API».
2. 2Mostriamo la chiave completa una sola volta, subito dopo la creazione. Conservala in un gestore di segreti o in una variabile d'ambiente.
3. 3Conserviamo solo un hash della chiave, quindi non possiamo mostrarla di nuovo. Hai perso una chiave? Revocala e creane una nuova.
4. 4Una chiave revocata smette di funzionare subito. Dai a ogni integrazione una propria chiave (fino a 10 attive).

URL di base

https://metadani.com/v1/data

Authorization: Bearer rdr_live_…

Gare aperte di copertura tetti in Ucraina. La chiave viene letta dalla variabile d'ambiente RADAR_API_KEY.

curl -H "Authorization: Bearer $RADAR_API_KEY" \
  "https://metadani.com/v1/data/tenders?cpv=4526&country=UA&limit=100"

import os
import httpx

API = "https://metadani.com/v1/data"
headers = {"Authorization": f"Bearer {os.environ['RADAR_API_KEY']}"}

r = httpx.get(f"{API}/tenders", params={"cpv": "4526", "country": "UA", "limit": 100}, headers=headers)
r.raise_for_status()
for tender in r.json()["data"]:
    print(tender["number"], tender["title"], tender["submission_deadline"])

const API = "https://metadani.com/v1/data";
const headers = { Authorization: `Bearer ${process.env.RADAR_API_KEY}` };

const params = new URLSearchParams({ cpv: "4526", country: "UA", limit: "100" });
const res = await fetch(`${API}/tenders?${params}`, { headers });
if (!res.ok) throw new Error(`${res.status} ${(await res.json()).code}`);
const { data } = await res.json();
for (const t of data) console.log(t.number, t.title, t.submission_deadline);

Ogni risposta è JSON in UTF-8. Gli elenchi arrivano come un oggetto con un campo data. I parametri di elenco possono essere ripetuti o separati da virgole.

{
  "data": [
    {
      "id": "0d6f4f7e-1c3b-4a51-9b7e-5b9b1f0c2a11",
      "number": "UA-2026-10-11-000337-a",
      "title": "Капітальний ремонт покрівлі",
      "status": "tendering",
      "source": { "code": "prozorro", "name": "Prozorro" },
      "value": { "amount": 1250000.0, "currency": "UAH", "vat_included": true },
      "submission_deadline": { "local": "2026-10-21T00:00:00+03:00", "utc": "2026-10-20T21:00:00Z" },
      "updated_at": "2026-10-11T19:31:02.123456Z",
      "…": "…"
    }
  ],
  "next_cursor": "eyJ1IjoiMjAyNi0xMC0xMVQxOTozMTowMi4xMjM0NTZaIiwiaSI6IjZmMWMifQ",
  "has_more": true,
  "as_of": "2026-10-11T19:40:00Z"
}

{
  "id": "0d6f4f7e-1c3b-4a51-9b7e-5b9b1f0c2a11",
  "number": "UA-2026-10-11-000337-a",
  "title": "Капітальний ремонт покрівлі",
  "title_translated": null,
  "description": "…",
  "language": "uk",
  "status": "tendering",
  "status_source": "active.tendering",
  "procedure": {
    "code": "aboveThreshold",
    "label": "Відкриті торги з особливостями"
  },
  "buyer": {
    "name": "Київська міська рада",
    "edrpou": "22883141",
    "scheme": "UA-EDR",
    "region": "Київ",
    "locality": "Київ"
  },
  "country": "UA",
  "region": "Київ",
  "source": {
    "code": "prozorro",
    "name": "Prozorro"
  },
  "url": "https://prozorro.gov.ua/tender/UA-2026-10-11-000337-a",
  "also_on": [
    {
      "source": "smarttender",
      "url": "https://smarttender.biz/…"
    }
  ],
  "cpv": {
    "main": {
      "code": "45261000",
      "name": "Покрівельні роботи"
    },
    "extra": [
      {
        "code": "45262000",
        "name": "…"
      }
    ]
  },
  "value": {
    "amount": 1250000,
    "currency": "UAH",
    "vat_included": true
  },
  "time_zone": "Europe/Kyiv",
  "published_at": {
    "local": "2026-10-11T10:15:00+03:00",
    "utc": "2026-10-11T07:15:00Z"
  },
  "submission_start": {
    "local": "2026-10-11T10:15:00+03:00",
    "utc": "2026-10-11T07:15:00Z"
  },
  "enquiry_end": null,
  "submission_deadline": {
    "local": "2026-10-21T00:00:00+03:00",
    "utc": "2026-10-20T21:00:00Z"
  },
  "auction_at": null,
  "lots": [],
  "items": [],
  "documents": [],
  "radar_url": "https://platform.aurum-apps.com/uk/app/tenders/0d6f4f7e-1c3b-4a51-9b7e-5b9b1f0c2a11",
  "first_seen_at": "2026-10-11T07:16:40Z",
  "updated_at": "2026-10-11T19:31:02.123456Z"
}

{
  "data": [
    {
      "code": "prozorro",
      "name": "Prozorro",
      "country": "UA",
      "segment": "ua_public",
      "kind": "api",
      "schedule_minutes": 5,
      "last_success_at": "2026-10-11T19:35:00Z",
      "status": "ok",
      "open_tenders": 18950
    }
  ]
}

{
  "data": [
    {
      "slug": "metinvest",
      "name": "Метінвест",
      "aliases": [
        "Metinvest"
      ],
      "members": [
        {
          "edrpou": "00191000",
          "name": "ПрАТ «ММК ім. Ілліча»"
        }
      ]
    }
  ]
}

{
  "data": [
    {
      "code": "45261000",
      "name": "Покрівельні роботи",
      "names": {
        "uk": "Покрівельні роботи",
        "en": "Roofing works",
        "ru": "Кровельные работы"
      }
    }
  ]
}

{
  "org": "ТОВ «Альфа»",
  "key": {
    "name": "ERP sync",
    "prefix": "rdr_live_ab12cd"
  },
  "limits": {
    "requests_per_minute": 120,
    "rows_per_day": 100000,
    "max_page": 500
  },
  "today": {
    "requests": 14,
    "rows": 1200,
    "rows_remaining": 98800
  },
  "subscription": {
    "status": "active",
    "plan": "api",
    "trial_until": null
  }
}

Come mantenere una copia aggiornata: carica tutto una volta, poi recupera solo le modifiche.

1. 1Primo caricamento: GET /v1/data/tenders?limit=500, poi segui next_cursor finché has_more è true. Salva l'ultimo next_cursor.
2. 2Ogni 10 minuti: GET /v1/data/tenders?cursor=…&status=any&limit=500, di nuovo finché has_more. Inserisci o aggiorna le righe per id: una gara che è cambiata arriva di nuovo con il nuovo stato, ad es. closed_by_deadline. Salva il nuovo next_cursor.
3. 3status=any in modo che anche le gare chiuse e annullate arrivino come modifiche. Le righe che non avevi e che non sono più aperte possono essere ignorate.

Nessun buco e nessun duplicato: una modifica ancora in scrittura viene trattenuta finché non è confermata, quindi il cursore non la salta mai. Se una richiesta si interrompe, ripetila con lo stesso cursore.

#!/usr/bin/env bash
# Needs curl and jq. Upsert each line of tenders.jsonl into your database by "id".
API="https://metadani.com/v1/data"
AUTH="Authorization: Bearer $RADAR_API_KEY"

pull() {   # $1 = filters, $2 = cursor to start from; follows next_cursor while has_more is true
  local filters="$1" cursor="$2" page
  while :; do
    page=$(curl -sf -H "$AUTH" "$API/tenders?$filters${cursor:+&cursor=$cursor}") || return 1
    echo "$page" | jq -c '.data[]' >> tenders.jsonl
    cursor=$(echo "$page" | jq -r '.next_cursor')
    echo "$cursor" > cursor.txt
    [ "$(echo "$page" | jq -r '.has_more')" = "true" ] || break
  done
}

if [ ! -s cursor.txt ]; then
  # 1. First full load: open tenders
  pull "limit=500"
else
  # 2. Every 10 minutes (cron: */10 * * * *): everything changed since the saved cursor,
  #    closed and cancelled tenders included
  pull "status=any&limit=500" "$(cat cursor.txt)"
fi

import os
import pathlib
import time

import httpx

API = "https://metadani.com/v1/data"
CURSOR = pathlib.Path("radar_cursor.txt")
client = httpx.Client(headers={"Authorization": f"Bearer {os.environ['RADAR_API_KEY']}"}, timeout=60)


def upsert(tender: dict) -> None:
    """Insert or update the row with id = tender["id"] in your database."""
    ...


def pull(params: dict) -> None:
    """Follows next_cursor while has_more is true and saves the cursor after every page."""
    while True:
        r = client.get(f"{API}/tenders", params=params)
        if r.status_code == 429:  # rate limit: wait as long as the API asks
            time.sleep(int(r.headers.get("Retry-After", "60")))
            continue
        r.raise_for_status()
        page = r.json()
        for tender in page["data"]:
            upsert(tender)
        CURSOR.write_text(page["next_cursor"])
        if not page["has_more"]:
            return
        params = {**params, "cursor": page["next_cursor"]}


# 1. First full load: open tenders
if not CURSOR.exists():
    pull({"limit": 500})

# 2. Every 10 minutes: everything changed since the saved cursor, closed and cancelled included
while True:
    time.sleep(600)
    pull({"cursor": CURSOR.read_text(), "status": "any", "limit": 500})

// Node 18+ (global fetch). Run as an ES module.
import { existsSync, readFileSync, writeFileSync } from "node:fs";

const API = "https://metadani.com/v1/data";
const CURSOR = "radar_cursor.txt";
const headers = { Authorization: `Bearer ${process.env.RADAR_API_KEY}` };
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

async function upsert(tender) {
  // Insert or update the row with id = tender.id in your database.
}

// Follows next_cursor while has_more is true and saves the cursor after every page.
async function pull(params) {
  for (;;) {
    const res = await fetch(`${API}/tenders?${new URLSearchParams(params)}`, { headers });
    if (res.status === 429) {
      await sleep(Number(res.headers.get("Retry-After") ?? 60) * 1000);
      continue;
    }
    if (!res.ok) throw new Error(`${res.status} ${(await res.json()).code}`);
    const page = await res.json();
    for (const tender of page.data) await upsert(tender);
    writeFileSync(CURSOR, page.next_cursor);
    if (!page.has_more) return;
    params = { ...params, cursor: page.next_cursor };
  }
}

// 1. First full load: open tenders
if (!existsSync(CURSOR)) await pull({ limit: "500" });

// 2. Every 10 minutes: everything changed since the saved cursor, closed and cancelled included
for (;;) {
  await sleep(10 * 60 * 1000);
  await pull({ cursor: readFileSync(CURSOR, "utf8"), status: "any", limit: "500" });
}

Aggiungi format=csv e le stesse righe arrivano come CSV: colonne piatte, separate da virgole, una riga di intestazione, UTF-8 con BOM (Excel lo apre così com'è). Il cursore arriva nelle intestazioni X-Next-Cursor e X-Has-More, quindi la sincronizzazione funziona allo stesso modo.

curl -sf -D headers.txt -o tenders.csv \
  -H "Authorization: Bearer $RADAR_API_KEY" \
  "https://metadani.com/v1/data/tenders?cpv=45&country=UA&limit=500&format=csv"

grep -i '^x-next-cursor:' headers.txt   # send it as cursor= for the next page
grep -i '^x-has-more:' headers.txt      # true = fetch the next page right away

import os
import httpx

API = "https://metadani.com/v1/data"
headers = {"Authorization": f"Bearer {os.environ['RADAR_API_KEY']}"}

r = httpx.get(f"{API}/tenders", params={"cpv": "45", "limit": 500, "format": "csv"}, headers=headers)
r.raise_for_status()
with open("tenders.csv", "wb") as f:
    f.write(r.content)  # UTF-8 with BOM: opens in Excel as is
next_cursor = r.headers["X-Next-Cursor"]
has_more = r.headers["X-Has-More"] == "true"

import { writeFileSync } from "node:fs";

const API = "https://metadani.com/v1/data";
const headers = { Authorization: `Bearer ${process.env.RADAR_API_KEY}` };

const res = await fetch(`${API}/tenders?cpv=45&limit=500&format=csv`, { headers });
if (!res.ok) throw new Error(String(res.status));
writeFileSync("tenders.csv", Buffer.from(await res.arrayBuffer())); // UTF-8 with BOM
const nextCursor = res.headers.get("X-Next-Cursor");
const hasMore = res.headers.get("X-Has-More") === "true";

• 120 richieste al minuto per chiave.
• 100.000 righe di gare al giorno per organizzazione (giorno UTC).
• Fino a 500 righe per pagina.
• Entrambi i limiti possono essere aumentati per la tua organizzazione: scrivici.

Intestazioni dei limiti di frequenza

Ogni risposta riporta lo stato attuale dei limiti:

Il corpo dell'errore è sempre lo stesso: code per i programmi, message e detail per le persone. Un errore di validazione (422) ha il corpo standard in cui detail elenca i campi.

{
  "code": "invalid_api_key",
  "message": "Unknown API key",
  "detail": "Check the Authorization header"
}

Gli stessi dati sulle gare come server Model Context Protocol (MCP), così un assistente può cercare gare e aprirne una all'interno di una conversazione. Un unico endpoint, POST /v1/mcp, JSON-RPC 2.0 sul trasporto Streamable HTTP. Usa la chiave dell'organizzazione, come l'API REST (l'intestazione Authorization: Bearer rdr_live_…), con lo stesso abbonamento e gli stessi limiti.

Endpoint

POST https://metadani.com/v1/mcp

Strumenti

Collega un client

Aggiungi il server a qualsiasi client MCP che consenta di impostare un'intestazione di richiesta e passa la tua chiave nell'intestazione Authorization. Per un client che legge una configurazione JSON, il bridge mcp-remote trasporta l'intestazione:

{
  "mcpServers": {
    "metadani-radar": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://metadani.com/v1/mcp",
        "--header",
        "Authorization: Bearer rdr_live_…"
      ]
    }
  }
}

Un client che parla direttamente Streamable HTTP non ha bisogno del bridge: invia JSON-RPC 2.0 con POST all'endpoint con l'intestazione Authorization e Accept: application/json.

I connettori web ospitati che richiedono OAuth non sono ancora supportati: usa un client che accetti un'intestazione, oppure scrivici.