API turf.bzh - documentation

Deux conditions, vérifiées à chaque requête :

• La Licence API (paiement unique, à vie) : api-licence.php
• Un abonnement turf.bzh actif. En cas de résiliation, l'API est suspendue ; elle se réactive seule au réabonnement, sans re-payer.

URL de base : https://www.turf.bzh/api/v1/ - HTTPS uniquement. Les réponses ne sont jamais mises en cache (Cache-Control: no-store) : ce que vous recevez est frais.

Une clé, deux usages. La même clé couvre les endpoints DONNÉES (programme, partants, cotes en direct, arrivées, base historique - illimités) et les endpoints CHATBZH (question à l'agent, méthodes), qui consomment vos crédits IA comme sur le site.

Générez votre clé personnelle sur Ma clé API (affichée une seule fois). Envoyez-la à chaque requête, de préférence en en-tête :

Authorization: Bearer tbz_live_VOTRE_CLE

Alternatives tolérées : l'en-tête X-Api-Key: tbz_live_..., ou le paramètre ?api_key=tbz_live_... pour les outils qui ne savent pas poser d'en-tête (Google Sheets, tableurs, liens de test). Attention avec le paramètre d'URL : la clé peut traîner dans des historiques. En cas de doute, régénérez-la (l'ancienne meurt immédiatement).

La clé est personnelle : pas de partage, pas d'usage mutualisé. Chaque clé est auditée.

curl - le programme du jour

curl -H "Authorization: Bearer tbz_live_VOTRE_CLE" \
  "https://www.turf.bzh/api/v1/programme"

Python - cotes live d'une course, toutes les 60 secondes

import requests, time

KEY = "tbz_live_VOTRE_CLE"
URL = "https://www.turf.bzh/api/v1/courses/2026-09-16/R1C4/cotes"

while True:
    r = requests.get(URL, headers={"Authorization": f"Bearer {KEY}"}, timeout=15)
    j = r.json()
    if "error" in j:
        print("Erreur:", j["error"]["message"])
        break
    for p in j["data"]["partants"]:
        print(p["num"], p["cheval"], p["cote"])
    time.sleep(60)  # restez au-dessus de 30 s : les cotes sont cachées côté serveur

Google Sheets - partants dans une feuille

Le plus simple, sans en-tête à gérer : la fonction IMPORTDATA avec la clé en paramètre et &format=csv. Mettez votre clé dans une cellule (ici A1) :

=IMPORTDATA("https://www.turf.bzh/api/v1/programme?api_key=" & A1 & "&format=csv")

Pour poser un vrai en-tête Authorization (plus propre), passez par Apps Script (Extensions > Apps Script) :

function partants() {
  var url = "https://www.turf.bzh/api/v1/courses/2026-09-16/R1C4";
  var res = UrlFetchApp.fetch(url, {
    headers: { Authorization: "Bearer tbz_live_VOTRE_CLE" }
  });
  var data = JSON.parse(res.getContentText()).data;
  var sheet = SpreadsheetApp.getActiveSheet();
  sheet.clear();
  sheet.appendRow(["Num", "Cheval", "Driver", "Cote BZH", "Note IA"]);
  data.partants.forEach(function (p) {
    sheet.appendRow([p.num, p.name, p.jockey_driver, p.Cote_BZH, p.Note_IA]);
  });
}

Six façons concrètes de vous servir de l'API. Cliquez sur une carte pour le tutoriel correspondant.

L'astuce : la même clé accepte ?api_key= dans l'URL et ?format=csv pour renvoyer un tableau propre. Excel n'a alors aucun en-tête à gérer, il suffit de lui donner une adresse.

Le plus simple : le pack prêt à l'emploi

Téléchargez le Pack Excel turf.bzh : programme et Quinté, cotes d'une course, value bets, plus un suivi de bankroll. Les trois requêtes sont déjà dans le classeur : vous collez votre clé dans la cellule jaune de l'onglet Réglages, vous cliquez sur Actualiser tout, et les trois onglets se remplissent. Vous n'avez aucun code à écrire ni à copier.

Le faire vous-même (Power Query)

1. Ruban Données > Obtenir des données > À partir d'autres sources > Requête vide.
2. Ouvrez Affichage > Éditeur avancé et collez ce code (adaptez l'endpoint) :

   let
       Cle = "tbz_live_VOTRE_CLE",
       Source = Csv.Document(
           Web.Contents("https://www.turf.bzh",
               [ RelativePath = "api/v1/programme",
                 Query = [ api_key = Cle, #"format" = "csv" ] ]),
           [Delimiter=";", Encoding=65001, QuoteStyle=QuoteStyle.Csv]),
       Promu = Table.PromoteHeaders(Source, [PromoteAllScalars=true])
   in
       Promu

3. Fermer et charger. À la première fois, Excel demande le niveau de confidentialité de la source : choisissez Anonyme.
4. Ensuite, Données > Actualiser tout met le tableau à jour quand vous voulez.

Douze adresses acceptent ?format=csv. Elles renvoient un fichier CSV en UTF-8 avec le point-virgule comme séparateur, donc directement lisible par Excel, LibreOffice, Google Sheets, ou n'importe quel outil capable d'aller chercher une adresse web. Aucune n'exige Power Query : elles marchent avec un Excel ancien, un script, ou simplement en enregistrant le fichier depuis votre navigateur.

Les voici en entier, prêtes à copier. Remplacez VOTRE_CLE par la vôtre, et adaptez la date et le code course :

# Le programme du jour
https://www.turf.bzh/api/v1/programme?api_key=VOTRE_CLE&format=csv

# Les partants d'une course, avec tous les indicateurs
https://www.turf.bzh/api/v1/courses/2026-09-16/R1C4?api_key=VOTRE_CLE&format=csv

# Les cotes de cette course, en direct
https://www.turf.bzh/api/v1/courses/2026-09-16/R1C4/cotes?api_key=VOTRE_CLE&format=csv

# Toute la série des cotes de cette course, du matin au départ
https://www.turf.bzh/api/v1/courses/2026-09-16/R1C4/cotes/historique?api_key=VOTRE_CLE&format=csv

# Le classement du jour pour un indicateur
https://www.turf.bzh/api/v1/tops?indicateur=ELO_Cheval&n=10&api_key=VOTRE_CLE&format=csv

# Les value bets du jour
https://www.turf.bzh/api/v1/value-bets?n=10&api_key=VOTRE_CLE&format=csv

# Tous les partants d'une journee entiere, cote de depart comprise
https://www.turf.bzh/api/v1/journees/2026-08-01/partants?api_key=VOTRE_CLE&format=csv

# Le dictionnaire des champs, avec leur taux de remplissage reel
https://www.turf.bzh/api/v1/schema?api_key=VOTRE_CLE&format=csv

# Les dernieres courses d'un cheval (l'idcheval vient de /v1/chevaux?recherche=)
https://www.turf.bzh/api/v1/chevaux/VOTRE_IDCHEVAL/historique?api_key=VOTRE_CLE&format=csv

# Les rapports definitifs d'une course, les DEUX masses PMU
https://www.turf.bzh/api/v1/courses/2026-07-20/R1C5/rapports?api_key=VOTRE_CLE&format=csv

# Tous les rapports d'une journee entiere
https://www.turf.bzh/api/v1/rapports?date=2026-07-20&api_key=VOTRE_CLE&format=csv

# Le taux de couverture de nos selections, sur trente jours
https://www.turf.bzh/api/v1/performances?fenetre=30j&api_key=VOTRE_CLE&format=csv

Quelles dates chacune accepte

C'est la question qui revient le plus souvent, alors autant l'écrire une fois pour toutes.

Le piège du séparateur décimal

C'est la demande qui revient le plus chez les utilisateurs avancés : tester une hypothèse sur l'ensemble de la base plutôt que sur la journée du jour. Trois chemins existent, et le bon dépend uniquement du volume que vous visez. Prendre le mauvais coûte des heures.

Ne parcourez pas la base course par course. Il y a 29 999 courses : au plafond de 10 000 appels par jour, cela représente trois jours calendaires, pour un résultat que les exports donnent en quelques minutes et sans solliciter la base.

La recette, en quatre commandes

K="Authorization: Bearer VOTRE_CLE"
B=https://www.turf.bzh/api/v1

# 1. La liste des mois, avec taille, nombre de lignes et empreinte
curl -s -H "$K" "$B/exports" | jq '.data.fichiers[] | {nom, lignes, partiel, scelle}'

# 2. Tout télécharger, sauf le mois en cours
curl -s -H "$K" "$B/exports" \
  | jq -r '.data.fichiers[] | select(.partiel == false) | .nom' \
  | while read f; do curl -s -H "$K" "$B/exports/$f" -o "$f"; done

# 3. Vérifier que rien n'est arrivé tronqué
for f in partants-*.csv.gz; do gzip -t "$f" || echo "CORROMPU : $f"; done

# 4. Empiler, en ne gardant l'en-tête qu'une fois
zcat partants-2025-*.csv.gz partants-2026-*.csv.gz \
  | awk 'NR==1 || !/^date;/' > base.csv

Trois pièges, mesurés et pas supposés

La dernière journée n'a pas encore sa cote de départ. Elle arrive au rafraîchissement du lendemain matin. Si vous mesurez un rendement en incluant cette journée, vous comptez des lignes sans prix. /v1/statut donne la date exacte où s'arrêter, dans cotes.derniere_journee_avec_cote_de_depart, et l'index des exports la porte aussi.

Un mois clos n'est pas forcément figé. Quand un mois se termine, sa dernière journée entre en base sans ses cotes : le mois est clos mais son contenu bouge encore une nuit. Ces mois-là portent scelle: false et seront régénérés. Ne bâtissez pas une mesure dessus sans revenir la chercher.

Toutes les colonnes ne sont pas remplies. Une quinzaine des 84 colonnes sont sous 65 %, et Rapport_SG n'est présent que sur 8,5 % des lignes. Interrogez /v1/schema avant de choisir vos variables : c'est la différence entre un échantillon de 320 000 lignes et un échantillon de 27 000.

1. Créez un bot Telegram. Dans Telegram, écrivez à @BotFather, envoyez /newbot : il vous donne un jeton. Récupérez aussi votre identifiant de discussion (chat_id) en écrivant à @userinfobot.
2. Lisez les mouvements de cote d'une course avec l'endpoint /cotes/mouvements.
3. Envoyez un message quand une cote baisse au-delà de votre seuil, via l'API Telegram.

Repérez d'abord les champs exacts de la réponse (le nom des colonnes peut évoluer) :

curl -H "Authorization: Bearer tbz_live_VOTRE_CLE" \
  "https://www.turf.bzh/api/v1/courses/2026-09-16/R1C4/cotes/mouvements?fenetre=5&limit=8"

Puis, un script à lancer à intervalle régulier (adaptez les noms de champs à ce que vous voyez) :

import requests

CLE   = "tbz_live_VOTRE_CLE"
BOT   = "JETON_BOTFATHER"      # de @BotFather
CHAT  = "VOTRE_CHAT_ID"        # de @userinfobot
DATE, COURSE = "2026-09-16", "R1C4"
SEUIL = 0.8                    # alerter si une cote perd au moins 0,8 point

api = requests.Session()
api.headers["Authorization"] = f"Bearer {CLE}"
url = f"https://www.turf.bzh/api/v1/courses/{DATE}/{COURSE}/cotes/mouvements"
data = api.get(url, params={"fenetre": 5, "limit": 8}, timeout=15).json().get("data", {})

for m in data.get("mouvements", []):
    evo = m.get("evolution_5min", m.get("evolution", 0)) or 0
    if evo <= -SEUIL:
        txt = f"Baisse {COURSE} : {m.get('cheval')} -> {m.get('cote')} ({evo})"
        requests.get(f"https://api.telegram.org/bot{BOT}/sendMessage",
                     params={"chat_id": CHAT, "text": txt}, timeout=15)

Pour lancer ce script automatiquement, utilisez le Planificateur de tâches (Windows) ou une tâche cron (Mac/Linux), ou passez par n8n/Make (voir plus bas). Pour un bot qui répond à des commandes, voir le tutoriel suivant.

Nous fournissons un bot Telegram prêt à héberger, en Python, qui tourne sur votre ordinateur et répond à vos commandes :

• /course R1C4 - la fiche et les partants d'une course
• /cotes R1C4 - les cotes PMU en direct
• /tops ELO_Cheval - le top du jour d'un indicateur
• /value - les value bets du jour
• /analyse R1C4 - le classement multi-features d'une course

Il n'a besoin d'aucun serveur ni adresse publique (il utilise le "long polling" Telegram). Téléchargez-le, il est livré avec un mode d'emploi :

Télécharger le bot Telegram

En résumé : créez le bot avec @BotFather, mettez votre jeton et votre clé API dans config.py, lancez python bot.py. La même logique se transpose à Discord (bibliothèque discord.py) : une commande, un appel à l'API, une réponse.

Une question, une réponse complète en un seul appel. L'agent choisit ses outils (programme, cotes, indicateurs, vos méthodes), analyse et renvoie un texte. Cet endpoint consomme vos crédits IA (comme sur le site).

import requests

r = requests.post("https://www.turf.bzh/api/v1/chat",
    headers={"Authorization": "Bearer tbz_live_VOTRE_CLE"},
    json={"question": "Quels sont les 3 meilleurs ELO du Quinté du jour ?",
          "mode": "standard", "max_credits": 100},
    timeout=240)
j = r.json()
if "error" in j:
    print("Refus:", j["error"]["message"])   # ex : plafond de crédits dépassé, avant tout débit
else:
    d = j["data"]
    print(d["reponse"])                       # le texte de l'agent, à afficher dans votre outil
    print("Outils:", d.get("tools_utilises"))
    print("Crédits facturés:", d["credits"]["factures"], "- reste:", d["credits"]["solde_restant"])

Le JSON de réponse contient : reponse (le texte), tools_utilises (les outils appelés), credits.factures et credits.solde_restant, et forfait_applique (60 cr pour appliquer une méthode, 100 cr pour un backtest). Prévoyez un délai : un tour peut durer 30 à 180 secondes. Chaque appel est autonome (pas de mémoire de conversation), mettez tout le contexte utile dans la question.

Tout est en GET (sauf /chat). Les dates sont au format YYYY-MM-DD, les courses au format turfiste R1C4. Réponse : {"data": ..., "meta": {...}} en succès, {"error": {...}} sinon.

Sortie tableur : ajoutez ?format=csv sur /programme, /courses/{date}/{rc}, /cotes, /cotes/historique, /tops, /value-bets, /journees/{date}/partants, /schema, /chevaux/{id}/historique, /courses/{date}/{rc}/rapports, /courses/{date}/{rc}/dossier (qui accepte aussi xlsx), /rapports et /performances pour recevoir un CSV UTF-8 (Excel FR, séparateur point-virgule). Les douze adresses en entier, prêtes à copier, avec les dates que chacune accepte.

Cette référence en un fichier : les adresses, leurs paramètres et les 80 champs du dictionnaire se téléchargent en Markdown, en JSON ou en PDF depuis le bloc Emporter cette documentation, en haut de page. C'est ce qu'il faut donner à un assistant plutôt que l'adresse de cette page.

Spec machine : openapi.json (OpenAPI 3, importable dans Postman, Swagger, ou un générateur de client).

Exemple de réponse (extrait de /v1/courses/{date}/{rc}/cotes) :

{
  "data": {
    "date": "2026-09-16",
    "code_course": "R1C4",
    "source": "pmu",
    "updated_at": "2026-09-16T01:23:26+02:00",
    "partants": [
      { "num": 1, "cheval": "EXEMPLE DU BOIS", "cote": 4.8,
        "cote_ref": 7.5, "evolution_ouverture": -2.7,
        "evolution_ouverture_pct": -36.0, "sens_ouverture": "baisse",
        "cote_5min_ago": 5.2, "evolution_5min": -0.4,
        "comparaison_age_sec": 312,
        "tendance": "-", "tendance_pct": 4.1,
        "favori": false, "fraicheur_label": "< 2 min", "np": false }
    ]
  },
  "meta": { "generated_at": "2026-09-16T01:23:26+02:00", "temps_reel": true }
}

Le dossier d'une course : tout en un appel

L'API est granulaire par choix : une ressource, une adresse. C'est le bon découpage quand on veut une chose précise, et c'est le mauvais quand on veut tout. Reconstituer une course complète demandait 7 appels de course, plus un appel par partant pour son historique : 21 appels pour un peloton de quatorze, plus de mille pour une journée entière.

/dossier fait l'assemblage côté serveur. Il compte pour un appel, comme n'importe quelle autre adresse : pas de pondération, pas de plafond à part.

# tout ce que l'on sait de la course, historique des partants compris
curl -H "Authorization: Bearer VOTRE_CLE" \
  "https://www.turf.bzh/api/v1/courses/2026-09-16/R1C4/dossier"

# juste ce dont vous avez besoin, et sans l'historique (reponse bien plus legere)
curl -H "Authorization: Bearer VOTRE_CLE" \
  "https://www.turf.bzh/api/v1/courses/2026-09-16/R1C4/dossier?inclure=classement,cotes&historique=0"

Le même dossier dans un tableur

Un dossier est imbriqué, un tableur ne l'est pas. ?format=csv prend donc les partants comme colonne vertébrale : une ligne par cheval, les champs de course répétés sur chaque ligne (préfixés course_), et chaque section rabattue sur le cheval qu'elle décrit, préfixée par son nom (classement_score, ecarts_ecart_victoire, historique_sorties…). C'est la seule forme qu'un tableur sait filtrer, trier et croiser.

# une ligne par partant, pret pour Power Query
curl -H "Authorization: Bearer VOTRE_CLE" \
  "https://www.turf.bzh/api/v1/courses/2026-09-16/R1C4/dossier?format=csv&historique=0"

# un classeur : un onglet par section, plus Partants et Course
curl -H "Authorization: Bearer VOTRE_CLE" -OJ \
  "https://www.turf.bzh/api/v1/courses/2026-09-16/R1C4/dossier?format=xlsx"

xlsx rend un classeur avec un onglet Partants (la même mise à plat), un onglet par section pour qui veut le détail, et un onglet Course qui rappelle ce que contient le fichier.

Ce que le tableur ne porte pas. L'historique détaillé de chaque cheval devient un simple compteur historique_sorties : quatorze chevaux fois trois sorties, c'est une deuxième table, pas des colonnes. Les valeurs imbriquées (comme top_features) sont jointes en texte lisible. Le JSON reste la forme complète et fait foi ; ces deux sorties sont des commodités.

Aucune section ne peut faire tomber le dossier. Les autres adresses traduisent une donnée manquante en erreur HTTP et s'arrêtent là. Ici, une section indisponible revient en disponible: false avec sa raison, et tout le reste est servi. Seule la course elle-même est bloquante : si elle n'existe pas, il n'y a pas de dossier. meta.appels_economises ne compte que les sections qui ont réellement abouti : c'est un décompte, pas un argument commercial.

{
  "data": {
    "course":   { "date": "2026-09-16", "code_course": "R1C4", "hippodrome": "Vincennes",
                  "nombre_partants_initial": 14, "nombre_partants_reel": 13,
                  "nombre_non_partants": 1, "numeros_non_partants": [ 7 ],
                  "nombre_partants": 14, "partants": [ ... ] },
    "sections": {
      "classement":  { "disponible": true,  "donnees": { ... } },
      "ligne_bzh":   { "disponible": false, "raison": "daily_data_missing",
                       "message": "Pas de lecture LigneBZH pour cette journee." },
      "historique":  { "disponible": true, "sorties_par_cheval": 3,
                       "donnees": { "1347094367": { "disponible": true, "donnees": { ... } } } }
    }
  },
  "meta": {
    "sections_servies": [ "indicateurs", "classement", "..." ],
    "sections_indisponibles": { "ligne_bzh": "daily_data_missing" },
    "appels_economises": 21,
    "cout_quota": 1,
    "cache": "miss", "cache_ttl_s": 15
  }
}

Cache. Une course passée ne bouge plus : son dossier est gardé six heures. Une course du jour porte des cotes vivantes : quinze secondes seulement. meta.cache vous dit lequel des deux cas vous avez touché. Pour une cote à la seconde près, /cotes reste l'adresse.

Trois reculs, trois durées différentes

C'est le point sur lequel on se trompe le plus facilement, alors autant l'écrire noir sur blanc. La réponse contient trois indicateurs de mouvement. Ils ne mesurent pas la même chose et ils ne portent pas sur la même durée.

Comment le lire. Une cote qui baisse veut dire que l'argent rentre sur le cheval, une cote qui monte qu'il est délaissé. C'est une photographie de ce que le public a joué, pas une prévision de l'arrivée. Un cheval massivement joué perd souvent, un cheval délaissé gagne parfois : le mouvement de marché est un élément de contexte parmi d'autres, jamais un signal à suivre seul.

La série complète : /cotes/historique

Les trois reculs ci-dessus sont des écarts entre deux points. Si vous voulez la courbe, c'est /v1/courses/{date}/{rc}/cotes/historique. Elle existe parce que nous l'enregistrons : le flux PMU ne publie que le rapport du moment et celui du matin, jamais la série. Une journée non collectée est perdue définitivement, et c'est pour cela que la collecte tourne depuis le 27/07/2026 alors qu'aucun écran ne l'exploitait encore.

Ce que la collecte ne couvre pas, dit franchement. La finesse ne peut jamais dépasser la fréquence à laquelle notre collecteur est appelé, et elle est aujourd'hui de 5 minutes. Les toutes dernières minutes avant le départ sont donc couvertes par un ou deux relevés, pas davantage, même si le tableau annonce un palier plus serré. Aucune course antérieure au 27/07/2026 n'a de série, et un jour sans relevé renvoie un 404 : c'est une absence de donnée, pas une panne.

Un relevé ressemble à ceci. Le champ cotes donne la cote du moment par numéro, cotes_reference celle du matin. Un numéro absent d'un relevé n'avait pas de cote à cet instant : soit c'est un non-partant, soit le marché n'était pas encore ouvert. Le PMU renvoie 0 dans ce second cas ; nous ne le publions pas comme une cote, parce qu'un 0 fausse toute moyenne et fait exploser tout calcul qui divise par la cote. En CSV, la cellule est simplement vide. Un relevé où aucun numéro n'avait de cote n'apparaît pas du tout.

{
  "data": {
    "date": "2026-09-16", "code_course": "R1C4",
    "hippodrome": "Vichy", "heure_depart": "13:47", "nb_mesures": 24,
    "premiere_mesure": "07:12:03", "derniere_mesure": "13:46:10",
    "mesures": [
      { "t": 1785138324, "heure": "12:25:24",
        "cotes":           { "1": 4.8, "2": 12.3, "3": 3.1 },
        "cotes_reference": { "1": 7.5, "2": 11.0, "3": 3.4 } }
    ]
  }
}

En ?format=csv, la même série arrive en forme longue : une ligne par relevé et par partant, sept colonnes qui ne changent jamais (date;code_course;t;heure;num;cote;cote_ref). C'est volontaire. Une colonne par numéro se lirait mieux à l'oeil, mais le nombre de colonnes changerait d'une course à l'autre et votre requête Power Query casserait au premier changement de partants. Là, la même requête marche sur toutes les courses, et vous pouvez empiler plusieurs courses dans un seul tableau puisque chaque ligne porte sa date et son code course.

Le PMU ne publie pas un rapport par pari, il en publie deux. Le flux nu rend la masse point de vente, celle des bureaux et des cafés. Le même flux appelé avec ?specialisation=INTERNET rend la masse en ligne, dont les types de pari portent le préfixe E_ et les libellés la minuscule (« e-Trio »). Elles ne paient pas la même somme, et l'écart n'est pas un détail : le 20 juillet 2026 sur la R1C5, le couplé placé 15-7 valait 17,80 € au point de vente et 30,10 € en ligne, soit 69 % de plus. Un script qui ignore la distinction compare des nombres qui ne se comparent pas. C'est pourquoi masse est un champ nommé et jamais un préfixe à deviner.

Chaque ligne porte de même deux montants, et pour la même raison. Le PMU publie rapport_pour_1_euro. Ce qu'un parieur encaisse pour un ticket vaut ce nombre multiplié par la mise de base du pari, qui n'est pas la même partout : 1 € au simple gagnant en ligne, 2 € au point de vente, 1,50 € au quarté, 3 € au Multi et au 2 sur 4. Nous servons donc aussi rapport_pour_la_mise_de_base et mise_de_base : personne n'a à refaire la multiplication, ni à se tromper dessus.

Le taux de couverture : ce qu'il est, ce qu'il n'est pas

/v1/performances sert une mesure et une seule : la part des courses où la combinaison gagnante d'un pari était entièrement contenue dans nos N premiers chevaux. Elle est calculée sur toutes les courses de la période où le PMU a publié cette formule, jamais sur une sélection des meilleures, et le dénominateur voyage avec le taux (courses, couvert) pour que vous puissiez le recompter.

Chaque ligne porte tickets, le nombre de combinaisons à jouer, et engage_eur, leur coût. Un taux sans son prix ne veut rien dire : couvrir un trio avec six chevaux, ce sont vingt combinaisons, et ça n'a pas le même sens que de le couvrir avec quatre.

GET /api/v1/performances?fenetre=30j&famille=DEUX_SUR_QUATRE&api_key=VOTRE_CLE
GET /api/v1/courses/2026-07-20/R1C5/rapports?masse=en_ligne&payants=1
GET /api/v1/rapports?date=2026-07-20&pari=TRIO&format=csv

Après chaque réunion, Le Renifleur relit les commentaires officiels de fin de course, raconte l'épreuve en deux ou trois phrases et retient un cheval qui mérite un coup d'oeil la prochaine fois. C'est du contenu écrit, produit chaque jour, que vous ne trouverez nulle part ailleurs. Deux endpoints l'exposent.

Sur une course

curl -H "X-API-Key: VOTRE_CLE" \
  "https://www.turf.bzh/api/v1/courses/2026-07-25/R1C4/renifleur"

{
  "data": {
    "date": "2026-07-25",
    "code_course": "R1C4",
    "carnet_de_course": {
      "resume": "Comme une pâtissière qui sort son gâteau du four une seconde trop tard, ...",
      "cheval_retenu": { "numero": 8, "nom": "LORIGRE",
                         "raison": "A pointé en retard à l'usine, mais a fait les heures sup'." },
      "url": "/pronostics-pmu-25072026-R1C4.html"
    },
    "deja_reperes": [
      { "num": 3, "cheval": "PASSE COMPOSE", "repere_le": "2026-07-20", "repere_a": "Vichy",
        "portait_le_numero": 9, "jours_depuis": 6, "course_origine": "R2C1",
        "note": "Bloquée aux six cents, elle n'a jamais pu sortir." }
    ],
    "nb_deja_reperes": 1,
    "avertissement": "Note de course, pas un pronostic. ..."
  },
  "meta": { "date": "2026-07-25", "code_course": "R1C4" }
}

carnet_de_course vaut null tant que la course n'a pas été courue et débriefée. deja_reperes est le champ le plus intéressant : ce sont les partants du jour qui étaient passés sous le nez du Renifleur à leur sortie précédente. La note n'apparaît que sur leur course de rentrée, et pendant 60 jours au maximum.

Sur un cheval

curl -H "X-API-Key: VOTRE_CLE" \
  "https://www.turf.bzh/api/v1/chevaux/1347094367/renifleur?n_last=5"

Renvoie nb_notes et la liste des notes. nb_notes: 0 signifie que ce cheval n'a jamais été repéré sur la période conservée, soit 400 jours. Environ un cheval sur seize parmi les partants du jour porte une note active.

Ce que ça vaut, honnêtement

Nous mesurons ce carnet et nous publions le résultat, parce qu'un chiffre non vérifié ne vaut rien. Sur 2 411 rentrées analysées :

Lecture : Le Renifleur repère des chevaux nettement meilleurs que la moyenne du peloton. Mais la troisième colonne dit l'essentiel : à cote égale, l'écart n'est pas significatif. Ces chevaux partent déjà à une cote qui tient compte de leur valeur. Un euro joué au gagnant sur chacun d'eux en rendrait 0,72.

Ne construisez pas un modèle de pari sur ce champ. Utilisez-le pour ce qu'il est : du contenu à afficher, un fil narratif pour vos utilisateurs, une mémoire de course. Chaque réponse porte un champ avertissement qui reprend ces chiffres, de sorte qu'un agent qui consomme l'API ne puisse pas les ignorer.

Droits d'usage

Ces textes sont produits et financés par turf.bzh. Leur réutilisation publique suppose une attribution visible à turf.bzh et un lien vers la course d'origine, fourni dans le champ url. La republication en masse sans attribution n'est pas couverte par la Licence API : voir les conditions.

Chaque matin, ÉcurieBZH compare la journée de chaque écurie engagée au programme à ses habitudes des dix-huit derniers mois, et signale ce qui sort de l'ordinaire : un trajet bien plus long que sa zone habituelle (« trajet inhabituel », « plus loin que jamais »), trois chevaux dans la même course, une première venue sur un hippodrome, une monte confiée ou reprise, le retour d'un cheval, une première sortie chez un entraîneur. C'est la même donnée qui alimente le pictogramme et l'onglet ÉcurieBZH du tableau des partants.

Trois façons d'interroger

curl -H "X-API-Key: VOTRE_CLE" \
  "https://www.turf.bzh/api/v1/ecuriebzh"                         # panorama du jour
curl -H "X-API-Key: VOTRE_CLE" \
  "https://www.turf.bzh/api/v1/ecuriebzh?ecurie=S.%20Roger"       # une écurie précise
curl -H "X-API-Key: VOTRE_CLE" \
  "https://www.turf.bzh/api/v1/courses/2026-08-19/R2C1/ecuriebzh" # les écuries d'une course
curl -H "X-API-Key: VOTRE_CLE" \
  "https://www.turf.bzh/api/v1/journees/2026-08-19/ecuriebzh"     # une journée passée

Chaque écurie renvoyée porte ses deplacements du jour (hippodrome, heure) et, pour chacun, ses faits : le libelle du fait, la phrase rédigée qui l'explique, et le kilométrage (km, km_habituel). Une journée passée est servie tant qu'elle est archivée ; une date non archivée répond 404. Le champ archive vaut true sur une journée passée.

Ce que ça dit, ce que ça ne dit pas

C'est une lecture descriptive du comportement des écuries, pas un pronostic. Une écurie qui se déplace loin, qui aligne plusieurs chevaux ou qui découvre un hippodrome ne gagne pas plus souvent pour autant. Le fait raconte quelque chose de la journée de l'écurie - une contrainte, un choix, un déplacement rare - il ne dit rien de la probabilité qu'un de ses chevaux gagne. Chaque réponse porte un champ avertissement qui le rappelle, de sorte qu'un agent qui consomme l'API ne puisse pas le présenter comme une raison de jouer.

Droits d'usage

Donnée produite et financée par turf.bzh. Sa réutilisation publique suppose une attribution visible à turf.bzh. La republication en masse sans attribution n'est pas couverte par la Licence API : voir les conditions.

Le même appel dans trois langages : on lit le programme du jour, on affiche le contenu. Explorez la structure renvoyée, puis ciblez ce qui vous intéresse.

Python (requests)

import requests

r = requests.get("https://www.turf.bzh/api/v1/programme",
                 headers={"Authorization": "Bearer tbz_live_VOTRE_CLE"},
                 timeout=15)
j = r.json()
if "error" in j:
    print("Erreur:", j["error"]["message"])
else:
    print(j["data"])   # explorez, puis ciblez j["data"][...] selon vos besoins

Node.js (18+ : fetch intégré)

const KEY = "tbz_live_VOTRE_CLE";

const res = await fetch("https://www.turf.bzh/api/v1/programme", {
  headers: { Authorization: `Bearer ${KEY}` }
});
const j = await res.json();
if (j.error) {
  console.error("Erreur:", j.error.message);
} else {
  console.log(j.data);
}

PHP (cURL)

<?php
$ch = curl_init("https://www.turf.bzh/api/v1/programme");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => ["Authorization: Bearer tbz_live_VOTRE_CLE"],
    CURLOPT_TIMEOUT        => 15,
]);
$j = json_decode(curl_exec($ch), true);
curl_close($ch);
if (isset($j["error"])) {
    echo "Erreur: " . $j["error"]["message"];
} else {
    print_r($j["data"]);
}

Postman

Deux façons de démarrer : importez notre collection Postman prête (tous les endpoints rangés par thème), ou importez directement la spec openapi.json (Postman > Import > Link ou File).

1. Importez la collection dans Postman.
2. Ouvrez l'onglet Variables de la collection, remplacez api_key par votre clé, ajustez date et rc.
3. L'authentification Bearer est déjà posée au niveau de la collection : lancez n'importe quelle requête.

n8n

Ajoutez un nœud HTTP Request : méthode GET, URL https://www.turf.bzh/api/v1/programme. Dans Authentication, choisissez Generic Credential Type > Header Auth, avec le nom Authorization et la valeur Bearer tbz_live_VOTRE_CLE. Enchaînez ensuite un nœud de traitement ou une notification (Telegram, e-mail...).

Make (ex-Integromat)

Module HTTP > Make a request : URL de l'endpoint, méthode GET, et un en-tête Authorization = Bearer tbz_live_VOTRE_CLE. Activez Parse response pour manipuler le JSON directement.

Posez une question à ChatBZH comme sur le site : l'agent choisit ses outils (programme, cotes live, indicateurs, vos méthodes...), analyse, et renvoie une réponse complète en un seul JSON. Cet endpoint consomme les crédits IA de votre compte (mêmes règles que le site : plafond 300 cr par question, forfait 60 cr pour appliquer une méthode, 100 cr pour un backtest).

curl -X POST "https://www.turf.bzh/api/v1/chat" \
  -H "Authorization: Bearer tbz_live_VOTRE_CLE" \
  -H "Content-Type: application/json" \
  -d '{"question": "Applique ma méthode Borda V2 sur R1C4", "mode": "standard", "max_credits": 100}'

• question (requis) : votre question, comme dans le chat.
• mode : standard (défaut) ou expert (analyse approfondie, coûte ~3x plus).
• max_credits (5-300, défaut 300) : votre plafond d'acceptation. Si l'estimation dépasse, refus 402 cost_exceeds_max_credits AVANT tout débit - l'équivalent API de la modale de confirmation du site.
• Réponse : reponse (texte), tools_utilises, credits.factures, credits.solde_restant, forfait_applique.
• Patience : un tour peut durer 30 à 180 secondes (l'agent enchaîne plusieurs outils). Prévoyez un timeout client de 240 s. Limite : 10 questions/minute, 1 question à la fois par compte.
• Chaque appel est autonome (pas de mémoire de conversation) : mettez tout le contexte dans la question.

Toute erreur renvoie un JSON uniforme :

{ "error": { "code": "subscription_required", "message": "...", "status": 403, "doc": "..." } }

• 60 requêtes/minute et 10 000/jour par clé (limite technique anti-abus, pas un compteur commercial). Réponse 429 + Retry-After au-delà.
• Ne devinez plus vos appels restants, lisez-les. Chaque réponse porte meta.quota (limite_minute, restant_minute, reset_minute_s, limite_jour, restant_jour, reset_jour_s) et les en-têtes X-RateLimit-*. Un programme qui boucle lit restant_minute et dort reset_minute_s secondes plutôt que d'attendre le 429. Le détail et un exemple.
• Un troisième plafond, 120 requêtes par minute et par IP, protège contre une clé partagée ou volée. Il n'apparaît pas dans quota : ce n'est pas votre compteur. On le reconnaît à scope: "ip" sur un 429.
• /v1/chat : 10 questions/minute et une seule question à la fois par compte (le solde de crédits IA borne naturellement le reste).
• Les cotes live sont rafraîchies côté serveur avec un cache adaptatif : interroger plus d'une fois toutes les 30 s n'apporte rien.
• Ne mettez JAMAIS votre clé dans du code visible (page web publique, dépôt GitHub public, capture d'écran). En cas de fuite : régénérez.
• Usage personnel uniquement : la revente, la redistribution des données ou le partage de clé sont interdits (CGV turf.bzh) et détectés par l'audit.
• Contrat de version : sur /v1, des champs peuvent être AJOUTÉS, jamais retirés ni renommés. Codez tolérant aux champs inconnus.

Les données et indicateurs turf.bzh sont des outils d'aide à la décision pour un loisir. Aucune API, aucun indicateur, aucun modèle ne garantit un gain : les courses comportent une part d'incertitude irréductible. Automatiser ses analyses ne doit jamais devenir automatiser ses mises. Fixez-vous des limites de budget et de temps, et ne jouez que ce que vous pouvez vous permettre de perdre.

12/09/2026 Les non partants ne sont plus servis comme des partants. Un cheval déclaré forfait figure dans notre base avec Rank = NP, et /v1/courses/{date}/{rc} comme /v1/journees/{date}/partants ne le distinguaient pas : 3 768 lignes et 2 741 courses sur les 8 530 mesurées de janvier à juin 2026. Chaque partant porte désormais partant, statut_partant et, sur un forfait, source_statut. Chaque course sépare nombre_partants_initial (le peloton engagé) de nombre_partants_reel, avec nombre_non_partants et leurs numéros. Ces deux nombres sont comptés ligne à ligne et non déduits de la colonne annoncée, servie sous le nom nombre_partants_declare : sur les courses avec forfait, elle vaut le peloton engagé 85,6 % du temps et le peloton réel 10,0 % seulement. Pour une course du jour non encore courue, les forfaits de dernière minute sont relevés en direct sur le flux PMU, seule source qui les connaisse avant l'arrivée. Nouveaux paramètres non_partants et non_partants_direct. Rien n'est retiré ni renommé.

09/09/2026 Les cinq probabilités IA, au lieu de deux. IA_Couple, IA_Trio et IA_Multi rejoignent IA_Gagnant et IA_Quinte sur /v1/courses/{date}/{rc}, /dossier, /indicateurs, /journees/{date}/partants et /quinte. Elles existaient en base et s'affichaient dans le tableau des partants (boutons IA COUPLE, IA TRIO, IA MULTI), mais l'API n'en exposait aucune. ia_quinte apparaît par ailleurs dans /indicateurs, qui la lisait depuis sa mise en service sans jamais la rendre. Rien n'est retiré ni renommé.

V1 16/09/2026 - Lancement : clé API self-service, licence à vie au tarif de lancement de 19,90 €, endpoints me, statut, programme, quinte, resultats, courses/{date}/{rc} (+ /cotes, /cotes/mouvements, /arrivee).

V2-V4 16/09/2026 - Données premium (indicateurs, analyse + LigneBZH, écarts, tops, value-bets, lectures, chevaux, personnes), format=csv, POST /v1/chat (crédits IA), /v1/methodes, spec openapi.json.

V5 16/09/2026 - Carnet de notes du Renifleur : /v1/courses/{date}/{rc}/renifleur et /v1/chevaux/{id}/renifleur. Contenu éditorial exclusif, avec la mesure de ce qu'il vaut publiée dans la section dédiée.

08/09/2026 Vos appels restants, dans chaque réponse. Toute réponse 200 porte un bloc meta.quota et six en-têtes X-RateLimit-* : limite et restant sur la minute, limite et restant sur la journée, et les secondes avant chaque remise à zéro. Les mêmes valeurs partent sur un 429, où quota rejoint retry_after et scope dans error. Les en-têtes sont exposés par Access-Control-Expose-Headers, donc lisibles par un fetch() de navigateur. Quand le compteur est indisponible, rien n'est émis plutôt qu'un chiffre faux. Aucun coût de quota supplémentaire, aucun champ retiré : le contrat v1 tient. Livré en même temps, le pack IA qui forme Claude et Codex au turf, compris dans la Licence API.

06/09/2026 Le dossier complet d'une course, en un appel. /v1/courses/{date}/{rc}/dossier assemble côté serveur ce qu'il fallait aller chercher en sept appels de course plus un par partant. Paramètres inclure, historique et hippodrome. Il compte pour un appel de quota, sans pondération ni plafond dédié, et les limites existantes (60/minute, 10 000/jour) sont inchangées. Aucune adresse existante n'est modifiée : le contrat v1 tient, des champs sont ajoutés, aucun n'est retiré ni renommé.

25/08/2026 Le propriétaire et l'éleveur entrent dans l'API. Chaque partant porte désormais owner (propriétaire), breeder (éleveur) et leurs identifiants stables idproprio / ideleveur, sur /v1/courses/{date}/{rc} et /v1/chevaux/{id}/historique. La recherche /v1/personnes?type= et les stats /v1/personnes/{type}/{id}/stats acceptent deux types de plus, proprietaire et eleveur, avec les mêmes mesures qu'un jockey ou un entraîneur (partants, chevaux distincts, victoires, placés, taux V/P, ROI placé, répartition par discipline). Ces colonnes sont remplies rétroactivement sur l'historique : elles ne sont pas renseignées à 100 %, et /v1/schema en publie le taux réel. Le contrat v1 ne change pas : des champs sont ajoutés, aucun n'est retiré ni renommé.

22/08/2026 ÉcurieBZH ouvre à l'API : ce que fait chaque écurie aujourd'hui. Trois adresses nouvelles - /v1/ecuriebzh (le panorama du jour, paramètre ecurie pour n'en interroger qu'une), /v1/courses/{date}/{rc}/ecuriebzh (les écuries engagées dans une course) et /v1/journees/{date}/ecuriebzh (une journée passée archivée). La même donnée que l'onglet ÉcurieBZH du tableau des partants : lecture descriptive du comportement des écuries, jamais un pronostic (champ avertissement). La section dédiée.

30/07/2026 Pack Excel refait, et un correctif sur /value-bets. Le classeur contient maintenant les trois requêtes Power Query prêtes à l'emploi : coller la clé et cliquer sur Actualiser tout suffit. Séparément, /v1/value-bets?format=csv renvoyait du JSON au lieu du CSV, ce qui rendait la troisième requête inopérante même correctement saisie ; c'est corrigé. Retéléchargez le pack si vous l'aviez pris avant cette date.

21/08/2026 Le programme s'ouvre aux journées passées. /v1/programme et /v1/quinte ne servaient que le jour même : toute autre date renvoyait une erreur 422 dont le message conseillait /v1/courses/{date}/{rc}, qui sert une course. Celui qui demandait le programme d'hier ne trouvait donc pas la bonne adresse et concluait à une panne. C'est devenu notre premier motif de support sur l'API. Les deux adresses acceptent désormais date=AAAA-MM-JJ. /programme rend les huit mêmes clés que pour le jour même, dans le même ordre, y compris quand aucune course ne sort : un client qui lit déjà la réponse du jour n'a rien à changer. Deux réserves, écrites plutôt que tues : filter=upcoming est refusé sur une journée passée, parce que le filtre du jour est posé sur le WHERE et fausserait le nombre de partants (mesure du 1^er août : 17 au lieu de 28 sur Goodwood R6C4) ; et la couverture de /quinte est celle du fichier de référence Quinté+, pas celle de la base. Pour reconstituer une journée entière avec tous les partants et leur cote de départ, /v1/journees/{date}/partants reste plus direct, en un seul appel.

21/08/2026 is_completed disait « à venir » d'une course sur trois, courue depuis des mois. Une course était réputée terminée quand tous ses partants avaient un classement, et un non partant comptait comme un classement manquant. Mesure sur les 28 809 courses de la base : 9 716, soit 33,7 %, ressortaient is_completed: false alors qu'elles étaient courues. Le filtre completed, lui, appliquait déjà la bonne règle : le champ et le filtre se contredisaient sur la même course. La règle est harmonisée partout, y compris pour /v1/programme au jour même et pour l'agent : une course est terminée quand aucun partant n'attend son classement et qu'au moins un partant est classé. Le jour même, le changement est neutre : la base ne reçoit les classements que le lendemain à 06h, donc les deux règles y répondaient déjà la même chose. Corrigé au même endroit : une course entièrement dépouillée mais comptant un non partant était signalée « en attente d'ingestion ».

21/08/2026 Les liens de course rendus par l'API pointaient sur la mauvaise course. Le champ link_url de /v1/programme était construit en minuscules. Or la page de course découpe son adresse avec une expression sensible à la casse et retombe en silence sur R1C1 quand elle échoue, sans jamais renvoyer 404. Mesure du 21/08 : /pronostics-pmu-20082026-r5c3.html répondait 200 en affichant R1C1 à Deauville, au lieu de R5C3 à York. Tous les link_url sont désormais en majuscules et mènent à la bonne course.

05/08/2026 Les rapports PMU s'ouvrent, les deux masses, et la mesure de ce qu'ils ont couvert. Trois adresses nouvelles. /v1/courses/{date}/{rc}/rapports et /v1/rapports servent les rapports definitifs COLLECTES, 306 088 sur 9 038 courses depuis le 1er janvier, point de vente ET en ligne : /arrivee interrogeait le PMU en direct et ne servait donc que la journee en cours, sur une seule masse. Chaque ligne porte les DEUX montants, rapport_pour_1_euro et rapport_pour_la_mise_de_base, parce que la mise de base va de 1 a 3 EUR selon le pari et que servir un seul des deux obligeait chacun a refaire la multiplication. /v1/performances publie le taux de couverture mesure de nos selections, avec son denominateur et le cout de chaque formule. Les trois acceptent format=csv, ce qui porte a douze le nombre d'adresses qui rendent un tableau. Ce que sont les deux masses, et ce que le taux n'est pas.

03/08/2026 L'historique profond s'ouvre : une journee entiere, un dictionnaire, et la base en telechargement. Trois adresses nouvelles. /v1/journees/{date}/partants rend tous les partants d'une journee en un seul appel, cote de depart comprise : reconstituer la base demandait un appel par course, elle en demande un par journee. /v1/schema publie le taux de remplissage reel de chaque champ, qui n'etait ecrit nulle part. /v1/exports sert la base entiere en CSV compresse, un fichier par mois, avec son empreinte SHA-256. Les deux premieres acceptent format=csv, et /v1/chevaux/{id}/historique l'acceptait deja sans que ce soit ecrit : cela porte a neuf le nombre d'adresses qui rendent un tableau. Les bornes debut et fin arrivent aussi sur l'historique d'un cheval et sur les statistiques d'un jockey ou d'un entraineur.

31/07/2026 L'historique des cotes s'ouvre : /v1/courses/{date}/{rc}/cotes/historique. Toute la série d'une course, du matin au départ, là où /cotes ne donnait que l'instantané et /cotes/mouvements qu'une fenêtre de deux heures. La donnée était collectée depuis le 27/07/2026 sans que personne puisse la lire ; c'est réparé. Sortie format=csv en forme longue, ce qui porte à six le nombre d'adresses qui rendent un tableau. Ce que la collecte couvre, et ce qu'elle ne couvre pas.

31/07/2026 Une page pour les six adresses en CSV. Elles étaient annoncées en une phrase, sans jamais être écrites en entier. Elles le sont désormais, prêtes à copier, avec les dates que chacune accepte et le piège du séparateur décimal sous Excel français. Aller à la section.

Docs 16/09/2026 - Documentation orientée cas d'usage : premiers pas en 5 min, galerie, tutoriels (Excel/Power Query, alerte Telegram, bot, ChatBZH), exemples Python/Node/PHP, outils n8n/Make, et modèles téléchargeables (pack Excel, collection Postman, bot).