Dane o przetargach przez API

Każdy przetarg przychodzi w jednym formacie, niezależnie od miejsca publikacji: numer, tytuł, zamawiający wraz z identyfikatorem firmy, CPV, szacunkowa wartość, terminy w strefie czasowej zamawiającego i w UTC, status oraz link do oryginału. Gdy ten sam przetarg znajduje się na kilku platformach, otrzymujesz jeden rekord ze wszystkimi miejscami publikacji.

Źródła

• Prozorro — zamówienia publiczne Ukrainy
• Ukraińskie platformy komercyjne i portale zamówień firm
• Unia Europejska (TED)
• Krajowe systemy zamówień innych państw, m.in. Wielkiej Brytanii
• Organizacje międzynarodowe, m.in. ONZ

Aktualność

Każde źródło jest odpytywane według własnego harmonogramu: najczęstsze co kilka minut, pozostałe od co godzinę do co kilka godzin. Pole updated_at informuje, kiedy rekord zmienił się ostatnio.

Pola przetargu

Każde żądanie zawiera klucz organizacji w nagłówku Authorization: Bearer rdr_live_…. Klucz należy do firmy, a nie do osoby: przekaż go usłudze lub integracji.

1. 1Klucze tworzy właściciel lub administrator firmy w Tender Radar: Ustawienia → «API».
2. 2Pełny klucz pokazujemy jednorazowo, zaraz po utworzeniu. Przechowuj go w menedżerze sekretów lub zmiennej środowiskowej.
3. 3Przechowujemy tylko skrót klucza, więc nie możemy go pokazać ponownie. Zgubiony klucz? Unieważnij go i utwórz nowy.
4. 4Unieważniony klucz przestaje działać natychmiast. Dla każdej integracji utwórz osobny klucz (do 10 aktywnych).

Bazowy adres URL

https://metadani.com/v1/data

Authorization: Bearer rdr_live_…

Otwarte przetargi na roboty dachowe na Ukrainie. Klucz jest odczytywany ze zmiennej środowiskowej 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);

Każda odpowiedź to JSON w UTF-8. Listy przychodzą jako obiekt z polem data. Parametry list można powtarzać lub rozdzielać przecinkami.

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

Jak utrzymywać aktualną kopię: załaduj wszystko raz, a potem pobieraj tylko zmiany.

1. 1Pierwsze ładowanie: GET /v1/data/tenders?limit=500, następnie podążaj za next_cursor, dopóki has_more ma wartość true. Zapisz ostatni next_cursor.
2. 2Co 10 minut: GET /v1/data/tenders?cursor=…&status=any&limit=500, ponownie dopóki has_more. Wykonuj upsert wierszy według id: zmieniony przetarg przychodzi ponownie z nowym stanem, np. closed_by_deadline. Zapisz nowy next_cursor.
3. 3status=any, aby zamknięte i anulowane przetargi również przychodziły jako zmiany. Wiersze, których nigdy nie miałeś i które nie są już otwarte, można pominąć.

Bez luk i duplikatów: zmiana, która jest jeszcze zapisywana, jest wstrzymywana do zatwierdzenia, więc kursor nigdy jej nie przeskakuje. Jeśli żądanie się urwie, powtórz je z tym samym kursorem.

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

Dodaj format=csv, a te same wiersze przyjdą jako CSV: płaskie kolumny, rozdzielone przecinkami, wiersz nagłówka, UTF-8 z BOM (Excel otwiera go bez zmian). Kursor przychodzi w nagłówkach X-Next-Cursor i X-Has-More, więc synchronizacja działa tak samo.

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 żądań na minutę na klucz.
• 100 000 wierszy przetargów dziennie na organizację (doba UTC).
• Do 500 wierszy na stronę.
• Oba limity można podnieść dla Twojej organizacji — napisz do nas.

Nagłówki limitów

Każda odpowiedź zawiera aktualny stan limitów:

Treść błędu jest zawsze taka sama: code dla programów, message i detail dla ludzi. Błąd walidacji (422) ma standardową treść, w której detail wymienia pola.

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

Te same dane o przetargach jako serwer Model Context Protocol (MCP), aby asystent mógł wyszukiwać przetargi i otwierać wybrany w trakcie rozmowy. Jeden punkt końcowy, POST /v1/mcp, JSON-RPC 2.0 przez transport Streamable HTTP. Używa klucza organizacji, tak samo jak REST API — nagłówek Authorization: Bearer rdr_live_… — z tą samą subskrypcją i limitami.

Punkt końcowy

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

Narzędzia

Podłączanie klienta

Dodaj serwer do dowolnego klienta MCP, który pozwala ustawić nagłówek żądania, i przekaż klucz w nagłówku Authorization. Dla klienta czytającego konfigurację JSON nagłówek przenosi most mcp-remote:

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

Klient obsługujący Streamable HTTP bezpośrednio nie potrzebuje mostu: wyślij JSON-RPC 2.0 przez POST na punkt końcowy z nagłówkiem Authorization i Accept: application/json.

Hostowane łączniki webowe wymagające OAuth nie są jeszcze obsługiwane — użyj klienta przyjmującego nagłówek lub napisz do nas.