Liste des Jeux Switch 2 : Tracker Auto en 13 Étapes

Le catalogue de la Nintendo Switch 2 ne tient plus sur une seule page. Entre les sorties officielles du mois, les précommandes, les portages rétrocompatibles de la Switch originale et les annonces faites en Nintendo Direct, la liste des jeux Switch 2 change plusieurs fois par semaine. En octobre 2026 seulement, Nintendo a ajouté KINGDOM HEARTS Collection [I–III], Dragon’s Dogma 2: Dark Arisen, Ratatan et les portages Resident Evil à son eShop européen, sans compter les annonces à venir fin octobre. Suivre tout cela à la main, en rafraîchissant des pages web, devient vite impossible.

Ce tutoriel construit un tracker automatisé de la liste des jeux Switch 2, codé en Python, qui récupère les flux RSS officiels de Nintendo, stocke chaque sortie dans une base SQLite, détecte les nouveautés, classe les titres par type (exclusivité, rétrocompatibilité, free-to-play) et envoie une alerte sur Discord dès qu’un nouveau jeu apparaît. Treize étapes, environ 90 minutes, pour un projet qui tourne ensuite seul en tâche planifiée.

Pourquoi la liste des jeux Switch 2 bouge chaque semaine

Trois flux alimentent en parallèle le catalogue de la console. Le premier regroupe les jeux natifs Switch 2, conçus ou portés spécifiquement pour la nouvelle puce. Le deuxième couvre la rétrocompatibilité: la quasi-totalité du catalogue Switch 1 tourne sur la nouvelle machine, parfois avec un correctif de performance payant. Le troisième flux, plus discret, correspond aux mises à jour gratuites qui transforment un jeu Switch 1 existant en expérience Switch 2, comme l’a fait Nintendo avec certains titres via des packs d’amélioration.

La page officielle Nintendo France des jeux à venir et les temps forts hebdomadaires de l’eShop Nintendo publiés par des médias comme Nintendo Insider restent les deux sources les plus fiables. Elles distinguent les jeux déjà sortis, les précommandes et les versions Switch 2 par rapport aux éditions Switch première génération. Le problème, c’est qu’aucune de ces pages n’offre de vue consolidée sur plusieurs semaines, ni d’alerte automatique. D’où l’intérêt de construire son propre agrégateur.

Un exemple concret illustre la cadence actuelle. En une seule quinzaine d’octobre 2026, le eShop européen a vu débarquer Earth Defense Force 6, Hell Is Us, The Crew Motorfest, Echo Weaver, Forever Ago, Silver Pines et The Relic: First Guardian, en plus des sorties majeures citées plus haut. Sans automatisation, repérer chaque arrivée dans ce flux demande une veille quotidienne sur plusieurs sites.

Les listes figées publiées sur des forums ou des wikis vieillissent mal face à ce rythme. Un article statique daté de septembre ne mentionnera jamais KINGDOM HEARTS Collection [I–III] ni Ratatan, puisque ces titres n’existaient pas encore dans le catalogue au moment de sa rédaction. Un tracker qui interroge directement la source à chaque exécution règle ce problème à la racine: il n’y a plus de version figée à maintenir à la main, seulement une base qui se met à jour toute seule.

Prérequis: outils, comptes et versions nécessaires

Le projet reste volontairement léger. Pas de cloud, pas de base de données externe, tout tourne sur une machine locale ou un petit serveur personnel. Voici l’environnement exact à préparer avant de commencer.

Outil	Version recommandée	Rôle dans le projet
Python	3.12 ou plus récent	Langage principal du tracker
pip	dernière version stable	Installation des dépendances
feedparser	dernière version stable	Lecture des flux RSS Nintendo
requests	dernière version stable	Appels HTTP et webhooks
Flask	dernière version stable	Mini tableau de bord web
SQLite 3	intégré à Python	Stockage du catalogue
cron (Linux/macOS) ou Planificateur de tâches (Windows)	natif à l’OS	Exécution automatique périodique
Webhook Discord	n/a	Notifications de nouvelles sorties

Un compte Discord gratuit suffit pour créer le webhook de notification. Aucune clé d’API Nintendo n’existe publiquement: le tracker s’appuie uniquement sur des flux RSS et des pages publiques, sans jamais authentifier de compte Nintendo ni contourner un système de paiement. Gardez cette limite en tête tout au long du tutoriel, elle conditionne les choix techniques des étapes suivantes.

Côté système, les trois grandes familles d’OS installent Python différemment. Sous Windows, le plus simple reste le programme d’installation officiel depuis python.org, en cochant la case qui ajoute Python au PATH. Sous macOS, Homebrew (brew install python) évite les conflits avec la version système préinstallée par Apple. Sous Linux, le gestionnaire de paquets de la distribution (apt, dnf, pacman) suffit largement, à condition de vérifier que le paquet python3-venv est bien présent pour créer des environnements virtuels.

Étape 1: repérer les sources officielles de la liste des jeux Switch 2

Avant d’écrire une seule ligne de code, il faut cartographier les sources. Nintendo publie chaque semaine, via son site européen, un récapitulatif des sorties eShop sous forme d’article HTML classique. Ces pages suivent un format régulier: une liste de titres, chacun accompagné d’une plateforme (Switch, Switch 2, ou les deux) et d’une date. Certains médias spécialisés, comme la page de filtrage par système de Nintendo Life, trient les jeux Switch 2 à venir par date de sortie.

Pour ce tutoriel, on privilégie le flux RSS du site Nintendo Insider dédié aux téléchargements européens, car il expose un format structuré (titre, lien, date de publication) directement exploitable par feedparser, sans avoir à parser du HTML fragile. C’est une différence importante: scraper une page HTML casse à la moindre refonte du site, alors qu’un flux RSS reste stable dans le temps.

Flux RSS Nintendo Insider (téléchargements Europe, mis à jour chaque semaine)
Page Nintendo Life “Upcoming Switch 2 Games”, triée par date
Page officielle Nintendo “Jeux à venir” (mensuelle, format HTML)
Annonces Nintendo Direct, publiées sous forme d’articles ponctuels

Le tracker construit ici se concentre sur la première source pour l’automatisation, et utilise les trois autres pour la vérification manuelle lors des gros annonces, comme un Nintendo Direct.

Étape 2: installer l’environnement Python du tracker

Créez un dossier dédié et isolez les dépendances dans un environnement virtuel. Cette isolation évite les conflits de versions avec d’autres projets Python présents sur la machine.

mkdir switch2-tracker && cd switch2-tracker
python3 -m venv venv
source venv/bin/activate   # sous Windows: venv\Scripts\activate
pip install feedparser requests flask

Vérifiez ensuite que les trois bibliothèques répondent correctement avant d’aller plus loin. Une erreur d’import à ce stade économise des heures de débogage plus tard.

python3 -c "import feedparser, requests, flask; print('OK:', feedparser.__version__, flask.__version__)"

Si la commande affiche deux numéros de version sans erreur, l’environnement est prêt. Sinon, relancez pip install en ciblant explicitement le module qui manque.

Étape 3: créer la base de données SQLite du catalogue

SQLite convient parfaitement à ce volume de données: quelques centaines de lignes par an, pas de concurrence d’écriture, aucun serveur à administrer. Le fichier de base vit directement dans le dossier du projet.

import sqlite3

def init_db(path="catalogue_switch2.db"):
    conn = sqlite3.connect(path)
    conn.execute("""
        CREATE TABLE IF NOT EXISTS jeux (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            titre TEXT NOT NULL,
            lien TEXT UNIQUE NOT NULL,
            date_publication TEXT,
            plateforme TEXT,
            categorie TEXT DEFAULT 'non_classe',
            vu_le TEXT NOT NULL
        )
    """)
    conn.commit()
    return conn

if __name__ == "__main__":
    init_db()
    print("Base catalogue_switch2.db prête.")

La colonne lien porte une contrainte UNIQUE: c’est elle qui empêchera le script d’insérer deux fois la même sortie lors des étapes suivantes. La colonne categorie reste vide à l’insertion, elle sera remplie automatiquement à l’étape 7.

Étape 4: récupérer le flux RSS Nintendo Download Europe

feedparser transforme un flux RSS en objets Python directement manipulables, sans aucune analyse manuelle de balises XML. La fonction suivante télécharge le flux et retourne la liste brute des entrées.

import feedparser

URL_FLUX = "https://www.nintendo-insider.com/feed/"

def recuperer_entrees(url=URL_FLUX):
    flux = feedparser.parse(url)
    if flux.bozo:
        print("Attention: flux possiblement malformé, vérifiez l'URL.")
    return flux.entries

if __name__ == "__main__":
    entrees = recuperer_entrees()
    print(f"{len(entrees)} entrées récupérées.")
    for e in entrees[:5]:
        print("-", e.title, "|", e.link)

Le flux général du site mélange toutes les actualités, pas uniquement les sorties Switch 2. L’étape de parsing qui suit filtre justement ce bruit pour ne garder que les articles pertinents, de type “Nintendo Download”.

Étape 5: parser et structurer les données de jeux

Un article “Nintendo Download” liste souvent plusieurs titres dans son corps de texte. Pour cette première version du tracker, on commence simple: chaque article devient une entrée, avec le titre de l’article comme repère, puis on affine manuellement la liste des jeux mentionnés dans le corps. Une version plus poussée irait chercher les sous-titres HTML dans le contenu complet de l’article.

from datetime import datetime, timezone

def filtrer_telechargements(entrees):
    pertinents = []
    for e in entrees:
        titre_lc = e.title.lower()
        if "nintendo download" in titre_lc or "eshop" in titre_lc:
            pertinents.append({
                "titre": e.title,
                "lien": e.link,
                "date_publication": e.get("published", ""),
                "plateforme": "Switch / Switch 2",
            })
    return pertinents

def horodatage():
    return datetime.now(timezone.utc).isoformat()

Cette structuration donne un dictionnaire par entrée, prêt à être inséré en base. Elle reste volontairement permissive sur le champ plateforme à ce stade: la distinction fine entre jeux exclusifs Switch 2 et jeux cross-plateforme arrive à l’étape 7.

Étape 6: détecter les nouveautés et éviter les doublons

C’est le cœur fonctionnel du tracker. À chaque exécution, le script doit insérer uniquement les entrées réellement nouvelles, et signaler celles-ci pour l’étape de notification. La contrainte UNIQUE posée sur la colonne lien à l’étape 3 fait le travail de déduplication, il suffit de capturer l’exception.

import sqlite3

def inserer_nouveautes(conn, jeux):
    nouveautes = []
    for jeu in jeux:
        try:
            conn.execute(
                "INSERT INTO jeux (titre, lien, date_publication, plateforme, vu_le) "
                "VALUES (?, ?, ?, ?, ?)",
                (jeu["titre"], jeu["lien"], jeu["date_publication"],
                 jeu["plateforme"], horodatage())
            )
            nouveautes.append(jeu)
        except sqlite3.IntegrityError:
            pass  # déjà présent, on ignore silencieusement
    conn.commit()
    return nouveautes

À la première exécution, toutes les entrées du flux remontent comme nouvelles: c’est normal, la base est vide. Les exécutions suivantes ne renverront que les vraies nouveautés, souvent une ou deux par semaine selon le rythme des sorties.

Étape 7: catégoriser exclusivités, rétrocompatibilité et free-to-play

La liste des jeux Switch 2 mélange plusieurs familles qu’il est utile de séparer visuellement. Un système de mots-clés simple, appliqué au titre, couvre déjà une bonne partie des cas sans recourir à un modèle de classification complexe.

REGLES_CATEGORIE = [
    ("Collection", "remaster"),
    ("Remastered", "remaster"),
    ("Gold Edition", "remaster"),
    ("Deluxe Edition", "remaster"),
    ("Definitive Edition", "remaster"),
    ("Switch 2 Edition", "upgrade_switch2"),
    ("gratuit", "free_to_play"),
    ("free", "free_to_play"),
]

def categoriser(titre):
    for motif, categorie in REGLES_CATEGORIE:
        if motif.lower() in titre.lower():
            return categorie
    return "nouveaute"

def mettre_a_jour_categories(conn):
    curseur = conn.execute("SELECT id, titre FROM jeux WHERE categorie='non_classe'")
    for id_jeu, titre in curseur.fetchall():
        categorie = categoriser(titre)
        conn.execute("UPDATE jeux SET categorie=? WHERE id=?", (categorie, id_jeu))
    conn.commit()

Avec ces règles, des titres comme KINGDOM HEARTS Collection [I–III] ou Resident Evil 4 Gold Edition tombent automatiquement dans la catégorie “remaster”, tandis qu’un jeu comme Ratatan reste classé “nouveaute” faute de mot-clé correspondant. Ajustez la liste REGLES_CATEGORIE au fil des mois, c’est un fichier de configuration vivant plutôt qu’une liste figée.

Étape 8: envoyer des alertes automatiques vers Discord

Créez un webhook depuis les paramètres d’un salon Discord (Paramètres du salon, Intégrations, Webhooks, Nouveau webhook) et copiez son URL. Le script suivant poste un message formaté pour chaque nouveauté détectée à l’étape 6.

import requests
import os

WEBHOOK_URL = os.environ.get("DISCORD_WEBHOOK_URL")

def notifier_discord(nouveautes):
    if not WEBHOOK_URL or not nouveautes:
        return
    for jeu in nouveautes:
        contenu = f"**Nouvelle sortie Switch 2 détectée**\n{jeu['titre']}\n{jeu['lien']}"
        reponse = requests.post(WEBHOOK_URL, json={"content": contenu}, timeout=10)
        if reponse.status_code >= 300:
            print("Échec de l'envoi Discord:", reponse.status_code, reponse.text)

Stocker l’URL du webhook dans une variable d’environnement plutôt que dans le code source évite de la publier par erreur si le projet termine un jour sur un dépôt Git public. La section sécurité, à l’étape 12, revient sur ce point en détail.

Étape 9: planifier l’exécution avec cron

Le tracker n’a de valeur que s’il tourne seul. Sur Linux ou macOS, cron reste l’outil le plus simple pour déclencher le script toutes les six heures, un rythme suffisant pour ne manquer aucune annonce majeure sans multiplier les requêtes inutiles vers les serveurs de Nintendo Insider.

# crontab -e, puis ajouter la ligne suivante
0 */6 * * * cd /chemin/vers/switch2-tracker && venv/bin/python main.py >> tracker.log 2>&1

Sous Windows, le Planificateur de tâches reproduit le même comportement via une tâche déclenchée toutes les six heures, qui exécute venv\Scripts\python.exe main.py. Pensez à rediriger la sortie vers un fichier journal dans les deux cas: c’est souvent le seul moyen de comprendre pourquoi une exécution a échoué pendant la nuit.

Étape 10: construire un mini tableau de bord web avec Flask

Consulter une base SQLite en ligne de commande fonctionne, mais un petit tableau de bord web rend la liste des jeux Switch 2 beaucoup plus lisible, surtout si plusieurs personnes du foyer veulent la consulter depuis leur téléphone sur le réseau local.

from flask import Flask, render_template_string
import sqlite3

app = Flask(__name__)

MODELE = """
<h1>Catalogue Switch 2</h1>
<table border="1" cellpadding="6">
  <tr><th>Titre</th><th>Catégorie</th><th>Publié le</th></tr>
  {% for jeu in jeux %}
  <tr><td>{{ jeu[0] }}</td><td>{{ jeu[1] }}</td><td>{{ jeu[2] }}</td></tr>
  {% endfor %}
</table>
"""

@app.route("/")
def accueil():
    conn = sqlite3.connect("catalogue_switch2.db")
    jeux = conn.execute(
        "SELECT titre, categorie, date_publication FROM jeux ORDER BY id DESC"
    ).fetchall()
    conn.close()
    return render_template_string(MODELE, jeux=jeux)

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000, debug=False)

Lancez python dashboard.py et ouvrez http://localhost:5000. La page affiche instantanément tout le contenu de la base, triée du plus récent au plus ancien. Gardez debug=False dès que le service tourne en dehors d’un test ponctuel: le mode debug de Flask expose un évaluateur de code arbitraire accessible depuis le réseau.

Étape 11: exporter et partager la liste des jeux Switch 2

Tout le monde n’a pas envie de lancer un serveur Flask pour consulter la liste. Un export CSV ou JSON couvre l’essentiel des usages: ouvrir le fichier dans un tableur, l’importer dans Notion, ou le partager tel quel dans un groupe de discussion.

import csv
import json
import sqlite3

def exporter(conn, format="csv", chemin="catalogue_export"):
    lignes = conn.execute(
        "SELECT titre, lien, date_publication, categorie FROM jeux ORDER BY id DESC"
    ).fetchall()
    if format == "csv":
        with open(f"{chemin}.csv", "w", newline="", encoding="utf-8") as f:
            ecrivain = csv.writer(f)
            ecrivain.writerow(["titre", "lien", "date_publication", "categorie"])
            ecrivain.writerows(lignes)
    elif format == "json":
        donnees = [
            {"titre": t, "lien": l, "date_publication": d, "categorie": c}
            for t, l, d, c in lignes
        ]
        with open(f"{chemin}.json", "w", encoding="utf-8") as f:
            json.dump(donnees, f, ensure_ascii=False, indent=2)

L’export JSON a un avantage discret: il se branche directement sur un script tiers (un bot Discord plus élaboré, une page statique Jekyll ou Hugo, un widget personnel) sans retoucher la base SQLite elle-même.

Étape 12: sécuriser le tracker et respecter les règles de Nintendo

Un projet qui tourne en permanence sur un flux externe mérite trois précautions simples, souvent négligées dans les tutoriels rapides.

Respectez un intervalle raisonnable entre deux appels au flux RSS (six heures suffisent largement, une exécution par minute s’apparente à de l’abus de service).
Ne stockez jamais l’URL du webhook Discord ni d’éventuels identifiants dans le code versionné: utilisez des variables d’environnement ou un fichier .env exclu du dépôt Git via .gitignore.
Limitez le tableau de bord Flask au réseau local (host="127.0.0.1") si vous n’avez pas mis en place d’authentification, plutôt que de l’exposer directement sur internet.
Le flux RSS et les pages consultées restent des sources publiques en lecture seule: le tracker ne contourne aucune mesure de protection, ne scrape pas de contenu payant et n’automatise aucune action sur un compte Nintendo.

Ces règles paraissent évidentes une fois énoncées, mais elles évitent les deux incidents les plus courants sur ce genre de petit projet personnel: la fuite d’un webhook dans un commit public, et le signalement d’un serveur personnel comme source de trafic anormal.

Étape 13: maintenir le projet sur le long terme

Un flux RSS peut changer d’adresse, un site peut migrer son hébergement, une page peut passer derrière un système anti-robot. Prévoyez une vérification manuelle mensuelle: ouvrez le fichier tracker.log généré par cron et cherchez les lignes d’erreur. Si le flux ne renvoie plus rien pendant plusieurs jours, comparez-le avec la page officielle Nintendo des jeux à venir pour confirmer que le problème vient bien de la source et non du script.

Pensez aussi à archiver régulièrement le fichier catalogue_switch2.db: une simple copie datée dans un dossier de sauvegarde suffit, et elle permet de reconstruire l’historique complet des sorties Switch 2 si la base venait à se corrompre.

Mettez également à jour, deux ou trois fois par an, le dictionnaire REGLES_CATEGORIE défini à l’étape 7. Les conventions de nommage évoluent: un éditeur qui utilisait “Gold Edition” en 2026 peut basculer vers “Ultimate Edition” l’année suivante pour un jeu similaire, et le script continuera de classer ce nouveau titre en “nouveaute” par défaut tant que la règle correspondante n’aura pas été ajoutée. Ce léger entretien manuel, quelques minutes tous les trimestres, maintient la pertinence du classement automatique sans nécessiter de refonte du code.

Sorties marquantes de la liste des jeux Switch 2 en octobre 2026

Pour tester le tracker avec des données réelles, voici un échantillon de sorties confirmées en octobre 2026, directement vérifiable via les flux officiels mentionnés à l’étape 1.

Jeu	Date de sortie	Type
KINGDOM HEARTS Collection [I–III]	8 octobre 2026	Remaster / collection
Order of the Sinking Star	8 octobre 2026	Nouveauté
Dragon’s Dogma 2: Dark Arisen	9 octobre 2026	Portage
Ratatan	14 octobre 2026	Nouveauté
Resident Evil 2 Deluxe Edition	16 octobre 2026	Remaster
Resident Evil 3	16 octobre 2026	Portage
Resident Evil 4 Gold Edition	16 octobre 2026	Remaster
Nintendo Switch Sports Resort	22 octobre 2026 (annoncé)	Nouveauté
Call of Duty: Modern Warfare 4	23 octobre 2026 (annoncé)	Portage multiplateforme
Minecraft	27 octobre 2026 (annoncé)	Portage
Hello Kitty Party Land	29 octobre 2026 (annoncé)	Exclusivité Switch / Switch 2

Ce tableau donne aussi un aperçu de ce qu’un Nintendo Direct peut injecter d’un coup dans le catalogue: la même session a confirmé une nouvelle version de The Legend of Zelda: Ocarina of Time sur Switch 2, ainsi qu’un cinquième chapitre pour DELTARUNE, livré sous forme de mise à jour gratuite plutôt que de jeu payant séparé. Un tracker bien réglé capture ce genre d’annonce dès la publication de l’article correspondant, sans attendre le lendemain.

Pièges courants à éviter

Cinq erreurs reviennent systématiquement chez les personnes qui montent ce type de projet pour la première fois.

Scraper le HTML plutôt qu’utiliser le flux RSS. Le HTML d’une page change à chaque refonte graphique, ce qui casse le script sans prévenir. Le RSS, lui, respecte un format stable depuis des années.
Oublier la contrainte UNIQUE sur la colonne lien. Sans elle, chaque exécution du script réinsère les mêmes jeux, et la base gonfle de doublons en quelques semaines.
Interroger le flux trop souvent. Une exécution toutes les minutes n’apporte rien puisque Nintendo Insider ne publie pas plus d’un article par jour en moyenne, et ce rythme ressemble à un abus vu du serveur distant.
Coder le webhook Discord en dur dans le script. Si le dépôt finit un jour sur GitHub, même en privé temporairement, l’URL se retrouve exposée dans l’historique Git pour toujours.
Confondre rétrocompatibilité et mise à niveau payante. Un jeu Switch 1 qui tourne sur Switch 2 n’est pas forcément optimisé pour la nouvelle puce: certains titres nécessitent un pack d’amélioration distinct, que le script doit catégoriser à part plutôt que de le confondre avec une sortie native.

Dépannage: 8 problèmes fréquents et leurs solutions

Voici les blocages les plus souvent rencontrés en testant ce tracker, avec la correction associée.

feedparser renvoie une liste vide. Vérifiez d’abord l’URL dans un navigateur. Si la page charge normalement mais que flux.entries reste vide, le site a probablement changé l’adresse de son flux RSS: cherchez la nouvelle URL dans le code source de la page, généralement dans une balise link rel="alternate".
sqlite3.OperationalError: database is locked. Le dashboard Flask et le script de collecte accèdent à la base en même temps. Fermez les connexions avec conn.close() dès que possible, ou ouvrez la base en mode WAL pour autoriser les lectures concurrentes.
Le webhook Discord renvoie un code 401. L’URL du webhook a été régénérée ou supprimée côté Discord. Recréez-en une nouvelle depuis les paramètres du salon et mettez à jour la variable d’environnement.
Le webhook Discord renvoie un code 429. Discord limite le nombre de messages par minute. Regroupez plusieurs nouveautés dans un seul message plutôt que d’envoyer un appel par jeu détecté.
cron ne déclenche jamais le script. Le chemin vers l’environnement virtuel dans la ligne crontab est souvent relatif par erreur. Utilisez systématiquement des chemins absolus, et testez la commande manuellement dans un terminal avant de l’ajouter à crontab.
Le script fonctionne en local mais pas via cron. cron exécute les tâches avec un environnement minimal, sans les variables définies dans votre .bashrc. Chargez les variables d’environnement explicitement en tête de script, par exemple via python-dotenv.
Le tableau de bord Flask affiche une page blanche. Vérifiez que le fichier catalogue_switch2.db se trouve dans le même dossier que le script lancé, SQLite travaille avec des chemins relatifs par défaut.
Les dates de publication apparaissent dans des formats incohérents. Les flux RSS mélangent parfois les formats de date selon l’article. Passez chaque date récupérée dans dateutil.parser.parse() avant de l’enregistrer, plutôt que de la stocker telle quelle.

Astuces avancées pour aller plus loin

Une fois le tracker stable, plusieurs extensions valent le détour. La première consiste à croiser automatiquement la liste des jeux Switch 2 avec un second flux dédié aux promotions de l’eShop, pour recevoir une alerte quand un jeu suivi passe en réduction. La seconde ajoute un second canal Discord réservé aux seules exclusivités Switch 2, en filtrant sur la catégorie “nouveaute” définie à l’étape 7, pour séparer le signal des remasters qui intéressent moins certains joueurs.

Une troisième piste transforme le tableau de bord Flask en flux RSS personnel, généré avec la bibliothèque feedgen, que vous pouvez ensuite ajouter à votre propre lecteur RSS. Cela ferme la boucle: les données circulent depuis un flux public, passent par votre base de données, et ressortent sous une forme que n’importe quel agrégateur personnel sait lire, sans jamais dépendre d’une application tierce.

Enfin, pour les foyers qui possèdent plusieurs consoles, une colonne supplémentaire dans la table jeux peut indiquer si un titre est aussi disponible sur Switch première génération. Cette distinction aide à prioriser les achats: un jeu listé uniquement en “nouveaute Switch 2” justifie davantage une mise à niveau matérielle qu’un simple portage disponible partout ailleurs. Une dernière extension, plus ambitieuse, consisterait à brancher un second worker qui interroge directement les prix affichés sur l’eShop pour chaque identifiant de jeu stocké, afin de bâtir un historique de prix maison et de repérer les baisses significatives sans dépendre d’un site tiers spécialisé dans les promos. Pour comparer concrètement l’écart matériel entre les deux consoles, la comparaison détaillée entre la Switch et la Switch 2 entre dans le détail du GPU et des prix de lancement.

Le projet complet: structure finale du tracker

Assemblé, le projet tient dans une arborescence simple, facile à versionner avec Git si vous voulez suivre son évolution dans le temps.

switch2-tracker/
├── venv/
├── .env                  # DISCORD_WEBHOOK_URL (jamais versionné)
├── .gitignore
├── db.py                 # init_db()
├── collecte.py           # recuperer_entrees(), filtrer_telechargements()
├── categorisation.py     # categoriser(), mettre_a_jour_categories()
├── notifications.py      # notifier_discord()
├── export.py             # exporter()
├── dashboard.py          # application Flask
├── main.py               # orchestre les étapes 4 à 8, appelé par cron
├── catalogue_switch2.db  # généré automatiquement
└── tracker.log           # généré par cron

Le fichier main.py reste volontairement court: il importe chaque module et enchaîne les fonctions dans l’ordre logique, collecte puis filtrage puis insertion puis catégorisation puis notification. C’est ce fichier que cron appelle toutes les six heures, et c’est aussi le seul point d’entrée à tester manuellement quand quelque chose ne fonctionne pas comme prévu.

from db import init_db
from collecte import recuperer_entrees, filtrer_telechargements
from categorisation import mettre_a_jour_categories
from notifications import notifier_discord

def inserer_nouveautes(conn, jeux):
    # voir étape 6 pour le détail de cette fonction
    ...

def main():
    conn = init_db()
    entrees = recuperer_entrees()
    jeux = filtrer_telechargements(entrees)
    nouveautes = inserer_nouveautes(conn, jeux)
    mettre_a_jour_categories(conn)
    notifier_discord(nouveautes)
    print(f"{len(nouveautes)} nouvelle(s) sortie(s) détectée(s).")
    conn.close()

if __name__ == "__main__":
    main()

Exécutez python main.py une première fois à la main. La sortie attendue ressemble à ceci lors d’un premier lancement sur une base vide.

$ python main.py
12 nouvelle(s) sortie(s) détectée(s).

Relancez la commande immédiatement après: le compteur doit cette fois afficher zéro, preuve que la déduplication fonctionne correctement.

$ python main.py
0 nouvelle(s) sortie(s) détectée(s).

Classer un jeu: exclusivité, rétrocompatibilité ou mise à niveau

Comprendre la différence entre ces trois catégories évite bien des achats décevants. Une exclusivité Switch 2 ne tourne que sur la nouvelle console, point final. Une rétrocompatibilité désigne un jeu Switch 1 qui fonctionne sans modification sur Switch 2, souvent avec de meilleurs temps de chargement grâce à la puce plus rapide. Une mise à niveau, elle, correspond à un jeu Switch 1 existant auquel Nintendo ou l’éditeur ajoute un correctif gratuit ou payant pour exploiter la nouvelle machine, sans pour autant en faire un jeu Switch 2 à part entière dans les boutiques. Le dossier sur la hausse de prix de la Switch 2 détaille d’ailleurs comment ces différences de catégorie influencent le budget jeux des joueurs.

Catégorie	Fonctionne sur Switch 1	Fonctionne sur Switch 2	Exemple cité dans cet article
Exclusivité Switch 2	Non	Oui	Ratatan
Rétrocompatible sans changement	Oui	Oui	Octopath Traveler
Remaster / nouvelle édition	Variable selon le titre	Oui	KINGDOM HEARTS Collection [I–III]
Mise à jour gratuite d’un jeu existant	Oui	Oui, avec contenu additionnel	DELTARUNE Chapter 5

Le script de catégorisation de l’étape 7 ne couvre que les cas les plus visibles, basés sur des mots-clés dans le titre. Pour les cas ambigus, comme un jeu qui porte le même nom sur les deux consoles sans suffixe distinctif, une vérification manuelle reste nécessaire avant de faire confiance à l’étiquette automatique. Un comparatif comme celui entre la Steam Deck et la Switch 2 montre d’ailleurs que le choix de plateforme pèse autant que la liste de jeux elle-même dans la décision d’achat.

Un autre repère utile vient des résultats financiers de Nintendo: le dernier bilan trimestriel, détaillé dans notre analyse des résultats de Nintendo, donne une idée de la vitesse à laquelle le catalogue Switch 2 doit grossir pour soutenir la demande. Pour les joueurs qui veulent comparer l’offre d’abonnement associée, la page sur Nintendo Switch Online face à Game Pass complète bien ce tutoriel, puisque l’abonnement conditionne l’accès à une partie du catalogue rétrocompatible repéré par le tracker.

Adapter le tracker aux spécificités françaises et européennes

Le eShop européen n’applique pas toujours les mêmes dates de sortie que l’Amérique du Nord ou le Japon, et les prix affichés en euros diffèrent parfois de la conversion directe du dollar. Un titre annoncé à 59,99 $ aux États-Unis sort fréquemment à 69,99 € en France, un écart qui dépasse largement le simple taux de change. Pour un tracker destiné à un public français, il vaut mieux filtrer le flux RSS sur sa variante européenne plutôt que sur la version américaine du même média, afin d’obtenir des dates de sortie et des prix réellement applicables localement.

Un autre détail touche la langue des jeux. Certains titres sortent en version intégralement doublée en français, d’autres restent uniquement sous-titrés, et cette information figure rarement dans le titre brut capté par le flux RSS. Pour la restituer, ajoutez une colonne localisation à la table jeux et remplissez-la manuellement après consultation de la fiche produit officielle, le temps qu’un repère textuel fiable apparaisse systématiquement dans les flux.

conn.execute("ALTER TABLE jeux ADD COLUMN localisation TEXT DEFAULT 'a_verifier'")
conn.execute(
    "UPDATE jeux SET localisation='vf_integrale' WHERE titre LIKE '%Ratatan%'"
)
conn.commit()

Enfin, gardez à l’esprit le décalage horaire entre la publication américaine d’une annonce et sa reprise sur les sites européens. Un Nintendo Direct diffusé en fin de journée aux États-Unis arrive souvent sur les flux RSS européens avec plusieurs heures de retard, le temps que les rédactions locales publient leur propre article. Si votre tracker tourne toutes les six heures comme recommandé à l’étape 9, ce délai ne pose pas de problème concret, mais il explique pourquoi un ami qui suit les comptes américains sur les réseaux sociaux reçoit parfois l’information avant votre webhook Discord.

Foire aux questions

Faut-il un compte développeur Nintendo pour accéder aux données de sorties?
Non. Ce tutoriel repose entièrement sur des flux RSS et des pages publiques déjà accessibles sans authentification. Aucune clé d’API Nintendo officielle n’existe pour le grand public.

Le flux RSS de Nintendo Insider est-il la seule source fiable?
Non, mais c’est la plus simple à automatiser. La page officielle Nintendo des jeux à venir et la page de filtrage Nintendo Life restent utiles pour une vérification croisée, notamment lors des annonces faites en Nintendo Direct.

Un jeu Switch 1 fonctionne-t-il automatiquement sur Switch 2?
Dans la grande majorité des cas oui, sans manipulation particulière. Certains titres bénéficient en plus d’un correctif de performance distinct, gratuit ou payant selon l’éditeur, qui améliore la fluidité sans changer le jeu de base.

Combien de temps prend la mise en place complète du tracker?
Comptez environ 90 minutes pour les treize étapes si l’environnement Python est déjà installé, et un peu plus si vous devez d’abord configurer Python et un éditeur de code.

Peut-on héberger le tableau de bord Flask en permanence sur internet?
Techniquement oui, mais ce n’est pas l’objectif de ce projet personnel. Si vous le faites, ajoutez au minimum une authentification et un certificat TLS, le code fourni ici reste pensé pour un usage sur réseau local. Un reverse proxy comme Caddy ou Nginx, placé devant Flask, simplifie grandement l’ajout de ce certificat sans toucher au code Python lui-même.

Que faire si Nintendo change le format de son flux RSS?
Les flux RSS évoluent rarement en profondeur, mais si feedparser commence à renvoyer des champs vides, inspectez le flux brut avec requests.get(url).text pour repérer le nouveau nom des balises, puis ajustez la fonction filtrer_telechargements() en conséquence.

Le tracker fonctionne-t-il aussi pour suivre uniquement les jeux Switch première génération?
Oui, la structure reste identique. Il suffit d’ajuster les règles de filtrage de l’étape 5 pour exclure les mentions explicites de Switch 2, et de modifier le titre du tableau de bord en conséquence.

Comment migrer les données vers une autre base, comme PostgreSQL?
Exportez d’abord l’intégralité de la table en JSON via la fonction exporter() de l’étape 11, puis réimportez ce fichier dans la nouvelle base avec un script d’import adapté. SQLite reste largement suffisant pour ce volume de données, la migration n’a d’intérêt que si vous comptez partager la base entre plusieurs machines simultanément.

Ce tracker coûte-t-il quelque chose à faire tourner?
Non, si vous l’hébergez sur une machine déjà allumée (ordinateur personnel, NAS, Raspberry Pi). Python, SQLite, Flask et les webhooks Discord sont tous gratuits, et le script consomme trop peu de ressources réseau pour justifier un hébergement payant dédié.