Jours fériés et jours ouvrés en France de 2026 à 2030 : le calcul en Python et les chiffres

Tutoriels en français · Par la rédaction de Loop & Branch · Publié le 2026-11-09

Brins de muguet aux clochettes blanches et aux larges feuilles vertes, posés dans une maison — Le muguet du 1er mai, seul jour férié obligatoirement chômé pour tous les salariés.

En 2027, la France métropolitaine ne compte que 7 jours fériés tombant un jour de semaine, contre 9 en 2026 et 10 en 2030 : le 1er mai, le 8 mai et Noël 2027 tombent un samedi. Cet écart change le nombre de jours ouvrés de l'année (254 en 2027, 251 en 2028 et en 2030), donc les plannings, les délais de livraison exprimés en jours ouvrés et les simulations de paie. Voici comment calculer ces dates en Python, les vérifier avec la source officielle et en tirer les chiffres de 2026 à 2030.

Le code a été exécuté avec Python 3.13 et requests 2.34 ; les sorties affichées sont réelles. Les blocs s'enchaînent dans un même fichier.

Ce que dit le Code du travail

L'article L3133-1 du Code du travail énumère onze fêtes légales : le 1er janvier, le lundi de Pâques, le 1er mai, le 8 mai, l'Ascension, le lundi de Pentecôte, le 14 juillet, l'Assomption (15 août), la Toussaint (1er novembre), le 11 novembre et Noël. Comme le rappelle la fiche Service Public sur les jours fériés, seul le 1er mai est obligatoirement chômé pour tous les salariés ; pour les autres, tout dépend de la convention collective ou de l'accord d'entreprise. Le lundi de Pentecôte reste un jour férié, même quand une entreprise en fait sa journée de solidarité.

Deux régimes particuliers existent :

Alsace-Moselle (Bas-Rhin, Haut-Rhin, Moselle) : le droit local ajoute le Vendredi saint et le 26 décembre (Saint-Étienne), soit 13 jours fériés. Le texte réserve le Vendredi saint aux communes ayant un temple protestant ou une église mixte ; en pratique, il est appliqué dans les trois départements, et c'est ce que fait l'API officielle.
Outre-mer : chaque territoire a en plus sa date de commémoration de l'abolition de l'esclavage, et certains d'autres fêtes locales. L'API publique couvre ces zones ; le calcul ci-dessous se limite à la métropole et à l'Alsace-Moselle.

Calculer la date de Pâques

Sept fêtes sont à date fixe. Les trois autres (lundi de Pâques, Ascension, lundi de Pentecôte) dépendent de Pâques, qui tombe le premier dimanche suivant la pleine lune ecclésiastique de printemps. L'algorithme de Meeus, Jones et Butcher calcule ce dimanche pour n'importe quelle année du calendrier grégorien avec des divisions entières uniquement :

from datetime import date, timedelta

def paques(annee: int) -> date:
    """Dimanche de Pâques (calendrier grégorien), algorithme de Meeus/Jones/Butcher."""
    a = annee % 19
    b, c = divmod(annee, 100)
    d, e = divmod(b, 4)
    f = (b + 8) // 25
    g = (b - f + 1) // 3
    h = (19 * a + b - d - g + 15) % 30
    i, k = divmod(c, 4)
    l = (32 + 2 * e + 2 * i - h - k) % 7
    m = (a + 11 * h + 22 * l) // 451
    mois, jour = divmod(h + l - 7 * m + 114, 31)
    return date(annee, mois, jour + 1)

print([paques(a).isoformat() for a in range(2026, 2031)])

['2026-04-05', '2027-03-28', '2028-04-16', '2029-04-01', '2030-04-21']

Si la bibliothèque python-dateutil est déjà installée dans votre projet, dateutil.easter.easter(annee) renvoie le même résultat. La version ci-dessus n'a besoin que de la bibliothèque standard.

La liste des jours fériés d'une année

À partir de Pâques : lundi de Pâques = Pâques + 1 jour, Ascension = Pâques + 39 jours (toujours un jeudi), lundi de Pentecôte = Pâques + 50 jours, Vendredi saint = Pâques − 2 jours.

def jours_feries(annee: int, alsace_moselle: bool = False) -> dict[date, str]:
    p = paques(annee)
    feries = {
        date(annee, 1, 1): "Jour de l'an",
        p + timedelta(days=1): "Lundi de Pâques",
        date(annee, 5, 1): "Fête du Travail",
        date(annee, 5, 8): "Victoire 1945",
        p + timedelta(days=39): "Ascension",
        p + timedelta(days=50): "Lundi de Pentecôte",
        date(annee, 7, 14): "Fête nationale",
        date(annee, 8, 15): "Assomption",
        date(annee, 11, 1): "Toussaint",
        date(annee, 11, 11): "Armistice 1918",
        date(annee, 12, 25): "Noël",
    }
    if alsace_moselle:
        feries[p - timedelta(days=2)] = "Vendredi saint"
        feries[date(annee, 12, 26)] = "Saint-Étienne"
    return dict(sorted(feries.items()))

JOURS = ["lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche"]
for jour, nom in jours_feries(2027).items():
    print(f"{JOURS[jour.weekday()]:9} {jour:%d/%m/%Y}  {nom}")

vendredi  01/01/2027  Jour de l'an
lundi     29/03/2027  Lundi de Pâques
samedi    01/05/2027  Fête du Travail
jeudi     06/05/2027  Ascension
samedi    08/05/2027  Victoire 1945
lundi     17/05/2027  Lundi de Pentecôte
mercredi  14/07/2027  Fête nationale
dimanche  15/08/2027  Assomption
lundi     01/11/2027  Toussaint
jeudi     11/11/2027  Armistice 1918
samedi    25/12/2027  Noël

On voit tout de suite pourquoi 2027 est une année « généreuse » en jours travaillés : quatre fêtes tombent un samedi ou un dimanche. Le Code du travail ne prévoit pas de compenser un jour férié qui tombe un week-end ; seuls certains accords collectifs le font.

Vérifier avec l'API jours fériés

L'administration publie les dates officielles via l'API jours fériés, accessible sans clé à l'adresse calendrier.api.gouv.fr, avec une zone par territoire (metropole, alsace-moselle, guadeloupe, la-reunion…). Plutôt que de recopier ses dates dans le code, on s'en sert pour vérifier le calcul :

import requests

def feries_api(annee: int, zone: str = "metropole") -> dict[date, str]:
    url = f"https://calendrier.api.gouv.fr/jours-feries/{zone}/{annee}.json"
    r = requests.get(url, timeout=10)
    r.raise_for_status()
    return {date.fromisoformat(k): v for k, v in r.json().items()}

for annee in range(2026, 2031):
    for zone, am in [("metropole", False), ("alsace-moselle", True)]:
        assert set(feries_api(annee, zone)) == set(jours_feries(annee, am)), (annee, zone)
print("2026-2030, métropole et Alsace-Moselle : mêmes dates que l'API")

2026-2030, métropole et Alsace-Moselle : mêmes dates que l'API

Les deux sources concordent sur les dix combinaisons testées. Dans une application, vous pouvez donc soit appeler l'API (et mettre ses réponses en cache, les dates d'une année ne changent pas), soit calculer localement et garder ce test dans votre suite de tests pour détecter une évolution de la loi. Le calcul local a l'avantage de fonctionner hors ligne et pour n'importe quelle année.

Jours ouvrés et jours ouvrables de 2026 à 2030

Deux notions à ne pas confondre : les jours ouvrés sont les jours normalement travaillés dans l'entreprise, en général du lundi au vendredi ; les jours ouvrables sont tous les jours de la semaine sauf le dimanche et les jours fériés habituellement chômés, soit du lundi au samedi. Le calcul suivant considère que tous les jours fériés sont chômés, ce qui est le cas le plus courant mais pas une obligation légale (seul le 1er mai l'est).

def compter(annee: int, alsace_moselle: bool = False) -> tuple[int, int, int]:
    """(fériés tombant du lundi au vendredi, jours ouvrés, jours ouvrables)"""
    feries = set(jours_feries(annee, alsace_moselle))
    en_semaine = ouvres = ouvrables = 0
    jour = date(annee, 1, 1)
    while jour.year == annee:
        js = jour.weekday()                 # 0 = lundi … 6 = dimanche
        if jour in feries:
            en_semaine += js < 5
        else:
            ouvres += js < 5                # du lundi au vendredi
            ouvrables += js < 6             # du lundi au samedi
        jour += timedelta(days=1)
    return en_semaine, ouvres, ouvrables

print("année   métropole (fériés/ouvrés/ouvrables)   Alsace-Moselle")
for annee in range(2026, 2031):
    m, am = compter(annee), compter(annee, alsace_moselle=True)
    print(f"{annee}    {m[0]:>2} / {m[1]} / {m[2]}                    {am[0]:>2} / {am[1]} / {am[2]}")

année   métropole (fériés/ouvrés/ouvrables)   Alsace-Moselle
2026     9 / 252 / 303                    10 / 251 / 301
2027     7 / 254 / 303                     8 / 253 / 302
2028     9 / 251 / 302                    11 / 249 / 300
2029     9 / 252 / 303                    11 / 250 / 301
2030    10 / 251 / 303                    12 / 249 / 301

Jours fériés, jours ouvrés et jours ouvrables par année (tous les jours fériés supposés chômés)
Année	Pâques	Fériés du lundi au vendredi (métropole)	Jours ouvrés (métropole)	Jours ouvrables (métropole)	Fériés du lundi au vendredi (Alsace-Moselle)	Jours ouvrés (Alsace-Moselle)	Jours ouvrables (Alsace-Moselle)
2026	5 avril	9	252	303	10	251	301
2027	28 mars	7	254	303	8	253	302
2028	16 avril	9	251	302	11	249	300
2029	1er avril	9	252	303	11	250	301
2030	21 avril	10	251	303	12	249	301

Lecture : en 2028, un salarié de Strasbourg ou de Metz travaillant du lundi au vendredi a deux jours ouvrés de moins qu'un salarié de Lyon, parce que le Vendredi saint (14 avril) et le 26 décembre (un mardi) tombent en semaine. Les jours ouvrables, eux, varient avec les fériés tombant un samedi : le 26 décembre 2026, un samedi, retire un jour ouvrable en Alsace-Moselle mais aucun jour ouvré.

Ajouter n jours ouvrés à une date

Délais de rétractation, de livraison, de traitement d'un dossier : beaucoup de délais s'expriment en jours ouvrés. Pour les calculer, on avance jour par jour en sautant les week-ends et les jours fériés, en chargeant ceux de l'année suivante pour passer correctement le 31 décembre :

def ajouter_jours_ouvres(depart: date, n: int, alsace_moselle: bool = False) -> date:
    """Date atteinte après n jours ouvrés (le jour de départ n'est pas compté)."""
    feries = set(jours_feries(depart.year, alsace_moselle)) | set(jours_feries(depart.year + 1, alsace_moselle))
    jour = depart
    while n > 0:
        jour += timedelta(days=1)
        if jour.weekday() < 5 and jour not in feries:
            n -= 1
    return jour

print(ajouter_jours_ouvres(date(2028, 12, 21), 5))
print(ajouter_jours_ouvres(date(2028, 12, 21), 5, alsace_moselle=True))

2028-12-29
2029-01-02

À partir du jeudi 21 décembre 2028, cinq jours ouvrés mènent au 29 décembre en métropole, mais au 2 janvier 2029 en Alsace-Moselle, où le 26 décembre est férié et où le 1er janvier tombe un lundi. Pour un délai légal précis (procédure, contrat), vérifiez toujours la règle de computation du texte concerné : certains délais se comptent en jours calendaires, d'autres en jours ouvrables, et le report au jour ouvrable suivant d'un délai expirant un samedi, un dimanche ou un jour férié dépend de la matière.

Exploiter ces dates dans un tableau de données

Pour marquer les jours fériés dans une série chronologique (ventes quotidiennes, fréquentation), transformez la liste en ensemble et testez l'appartenance de chaque date, ou construisez une colonne booléenne avec pandas. Si vos données arrivent dans un fichier CSV exporté d'un tableur français, avec des dates au format JJ/MM/AAAA, notre article sur la lecture des CSV français avec pandas montre comment les convertir sans inverser jour et mois. Pour d'autres contrôles de données propres à la France, voyez aussi la vérification des numéros SIRET et SIREN.

Méthode et sources

Dates des jours fériés : calcul local (algorithme de Meeus/Jones/Butcher pour Pâques, décalages fixes pour les fêtes mobiles), comparé le 9 novembre 2026 aux réponses de l'API jours fériés pour 2026 à 2030, zones « metropole » et « alsace-moselle » : concordance complète.
Jours ouvrés : jours du lundi au vendredi qui ne sont pas fériés ; jours ouvrables : jours du lundi au samedi qui ne sont pas fériés. Tous les jours fériés sont supposés chômés.
Liste légale des fêtes : Code du travail, article L3133-1 (métropole) et article L3134-13 (Alsace-Moselle), résumés dans la fiche Service Public citée plus haut.

Sources

Service Public, Jours fériés et ponts dans le secteur privé (liste des fêtes légales, régimes d'Alsace-Moselle et d'outre-mer, 1er mai).
data.gouv.fr, API jours fériés (dates officielles par zone et par année).