Les données d'appels d'offres via une API

Chaque appel d'offres arrive dans un seul format, quel que soit l'endroit où il a été publié : numéro, titre, acheteur avec son identifiant d'entreprise, CPV, valeur attendue, échéances dans le fuseau horaire de l'acheteur et en UTC, statut et lien vers l'original. Lorsque le même appel d'offres figure sur plusieurs plateformes, vous obtenez un seul enregistrement listant tous les lieux de publication.

Sources

• Prozorro — les marchés publics d'Ukraine
• Plateformes commerciales ukrainiennes et portails d'achats d'entreprise
• Union européenne (TED)
• Systèmes nationaux de marchés publics d'autres pays, dont le Royaume-Uni
• Organisations internationales, dont l'ONU

Fraîcheur

Chaque source est interrogée selon son propre calendrier : la plus fréquente toutes les quelques minutes, les autres de toutes les heures à toutes les quelques heures. Le champ updated_at indique quand un enregistrement a changé pour la dernière fois.

Champs d'un appel d'offres

Chaque requête porte la clé de l'organisation dans l'en-tête Authorization: Bearer rdr_live_…. Une clé appartient à la société, pas à une personne : donnez-la à un service ou à une intégration.

1. 1Les clés sont créées par le propriétaire ou un administrateur de la société dans Tender Radar : Paramètres → « API ».
2. 2Nous affichons la clé complète une seule fois, juste après sa création. Conservez-la dans un gestionnaire de secrets ou une variable d'environnement.
3. 3Nous ne stockons qu'un hachage de la clé, nous ne pouvons donc pas la réafficher. Clé perdue ? Révoquez-la et créez-en une nouvelle.
4. 4Une clé révoquée cesse aussitôt de fonctionner. Donnez à chaque intégration sa propre clé (jusqu'à 10 actives).

URL de base

https://metadani.com/v1/data

Authorization: Bearer rdr_live_…

Appels d'offres ouverts de toiture en Ukraine. La clé est lue depuis la variable d'environnement 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);

Chaque réponse est du JSON en UTF-8. Les listes arrivent sous forme d'objet avec un champ data. Les paramètres de liste peuvent être répétés ou séparés par des virgules.

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

Comment conserver une copie à jour : tout charger une fois, puis ne récupérer que les changements.

1. 1Premier chargement : GET /v1/data/tenders?limit=500, puis suivez next_cursor tant que has_more vaut true. Enregistrez le dernier next_cursor.
2. 2Toutes les 10 minutes : GET /v1/data/tenders?cursor=…&status=any&limit=500, de nouveau tant que has_more. Faites un upsert des lignes par id : un appel d'offres modifié revient avec son nouvel état, par ex. closed_by_deadline. Enregistrez le nouveau next_cursor.
3. 3status=any pour que les appels d'offres clos et annulés arrivent aussi comme des changements. Les lignes que vous n'avez jamais eues et qui ne sont plus ouvertes peuvent être ignorées.

Ni trous ni doublons : une modification encore en cours d'écriture est retenue jusqu'à sa validation, de sorte que le curseur ne la saute jamais. Si une requête est interrompue, répétez-la avec le même curseur.

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

Ajoutez format=csv et les mêmes lignes arrivent en CSV : colonnes à plat, séparées par des virgules, une ligne d'en-tête, UTF-8 avec BOM (Excel l'ouvre tel quel). Le curseur arrive dans les en-têtes X-Next-Cursor et X-Has-More, la synchronisation fonctionne donc de la même façon.

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 requêtes par minute et par clé.
• 100 000 lignes d'appels d'offres par jour et par organisation (jour UTC).
• Jusqu'à 500 lignes par page.
• Les deux limites peuvent être relevées pour votre organisation — écrivez-nous.

En-têtes de limitation de débit

Chaque réponse porte l'état actuel des limites :

Le corps d'une erreur est toujours le même : code pour les programmes, message et detail pour les humains. Une erreur de validation (422) a le corps standard où detail liste les champs.

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