Datele licitațiilor prin API

Fiecare licitație vine într-un singur format, indiferent unde a fost publicată: număr, titlu, autoritatea contractantă cu identificatorul companiei, CPV, valoare estimată, termene în fusul orar al achizitorului și în UTC, stare și un link către original. Când aceeași licitație apare pe mai multe platforme, primiți o singură înregistrare care enumeră toate locurile în care a fost publicată.

Surse

• Prozorro — achizițiile publice din Ucraina
• Platforme comerciale ucrainene și portaluri de achiziții ale companiilor
• Uniunea Europeană (TED)
• Sisteme naționale de achiziții din alte țări, inclusiv Marea Britanie
• Organizații internaționale, inclusiv ONU

Actualitatea datelor

Fiecare sursă este interogată după programul propriu: cea mai frecventă, la câteva minute, celelalte de la o dată pe oră până la o dată la câteva ore. Câmpul updated_at arată când s-a modificat ultima dată o înregistrare.

Câmpurile licitației

Fiecare cerere poartă cheia organizației în antetul Authorization: Bearer rdr_live_…. Cheia aparține companiei, nu unei persoane: atribuiți-o unui serviciu sau unei integrări.

1. 1Cheile sunt create de proprietarul sau administratorul companiei în Tender Radar: Setări → „API”.
2. 2Afișăm cheia completă o singură dată, imediat după creare. Păstrați-o într-un manager de secrete sau într-o variabilă de mediu.
3. 3Stocăm doar un hash al cheii, deci nu o mai putem afișa. Ați pierdut cheia? Revocați-o și creați una nouă.
4. 4O cheie revocată nu mai funcționează imediat. Dați fiecărei integrări propria cheie (până la 10 active).

URL de bază

https://metadani.com/v1/data

Authorization: Bearer rdr_live_…

Licitații deschise pentru lucrări de acoperiș în Ucraina. Cheia este citită din variabila de mediu 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);

Fiecare răspuns este JSON în UTF-8. Listele vin ca un obiect cu câmpul data. Parametrii de tip listă pot fi repetați sau separați prin virgulă.

{
  "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
  }
}

Cum păstrați o copie actualizată: încărcați totul o dată, apoi preluați doar modificările.

1. 1Prima încărcare: GET /v1/data/tenders?limit=500, apoi urmați next_cursor cât timp has_more este true. Salvați ultimul next_cursor.
2. 2La fiecare 10 minute: GET /v1/data/tenders?cursor=…&status=any&limit=500, din nou cât timp has_more. Actualizați rândurile (upsert) după id: o licitație modificată revine cu noua stare, de ex. closed_by_deadline. Salvați noul next_cursor.
3. 3status=any pentru ca și licitațiile închise și anulate să vină ca modificări. Rândurile pe care nu le-ați avut niciodată și care nu mai sunt deschise pot fi omise.

Fără goluri și fără dubluri: o modificare aflată încă în curs de scriere este reținută până la confirmare, astfel încât cursorul nu o sare niciodată. Dacă o cerere se întrerupe, repetați-o cu același cursor.

#!/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" });
}

Adăugați format=csv și aceleași rânduri vin ca CSV: coloane plate, separate prin virgulă, cu rând de antet, UTF-8 cu BOM (Excel îl deschide direct). Cursorul vine în antetele X-Next-Cursor și X-Has-More, deci sincronizarea funcționează la fel.

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 de cereri pe minut pentru fiecare cheie.
• 100.000 de rânduri de licitații pe zi pentru fiecare organizație (zi UTC).
• Până la 500 de rânduri pe pagină.
• Ambele limite pot fi mărite pentru organizația dvs. — scrieți-ne.

Antete pentru limitele de cereri

Fiecare răspuns conține starea curentă a limitelor:

Corpul erorii este întotdeauna același: code pentru programe, message și detail pentru oameni. O eroare de validare (422) are corpul standard, în care detail enumeră câmpurile.

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

Aceleași date despre licitații, ca server Model Context Protocol (MCP), astfel încât un asistent să poată căuta licitații și să deschidă una în timpul unei conversații. Un singur endpoint, POST /v1/mcp, JSON-RPC 2.0 peste transportul Streamable HTTP. Folosește cheia organizației, la fel ca API-ul REST — antetul Authorization: Bearer rdr_live_… — cu același abonament și aceleași limite.

Endpoint

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

Instrumente

Conectați un client

Adăugați serverul în orice client MCP care permite setarea unui antet de cerere și transmiteți cheia în antetul Authorization. Pentru un client care citește o configurație JSON, antetul este transmis de puntea mcp-remote:

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

Un client care vorbește direct Streamable HTTP nu are nevoie de punte: trimiteți JSON-RPC 2.0 prin POST la endpoint, cu antetul Authorization și Accept: application/json.

Conectorii web găzduiți care necesită OAuth nu sunt încă acceptați — folosiți un client care primește un antet sau scrieți-ne.