Comment utiliser Whisper AI pour transcrire des audios sur VPS

Podcasts, webinaires, interviews, réunions ou vidéos : dès que vous produisez régulièrement du contenu audio, la transcription automatique peut faire gagner un temps précieux. ✨Elle permet notamment de créer des sous-titres, préparer des comptes-rendus, améliorer l’accessibilité d’une vidéo ou transformer un podcast en contenu textuel destiné au référencement. Les services de transcription dans le cloud sont pratiques, mais ils impliquent généralement une facturation liée à l’utilisation et l’envoi des fichiers audio vers une infrastructure tierce.💥

✨Une autre approche consiste à installer Whisper AI directement sur son propre serveur. Le traitement peut alors être réalisé localement, sans transmettre les enregistrements à une API de transcription externe. Avec un VPS, il devient ainsi possible de mettre en place une solution de transcription audio open source, automatisable et entièrement contrôlée depuis son environnement Linux.

Objectif

Dans ce tutoriel, nous allons voir comment installer Whisper AI sur un VPS et l’utiliser pour transformer automatiquement des fichiers audio ou vidéo en texte. Whisper est un modèle de reconnaissance automatique de la parole, ou ASR (Automatic Speech Recognition), publié par OpenAI sous licence MIT. ⚡Nous nous concentrerons sur deux implémentations particulièrement intéressantes pour un serveur fonctionnant principalement avec son processeur : faster-whisper, basé sur CTranslate2, et whisper.cpp, une implémentation C/C++ légère pouvant fonctionner sans environnement Python. ✨À la fin du tutoriel, votre VPS KVM LWS pourra transcrire un fichier en français, produire une transcription texte et générer des sous-titres SRT. Nous verrons également comment traiter plusieurs fichiers automatiquement et surveiller les ressources consommées pendant l’inférence.

Pré-requis

Avant de commencer l’installation de Whisper AI sur votre VPS, assurez-vous de disposer des éléments suivants :

• un VPS KVM LWS sous Ubuntu 22.04/24.04 ou Debian avec un accès administrateur via SSH ;
• au moins 4 Go de RAM pour commencer confortablement avec des modèles légers ou intermédiaires ; davantage de mémoire est conseillé pour les modèles les plus volumineux ;
• une installation fonctionnelle de Python 3 si vous choisissez faster-whisper. À la date où nous rédigeons ce tutoriel, la documentation officielle de faster-whisper exige Python 3.9 ou supérieur.
• l’outil ffmpeg, notamment utile pour convertir les fichiers audio avant leur traitement avec whisper.cpp ;
• quelques connaissances de base des commandes Linux : connexion SSH, navigation entre les répertoires et installation de paquets.

Les VPS utilisés dans ce tutoriel ne nécessitent pas de GPU dédié. Nous privilégierons des configurations adaptées à l’inférence CPU et éviterons de reprendre des performances mesurées sur GPU comme référence pour un VPS.

Qu’est-ce que Whisper : présentation factuelle

Whisper est un système de reconnaissance automatique de la parole développé par OpenAI et publié en open source en septembre 2022. Il repose sur une architecture Transformer capable d’effectuer plusieurs tâches liées au traitement de la voix, notamment la transcription multilingue, l’identification de la langue et la traduction de la parole vers l’anglais. Le modèle original a été entraîné sur 680 000 heures de données audio et de transcriptions collectées sur Internet.

Le code de référence est distribué sous licence MIT, ce qui permet notamment une utilisation commerciale. Lorsqu’il est exécuté localement, Whisper ne nécessite pas de facturation à la minute : le coût correspond principalement aux ressources du serveur utilisé pour effectuer les calculs.

Pour une entreprise ou un créateur de contenu, l’auto-hébergement présente également un intérêt important : le fichier audio peut être traité directement sur le VPS, sans être envoyé à une API de transcription tierce.

Critère	Whisper auto-hébergé	API de transcription cloud
Facturation de la transcription	Pas de coût à la minute lié au modèle	Généralement liée au volume traité
Emplacement des audios	Traitement possible directement sur le serveur	Fichiers transmis au fournisseur
Fonctionnement hors API externe	Oui, une fois le modèle disponible localement	Non
Contrôle de l’environnement	Élevé : serveur, runtime et modèle sont configurables	Dépend du fournisseur
Automatisation	Scripts Python, Bash, Cron, n8n, etc.	API et outils proposés par le service

Quels modèles Whisper sont disponibles ?

Le dépôt officiel d’OpenAI référence actuellement six tailles principales : tiny, base, small, medium, large et turbo. Le choix du modèle influence directement la consommation de ressources et la qualité attendue de la transcription. OpenAI précise également que les vitesses relatives publiées dans sa documentation ont été mesurées sur GPU A100 : elles ne doivent donc pas être transposées à un VPS fonctionnant uniquement sur CPU.

Modèle	Paramètres	Mémoire indicative avec whisper.cpp*	Usage conseillé sur VPS
tiny	39 M	~273 Mo	Tests rapides et ressources très limitées
base	74 M	~388 Mo	Premiers essais de transcription
small	244 M	~852 Mo	Bon point de départ pour un usage courant
medium	769 M	~2,1 Go	Plus exigeant en CPU et en mémoire
large / large-v3	1 550 M	~3,9 Go pour la famille large	À réserver aux VPS disposant de davantage de ressources
turbo	809 M	Variable selon le runtime et la quantification	Compromis intéressant à évaluer selon le serveur

Les valeurs de mémoire indiquées proviennent de la documentation actuelle de whisper.cpp pour ses modèles GGML et ne doivent pas être assimilées aux besoins exacts de faster-whisper ou de l’implémentation PyTorch officielle.

Le modèle turbo est une version optimisée de large-v3 utilisant 809 millions de paramètres. OpenAI le présente comme plus rapide tout en limitant la dégradation de précision par rapport à large-v3. Il est toujours référencé dans le dépôt officiel en août 2026, et aucune annonce officielle d’un modèle « Whisper v4 » n’apparaît actuellement dans les annonces du projet.

Dans un contexte VPS sans GPU, la taille du modèle n’est cependant qu’une partie de l’équation. Le runtime utilisé pour exécuter Whisper joue lui aussi un rôle déterminant. C’est précisément ce que nous allons comparer dans la section suivante.

Choisir le bon runtime pour un VPS sans GPU

Installer Whisper AI ne consiste pas seulement à choisir un modèle comme small, medium ou turbo. Il faut également sélectionner le runtime, c’est-à-dire l’implémentation qui chargera le modèle et réalisera concrètement la transcription.

Sur un VPS sans GPU dédié, ce choix est particulièrement important. Les trois principales solutions n’ont pas les mêmes dépendances ni les mêmes besoins.

Runtime	Fonctionnement	Adapté à un VPS CPU ?	À privilégier si…
openai-whisper	Implémentation de référence en Python utilisant notamment PyTorch	Oui, mais ce n’est pas l’option privilégiée dans ce tutoriel	Vous souhaitez utiliser directement l’implémentation officielle
faster-whisper	Réimplémentation de Whisper avec CTranslate2	Oui	Vous souhaitez travailler en Python et automatiser facilement vos transcriptions
whisper.cpp	Implémentation légère en C/C++, avec prise en charge de l’inférence CPU	Oui	Vous recherchez une solution légère sans environnement Python pour l’exécution

L’implémentation officielle openai-whisper repose notamment sur Python et PyTorch. Elle reste utile comme version de référence, mais nous utiliserons plutôt des runtimes spécifiquement intéressants pour un environnement serveur fonctionnant sur CPU.

faster-whisper réimplémente Whisper avec le moteur d’inférence CTranslate2. Il prend en charge la quantification 8 bits, y compris sur CPU, ce qui permet notamment de réduire l’empreinte mémoire dans certaines configurations. Son principal avantage dans ce tutoriel est de conserver un environnement Python, pratique pour intégrer ensuite la transcription dans un script, une application ou un workflow automatisé.

whisper.cpp, de son côté, fournit une implémentation en C/C++ et prend explicitement en charge l’inférence uniquement sur CPU. Le projet fonctionne sous Linux et propose également la quantification des modèles. Il constitue donc une alternative particulièrement intéressante lorsqu’on souhaite limiter les dépendances logicielles liées à Python.

Dans la suite de ce tutoriel, nous allons installer les deux solutions. Vous pourrez ainsi choisir faster-whisper pour sa souplesse côté Python ou whisper.cpp pour son approche légère orientée CPU.

Créer un snapshot LWS avant l’installation

Avant d’installer des dépendances Python ou de compiler whisper.cpp, il est recommandé de créer un snapshot de votre VPS. Celui-ci capture l’état du serveur à un instant donné et peut faciliter un retour à une configuration précédente en cas de problème pendant vos manipulations.

Depuis votre espace de gestion LWS :

• accédez au VPS concerné ;
• ouvrez la rubrique “Snapshots” ;

• renseignez un nom permettant d’identifier facilement le snapshot ;
• cliquez sur le bouton “Créer le snapshot”.

La gamme VPS KVM LWS permet actuellement de conserver jusqu’à 3 snapshots simultanés gratuits. Cette précaution est particulièrement utile avant une installation, une compilation ou une modification importante de l’environnement logiciel.

Un snapshot constitue toutefois un point de restauration et ne doit pas remplacer une véritable stratégie de sauvegarde de vos données.

Méthode 1 : Installer faster-whisper (Python)

Commençons par faster-whisper, la méthode la plus adaptée si vous souhaitez manipuler les transcriptions depuis Python. Nous allons isoler son installation dans un environnement virtuel, puis créer un premier script capable de transcrire automatiquement un fichier audio en français.

1. Installer les dépendances système

Connectez-vous à votre VPS en SSH avec un compte disposant des droits nécessaires, puis mettez à jour l’index des paquets :

apt update

Installez ensuite Python, pip, le module permettant de créer des environnements virtuels ainsi que ffmpeg :

apt install python3 python3-pip python3-venv ffmpeg -y

La documentation actuelle de faster-whisper précise que le runtime décode lui-même les fichiers audio avec PyAV, qui embarque les bibliothèques FFmpeg nécessaires. L’installation de la commande système ffmpeg n’est donc pas indispensable à faster-whisper seul. Nous l’installons néanmoins dès maintenant, car elle sera utile pour convertir les fichiers audio, notamment lors de la méthode avec whisper.cpp.

2. Vérifier la version de Python

Avant d’installer faster-whisper, vérifiez la version de Python 3 disponible sur votre VPS :

python3 --version

La documentation actuelle de faster-whisper exige Python 3.9 ou une version supérieure. Si la commande renvoie une version compatible, vous pouvez poursuivre directement l’installation.

Pour connaître également la version de pip, utilisez :

python3 -m pip --version

L’utilisation de python3 -m pip permet de s’assurer que le gestionnaire de paquets appelé correspond bien à l’installation de Python utilisée sur le VPS.

3. Créer un environnement virtuel (bonne pratique)

Il est fortement recommandé d’installer faster-whisper dans un environnement virtuel Python plutôt que directement dans l’environnement système du VPS. Cette méthode permet d’isoler ses bibliothèques et leurs versions des autres applications Python installées sur le serveur.

Créez un environnement appelé whisper-env :

python3 -m venv whisper-env

Activez-le ensuite :

source whisper-env/bin/activate

Une fois l’environnement activé, le début de votre invite de commande devrait généralement afficher son nom :

(whisper-env) root@vps:~#

Vous pouvez également vérifier quel interpréteur Python est utilisé :

which python

Le chemin retourné doit pointer vers le répertoire whisper-env.

Avant d’installer faster-whisper, vous pouvez mettre à jour pip dans cet environnement :

python -m pip install --upgrade pip

À partir de maintenant, les dépendances installées resteront isolées dans cet environnement virtuel. Lors d’une future connexion SSH, pensez donc à le réactiver avec :

source whisper-env/bin/activate

4. Installer faster-whisper

Une fois l’environnement virtuel actif, installez faster-whisper depuis PyPI :

python -m pip install faster-whisper

Il s’agit de la méthode d’installation actuellement recommandée. faster-whisper utilise CTranslate2 comme moteur d’inférence et prend en charge la quantification en INT8 sur CPU, configuration que nous allons utiliser sur notre VPS.

Une fois l’installation terminée, vous pouvez vérifier que le paquet est bien présent :

python -m pip show faster-whisper

La commande doit notamment afficher son nom et la version installée.

À ce stade, aucun modèle Whisper n’a nécessairement encore été téléchargé. Lorsque nous indiquerons une taille de modèle à WhisperModel, faster-whisper récupérera automatiquement le modèle CTranslate2 correspondant depuis Hugging Face Hub s’il n’est pas déjà disponible localement.

5. Premier test de transcription

Nous pouvons maintenant effectuer notre première transcription audio avec Whisper AI.

Pour commencer, placez un fichier appelé audio.mp3 dans votre répertoire de travail. Vous pouvez vérifier sa présence avec :

ls -lh audio.mp3

Créez ensuite un fichier Python nommé transcrire.py :

nano transcrire.py

Ajoutez le code suivant :

from faster_whisper import WhisperModel

model_size = "small"

model = WhisperModel(
    model_size,
    device="cpu",
    compute_type="int8"
)

segments, info = model.transcribe(
    "audio.mp3",
    beam_size=5
)

print(
    f"Langue détectée : {info.language} "
    f"(confiance : {info.language_probability:.2f})"
)

for segment in segments:
    print(
        f"[{segment.start:.2f}s -> {segment.end:.2f}s] "
        f"{segment.text}"
    )

Nous utilisons ici le modèle small, qui constitue un point de départ raisonnable pour tester l’installation avant d’expérimenter avec des modèles plus exigeants.

Le paramètre :

device="cpu"

indique explicitement que l’inférence doit être effectuée avec le processeur du VPS, tandis que :

compute_type="int8"

active le calcul INT8. Cette configuration CPU/INT8 est directement documentée par faster-whisper.

Dans cet exemple, nous ne renseignons volontairement pas language="fr". Whisper peut ainsi effectuer la détection de langue, ce qui nous permet de vérifier que le fichier français est correctement identifié.

Si vous savez que tous vos fichiers seront en français, vous pourrez ensuite imposer cette langue :

segments, info = model.transcribe(
    "audio.mp3",
    language="fr"
)

Enregistrez le fichier avec Ctrl + O, validez avec Entrée, puis quittez Nano avec Ctrl + X.

Lancez maintenant le script :

python transcrire.py

Lors du premier lancement, faster-whisper télécharge automatiquement le modèle correspondant à la taille indiquée lorsque celui-ci n’est pas encore disponible localement. Une connexion Internet est donc nécessaire pour cette première récupération.

Une fois le modèle chargé, le terminal devrait afficher la langue identifiée puis les différents segments de transcription avec leurs timestamps :

Langue détectée : fr (confiance : 0.99)
[0.00s -> 4.28s] Bonjour et bienvenue dans cet épisode.
[4.28s -> 8.74s] Aujourd'hui, nous allons parler d'hébergement web.

Les valeurs ci-dessus sont uniquement un exemple de format de sortie : la confiance, les timestamps et le texte dépendront évidemment de votre propre enregistrement.

Un détail important concerne le fonctionnement de faster-whisper : l’objet segments retourné par model.transcribe() est un générateur Python. La transcription est réellement exécutée lorsque ce générateur est parcouru, ce que réalise ici la boucle for segment in segments.

Méthode 2 : Installer whisper.cpp (C/C++, léger)

La deuxième méthode repose sur whisper.cpp, une implémentation de Whisper en C/C++ particulièrement intéressante pour un serveur fonctionnant principalement sur CPU. Le projet prend en charge Linux et fournit un exécutable en ligne de commande, whisper-cli, permettant d’effectuer des transcriptions sans avoir à maintenir un environnement Python pour l’exécution.

Cette solution convient donc bien à un VPS aux ressources limitées, mais aussi aux utilisateurs qui souhaitent intégrer la transcription dans des scripts Bash ou d’autres outils système.

Contrairement à la méthode avec faster-whisper, nous allons ici compiler le programme directement sur le VPS, puis télécharger séparément un modèle Whisper converti au format GGML.

1. Installer les outils de compilation

Commencez par installer les paquets nécessaires à la récupération et à la compilation de whisper.cpp :

apt update

Puis :

apt install build-essential cmake git ffmpeg -y

Ces différents outils ont chacun un rôle précis :

• build-essential fournit notamment le compilateur et les outils nécessaires à la compilation sous Linux ;
• cmake permet de configurer et construire la version actuelle de whisper.cpp ;
• git sert à récupérer le code source depuis son dépôt ;
• ffmpeg nous permettra de convertir les fichiers audio dans un format compatible avec la procédure utilisée dans ce tutoriel.

La documentation actuelle de whisper.cpp utilise CMake pour construire whisper-cli. Les anciennes procédures basées uniquement sur des commandes make ne doivent donc pas être utilisées comme méthode principale d’installation.

Vous pouvez vérifier que les principaux outils sont disponibles avec :

git --version
cmake --version
gcc --version
ffmpeg -version

Il n’est pas nécessaire d’installer CUDA pour suivre ce tutoriel. Nous compilons ici une version destinée à fonctionner avec le CPU du VPS.

2. Cloner et compiler whisper.cpp

Placez-vous dans le répertoire dans lequel vous souhaitez installer le programme, puis clonez le dépôt officiel :

git clone https://github.com/ggml-org/whisper.cpp.git

Accédez ensuite au dossier créé :

cd whisper.cpp

Configurez le projet avec CMake :

cmake -B build

Puis lancez la compilation :

cmake --build build -j --config Release

Cette procédure correspond au Quick Start actuel du projet whisper.cpp. Elle construit notamment l’exécutable whisper-cli, que nous utiliserons ensuite pour lancer nos transcriptions.

L’option -j permet à l’outil de compilation de paralléliser les tâches lorsque cela est possible. Comme cette opération peut solliciter plusieurs cœurs du serveur, il est normal d’observer temporairement une hausse de la charge CPU pendant la compilation.

Une fois l’opération terminée, vérifiez que l’exécutable a correctement été généré :

ls -lh build/bin/whisper-cli

Vous pouvez également afficher son aide :

./build/bin/whisper-cli -h

Si cette commande affiche les différentes options disponibles, whisper.cpp est correctement compilé.

À noter que le projet propose également des raccourcis tels que :

make -j small

Cependant, cette commande ne se contente pas de télécharger le modèle : le Makefile actuel télécharge le modèle demandé, lance la construction puis exécute celui-ci sur les fichiers d’exemple présents dans le projet. Pour un tutoriel plus clair et plus contrôlé, nous séparons donc compilation, téléchargement du modèle et transcription.

3. Télécharger un modèle

whisper.cpp n’utilise pas directement les fichiers PyTorch distribués par OpenAI. Il charge des modèles convertis dans un format GGML adapté à l’implémentation C/C++. Le projet fournit un script permettant de télécharger directement ces modèles préconvertis.

Pour commencer avec le modèle small, exécutez depuis le répertoire whisper.cpp :

sh ./models/download-ggml-model.sh small

Le fichier est alors enregistré dans le dossier models. Vous pouvez vérifier sa présence avec :

ls -lh models/ggml-small.bin

Au moment de la rédaction, whisper.cpp propose notamment les modèles multilingues suivants :

tiny
base
small
medium
large-v1
large-v2
large-v3
large-v3-turbo

Le modèle large-v3-turbo est bien le nom actuellement utilisé par whisper.cpp pour la variante Turbo. Le projet propose aussi plusieurs modèles quantifiés, par exemple large-v3-turbo-q5_0, dont les fichiers occupent moins d’espace disque et nécessitent moins de mémoire que leur équivalent non quantifié.

Pour une transcription en français, choisissez un modèle multilingue comme small plutôt qu’une variante portant le suffixe .en. La documentation du projet précise en effet que les modèles contenant .en dans leur nom sont destinés à l’anglais, tandis que les autres modèles de cette liste sont multilingues.

Pour un premier essai sur VPS, nous resterons sur :

sh ./models/download-ggml-model.sh small

Vous pourrez ensuite tester un autre modèle en fonction de la mémoire disponible, de la précision recherchée et du comportement réellement observé sur votre VPS. À titre indicatif, la documentation de whisper.cpp annonce environ 466 MiB sur disque et 852 Mo de mémoire pour small, contre environ 1,5 GiB sur disque et 2,1 Go de mémoire pour medium. Ces valeurs concernent le runtime whisper.cpp et ne constituent pas des mesures de vitesse de transcription.

Nous allons maintenant préparer notre fichier audio dans le format attendu avant de lancer la première transcription avec whisper.cpp.

4. Convertir un fichier audio au format attendu

Avant la transcription, nous allons convertir le fichier en WAV 16 bits, mono et 16 kHz. Le README principal de whisper.cpp recommande toujours ce format pour whisper-cli, même si l’aide actuelle de la commande mentionne également la prise en charge de fichiers FLAC, MP3 et OGG. Pour obtenir un fonctionnement reproductible sur VPS, la conversion préalable avec ffmpeg reste donc la méthode retenue dans ce tutoriel.

Depuis le dossier contenant votre fichier audio.mp3, exécutez :

ffmpeg -i audio.mp3 -ar 16000 -ac 1 -c:a pcm_s16le audio.wav

Dans cette commande, -ar 16000 fixe la fréquence d’échantillonnage à 16 kHz, -ac 1 produit une piste mono et -c:a pcm_s16le utilise un encodage PCM signé sur 16 bits. Il s’agit de la commande de conversion fournie dans la documentation officielle de whisper.cpp.

Vérifiez ensuite que le fichier a bien été créé :

ls -lh audio.wav

Vous disposez maintenant d’un fichier prêt à être utilisé pour notre premier test avec whisper.cpp.

5. Lancer la transcription

Depuis le répertoire whisper.cpp, lancez la transcription avec le modèle small téléchargé précédemment :

./build/bin/whisper-cli \
  -m models/ggml-small.bin \
  -f audio.wav \
  -l fr

L’option -m indique le modèle Whisper à charger, -f désigne le fichier audio et -l fr précise que la langue parlée est le français. Cette dernière option est importante : l’aide actuelle de whisper-cli permet de fournir explicitement une langue ou d’utiliser auto pour demander une détection automatique.

Si vous souhaitez tester cette détection, utilisez plutôt :

./build/bin/whisper-cli \
  -m models/ggml-small.bin \
  -f audio.wav \
  -l auto

Le terminal affiche progressivement les segments transcrits avec leurs timestamps. Le résultat exact dépend évidemment de l’enregistrement et du modèle sélectionné.

Nous disposons désormais de deux installations fonctionnelles de Whisper AI sur VPS. Voyons comment exploiter les timestamps produits pour créer directement des fichiers de sous-titres.

Générer des sous-titres au format SRT

Le format SRT (SubRip Subtitle) associe chaque portion de texte à un intervalle temporel. Il peut ensuite être importé dans de nombreux lecteurs et outils vidéo pour ajouter des sous-titres synchronisés, notamment à partir d’un podcast vidéo, d’un webinaire ou d’une interview.

Avec faster-whisper (script Python) :

Avec faster-whisper, nous pouvons construire le fichier SRT à partir des propriétés start, end et text de chaque segment retourné par la transcription. Ces informations sont exposées directement par l’objet Segment de faster-whisper.

Créez un nouveau fichier :

nano generer_srt.py

Ajoutez le script suivant :

from faster_whisper import WhisperModel


def format_timestamp(seconds):
    milliseconds = round(seconds * 1000)

    hours, remainder = divmod(milliseconds, 3_600_000)
    minutes, remainder = divmod(remainder, 60_000)
    seconds, milliseconds = divmod(remainder, 1000)

    return (
        f"{hours:02d}:{minutes:02d}:"
        f"{seconds:02d},{milliseconds:03d}"
    )


model = WhisperModel(
    "small",
    device="cpu",
    compute_type="int8"
)

segments, info = model.transcribe(
    "audio.mp3",
    language="fr"
)

with open("sous-titres.srt", "w", encoding="utf-8") as fichier_srt:
    for numero, segment in enumerate(segments, start=1):
        fichier_srt.write(f"{numero}\n")
        fichier_srt.write(
            f"{format_timestamp(segment.start)} --> "
            f"{format_timestamp(segment.end)}\n"
        )
        fichier_srt.write(f"{segment.text.strip()}\n\n")

print("Fichier sous-titres.srt généré avec succès.")

La configuration CPU avec compute_type="int8" est prise en charge officiellement par faster-whisper. Comme segments est un générateur, la transcription est effectivement exécutée lorsque la boucle parcourt les différents segments pour écrire le fichier SRT.

Exécutez le script :

python generer_srt.py

Vous devriez obtenir un fichier :

sous-titres.srt

Vous pouvez en afficher les premières lignes avec :

head -n 12 sous-titres.srt

Le résultat prendra cette forme :

1
00:00:00,000 --> 00:00:04,280
Bonjour et bienvenue dans cet épisode.

2
00:00:04,280 --> 00:00:08,740
Aujourd'hui, nous allons parler d'hébergement web.

Les phrases et timestamps ci-dessus servent uniquement d’exemple de structure SRT. Ils seront remplacés par ceux calculés à partir de votre propre fichier audio.

Avec whisper.cpp (option intégrée) :

Avec whisper.cpp, la génération d’un fichier SRT est plus directe : whisper-cli possède une option dédiée aux sous-titres SRT. Le code source actuel du projet confirme que -osrt est l’alias de --output-srt.

Depuis le répertoire whisper.cpp, exécutez :

./build/bin/whisper-cli \
  -m models/ggml-small.bin \
  -f audio.wav \
  -l fr \
  -osrt

La transcription est alors également enregistrée au format SRT.

Si vous souhaitez définir explicitement le nom du fichier de sortie, whisper-cli propose l’option -of, ou --output-file. Le chemin doit être fourni sans extension.

Par exemple :

./build/bin/whisper-cli \
  -m models/ggml-small.bin \
  -f audio.wav \
  -l fr \
  -osrt \
  -of sous-titres

Vous obtenez alors :

sous-titres.srt

Vous pouvez vérifier les premières lignes avec :

head -n 12 sous-titres.srt

Cette méthode est particulièrement pratique lorsque votre objectif principal consiste à générer rapidement des sous-titres sans développer de script Python supplémentaire.

Traiter plusieurs fichiers automatiquement : script batch

Une fois Whisper AI opérationnel, il est possible d’automatiser la transcription de plusieurs fichiers. C’est utile, par exemple, pour traiter une archive de podcasts, des enregistrements de réunions ou des fichiers audio déposés régulièrement sur le VPS.

Le premier script transcrire.py de ce tutoriel utilisait directement audio.mp3. Pour un traitement par lot, nous devons d’abord lui permettre de recevoir le chemin du fichier audio en argument.

Remplacez son contenu par :

import sys

from faster_whisper import WhisperModel


if len(sys.argv) != 2:
    print("Usage : python transcrire.py fichier_audio")
    sys.exit(1)

fichier_audio = sys.argv[1]

model = WhisperModel(
    "small",
    device="cpu",
    compute_type="int8"
)

segments, info = model.transcribe(
    fichier_audio,
    language="fr"
)

for segment in segments:
    print(segment.text.strip())

Vous pouvez désormais appeler le script avec n’importe quel fichier :

python transcrire.py podcast.mp3

Créez ensuite les dossiers qui accueilleront les fichiers :

mkdir -p /home/utilisateur/audios
mkdir -p /home/utilisateur/transcriptions

Puis créez transcrire_dossier.sh :

nano transcrire_dossier.sh

Ajoutez :

#!/bin/bash

shopt -s nullglob

for fichier in /home/utilisateur/audios/*.mp3; do
    nom=$(basename "$fichier" .mp3)

    /home/utilisateur/whisper-env/bin/python \
        /home/utilisateur/transcrire.py \
        "$fichier" \
        > "/home/utilisateur/transcriptions/${nom}.txt"
done

Adaptez /home/utilisateur/ au chemin réellement utilisé sur votre VPS.

Rendez ensuite le script exécutable :

chmod +x transcrire_dossier.sh

Puis lancez-le :

./transcrire_dossier.sh

Chaque fichier MP3 présent dans audios produit alors une transcription TXT portant le même nom dans le dossier transcriptions.

Nous utilisons volontairement le chemin complet vers :

/home/utilisateur/whisper-env/bin/python

Cette méthode évite de dépendre de l’activation manuelle de l’environnement virtuel Python, ce qui devient particulièrement important lorsqu’un script est lancé automatiquement par Cron.

Pour planifier, par exemple, une transcription chaque nuit, vous pouvez ensuite créer une tâche Cron. Le guide LWS consacré aux Cron Jobs détaille la syntaxe et la gestion de ces tâches sur Linux.

Vous pouvez consulter le tutoriel : automatiser vos transcriptions avec une tâche planifiée Cron.

Superviser les ressources pendant la transcription

La transcription audio par IA sollicite principalement le processeur et la mémoire lorsque Whisper fonctionne sans GPU. Plus le modèle choisi est volumineux, plus il est important de vérifier le comportement réel du serveur pendant les premiers traitements.

Le Panel KVM LWS permet de suivre depuis une interface graphique différentes ressources du VPS, notamment la charge CPU, la mémoire RAM et le trafic réseau. Cette supervision est déjà utilisée dans les tutoriels LWS consacrés aux VPS pour identifier rapidement une hausse de consommation.

Pendant une transcription, ouvrez donc la partie consacrée à la supervision des ressources dans votre Panel KVM et observez principalement :

• la charge CPU pendant le traitement ;
• la mémoire RAM utilisée ;
• l’évolution des ressources lorsque plusieurs fichiers sont traités successivement ;
• l’impact éventuel sur les autres services hébergés sur le même VPS.

Un CPU fortement sollicité pendant l’inférence n’indique pas nécessairement une anomalie. En revanche, si le serveur devient difficilement utilisable ou manque régulièrement de mémoire, commencez par tester un modèle Whisper plus léger avant d’augmenter les ressources du VPS.

Aucun temps de traitement précis n’est donné ici : il doit être mesuré sur la configuration CPU réelle du VPS KVM LWS utilisé.

Cas d’usage concrets sur un VPS LWS

Une fois la transcription Whisper automatisée, elle peut être intégrée à de nombreux workflows : création de contenus SEO à partir de podcasts, sous-titrage de vidéos, comptes-rendus confidentiels ou encore automatisations combinant Whisper avec d’autres outils hébergés sur le même VPS.

Transcription de podcasts pour le SEO

Une transcription de podcast peut servir de matière première pour créer un article de blog, une FAQ, un résumé ou des extraits destinés aux réseaux sociaux. Whisper produit d’abord le texte brut de l’épisode, qui doit ensuite être relue, corrigé et restructuré avant publication : une transcription automatique ne remplace pas le travail éditorial nécessaire à un contenu SEO de qualité.

Vous pouvez également combiner Whisper avec un LLM local pour résumer automatiquement vos transcriptions.

Un workflow peut ainsi suivre cette logique :

Podcast → Whisper → transcription texte → LLM local → résumé ou structure d’article → relecture humaine
→ publication

Cette approche permet d’exploiter plus facilement un même contenu audio sous plusieurs formats tout en conservant le traitement principal sur votre infrastructure.

Sous-titrage de vidéos et accessibilité

Les fichiers SRT générés avec Whisper AI peuvent également servir à créer des sous-titres synchronisés pour des interviews, tutoriels vidéo, webinaires ou podcasts filmés.

Les WCAG 2.2 prévoient notamment, avec le critère 1.2.2 de niveau A, des sous-titres pour les contenus audio préenregistrés présents dans un média synchronisé. Le W3C précise que ces sous-titres doivent transmettre non seulement les paroles, mais aussi les informations sonores nécessaires à la compréhension, comme l’identification d’un intervenant ou certains effets sonores significatifs.

Une transcription Whisper constitue donc une excellente base, mais elle doit être vérifiée et éventuellement complétée manuellement avant d’être considérée comme un véritable sous-titrage accessible.

Pour approfondir ce sujet, consultez le guide LWS expliquant comment les sous-titres générés contribuent aux critères d’accessibilité WCAG de votre site. Cet article détaille notamment l’accessibilité des contenus audio et vidéo.

Comptes-rendus de réunions confidentielles

Pour une entreprise, Whisper auto-hébergé peut aussi être utilisé pour transcrire des réunions internes, entretiens ou échanges contenant des informations sensibles.

Lorsque la transcription est entièrement réalisée sur votre propre VPS, il est possible d’éviter l’envoi du fichier audio à une API de transcription externe. Cette approche donne davantage de contrôle sur l’emplacement du fichier, le modèle utilisé et la suppression des données après traitement.

Il faut toutefois éviter de présenter l’auto-hébergement comme une garantie automatique de conformité au RGPD. L’entreprise reste responsable de la sécurité, des droits d’accès, des sauvegardes et de la durée de conservation des enregistrements et transcriptions. La CNIL rappelle notamment que les données personnelles ne doivent pas être conservées indéfiniment et que leur accès doit être protégé.

Pour des réunions sensibles, prévoyez donc une politique de conservation, des droits d’accès limités et une suppression des fichiers devenus inutiles.

Automatisation via n8n

Whisper peut enfin être intégré dans un workflow n8n auto-hébergé afin d’automatiser toute la chaîne de transcription.

Un scénario peut, par exemple, démarrer lorsqu’un fichier est reçu via un webhook. Le nœud Webhook de n8n est précisément conçu pour déclencher un workflow lorsqu’une requête arrive sur une URL dédiée.

Le workflow peut ensuite :

1. récupérer ou enregistrer le fichier audio ;
2. lancer le script faster-whisper ou la commande whisper-cli ;
3. récupérer la transcription produite ;
4. l’envoyer vers un autre traitement local ;
5. enregistrer le résultat ou déclencher une notification.

Sur une instance n8n auto-hébergée, le nœud Execute Command permet d’exécuter des commandes shell sur la machine qui héberge n8n. Il est toutefois classé parmi les nœuds pouvant être bloqués par défaut dans certaines configurations récentes pour des raisons de sécurité : vérifiez donc sa disponibilité avant de construire votre workflow.

Vous pouvez ainsi créer un pipeline entièrement automatisé du type :

Dépôt audio → n8n → Whisper AI → transcription → LLM local → résumé → archivage ou notification

Vérification du bon fonctionnement

Avant d’automatiser vos transcriptions Whisper AI, effectuez quelques contrôles simples pour vous assurer que l’installation fonctionne correctement.

Vérifiez les points suivants :

• le script faster-whisper transcrit correctement un fichier audio et détecte une langue cohérente ;
• whisper-cli se lance sans erreur et produit une transcription exploitable ;
• le fichier SRT contient des numéros de séquence, des timestamps et du texte ;
• le script batch génère bien un fichier .txt pour chaque audio traité ;
• la RAM du VPS reste suffisante pendant le chargement du modèle ;
• la charge CPU observée dans le Panel KVM LWS reste compatible avec les autres services hébergés sur le serveur. Le Panel permet notamment de suivre la consommation CPU et mémoire du VPS.

Pour vérifier rapidement un fichier SRT :

head -n 20 sous-titres.srt

Avec whisper.cpp, assurez-vous également que vos fichiers suivent le format recommandé par le projet, à savoir un WAV PCM 16 bits, mono et 16 kHz pour la procédure utilisée dans ce tutoriel.

Erreurs fréquentes et cas de blocage

Même avec une installation correcte, certaines erreurs peuvent apparaître selon la configuration du VPS, le modèle choisi ou l’environnement Python.

Erreur ou symptôme	Cause probable	Solution
ModuleNotFoundError: No module named 'faster_whisper'	L’environnement virtuel n’est pas actif ou faster-whisper a été installé avec un autre interpréteur Python	Exécuter source whisper-env/bin/activate, puis vérifier avec python -m pip show faster-whisper
whisper-cli: No such file or directory	whisper.cpp n’a pas été compilé ou la commande est lancée depuis le mauvais répertoire	Vérifier la compilation et la présence de build/bin/whisper-cli
Erreur concernant le format WAV	Le fichier n’est pas au format attendu par la procédure whisper.cpp	Convertir l’audio avec ffmpeg -ar 16000 -ac 1 -c:a pcm_s16le
Échec lors du premier chargement du modèle	Le modèle n’est pas encore présent localement ou son téléchargement n’a pas abouti	Vérifier la connexion réseau et relancer le script
Processus interrompu et journal système indiquant un manque de mémoire	Le modèle choisi nécessite davantage de RAM que celle disponible	Tester base ou small, ou un modèle quantifié avec whisper.cpp
Transcription particulièrement lente	Le modèle est trop exigeant pour les ressources CPU disponibles	Tester un modèle plus léger et mesurer les performances sur le VPS réel
La commande whisper est introuvable	Confusion avec le CLI de l’implémentation officielle OpenAI Whisper	Avec faster-whisper, utiliser le script Python créé dans ce tutoriel plutôt que la commande whisper

Pour diagnostiquer l’installation de faster-whisper, commencez par vérifier :

source whisper-env/bin/activate
python --version
python -m pip show faster-whisper

La version actuelle de faster-whisper nécessite Python 3.9 ou supérieur et s’installe avec pip. Elle utilise par ailleurs PyAV pour le décodage audio.

Pour whisper.cpp, contrôlez l’exécutable :

ls -lh build/bin/whisper-cli

Puis le modèle :

ls -lh models/ggml-small.bin

Si le problème concerne l’audio, reconvertissez-le :

ffmpeg -i audio.mp3 -ar 16000 -ac 1 -c:a pcm_s16le audio.wav

Cette conversion correspond à celle recommandée actuellement dans la documentation de whisper.cpp.

Enfin, ne cherchez pas à résoudre systématiquement un problème de lenteur en installant un modèle plus volumineux. Sur un VPS sans GPU, il est préférable de commencer petit, puis de comparer la qualité obtenue avec les ressources réellement disponibles.

Bonnes pratiques à suivre

Pour utiliser Whisper AI sur un VPS de manière régulière, quelques précautions permettent de conserver une installation plus stable et prévisible.

Commencez vos essais avec un modèle base ou small. Vous pourrez ensuite tester un modèle plus volumineux si la qualité obtenue ne répond pas à vos besoins. whisper.cpp propose également plusieurs modèles quantifiés, conçus notamment pour diminuer la taille du modèle et son empreinte mémoire.

Avec faster-whisper, conservez votre installation dans un environnement virtuel Python et utilisez compute_type="int8" lorsque vous souhaitez exploiter le mode CPU INT8 pris en charge par CTranslate2.

Pour whisper.cpp, conservez la conversion systématique vers un fichier :

WAV + PCM 16 bits + 16 kHz + mono

Vous réduirez ainsi les problèmes de compatibilité entre fichiers provenant de sources différentes. La documentation officielle de whisper.cpp recommande toujours cette préparation pour whisper-cli.

Pensez également à :

• créer un snapshot avant une mise à jour importante ;
• surveiller la RAM et le CPU lors des premiers traitements ;
• éviter de lancer simultanément plusieurs gros modèles sur un VPS déjà chargé ;
• conserver les fichiers audio sensibles uniquement pendant la durée réellement nécessaire ;
• tester vos scripts sur quelques fichiers avant de lancer une archive complète ;
• mesurer vous-même les performances avant de dimensionner un workflow de production.

Le Panel KVM LWS permet de suivre notamment le CPU, la RAM, le disque et l’activité réseau du VPS, ce qui facilite ces contrôles pendant les premiers traitements.

FAQ

Whisper AI est-il gratuit pour un usage commercial ?

Oui. Whisper AI est publié sous licence MIT, ce qui autorise un usage commercial. En auto-hébergement, vous ne payez pas la transcription à la minute, mais uniquement les ressources de votre serveur.

Peut-on utiliser Whisper AI sans GPU sur un VPS ?

Oui. faster-whisper et whisper.cpp peuvent fonctionner sur CPU sans GPU dédié. Sur un VPS, commencez avec un modèle léger comme base ou small pour limiter la consommation de ressources.

Quelle est la différence entre faster-whisper et whisper.cpp ?

faster-whisper s’appuie sur CTranslate2 et s’intègre facilement dans des scripts Python. whisper.cpp est une implémentation C/C++ plus légère, particulièrement adaptée à une utilisation en ligne de commande sur CPU.

Whisper transcrit-il bien le français ?

Oui. Les modèles multilingues de Whisper prennent en charge le français. La qualité varie toutefois selon le modèle utilisé, la qualité de l’enregistrement, le bruit ambiant et les conditions de prise de son.

Comment générer des sous-titres SRT avec Whisper ?

Avec faster-whisper, un script Python peut transformer les segments transcrits en fichier SRT. Avec whisper.cpp, l’option -osrt permet de générer directement les sous-titres.

Les enregistrements transcrits avec Whisper restent-ils confidentiels ?

Avec une installation locale sur votre VPS, les fichiers n’ont pas besoin d’être envoyés à une API de transcription tierce. La confidentialité dépend néanmoins de la sécurité du serveur, des droits d’accès et de votre politique de conservation.

Conclusion

Installer Whisper AI sur un VPS permet de disposer d’une solution de transcription audio auto-hébergée, sans dépendre systématiquement d’une API facturée à l’usage. ✔Avec faster-whisper, vous profitez d’un environnement Python pratique pour créer des scripts et automatiser vos traitements. whisper.cpp constitue de son côté une alternative légère particulièrement adaptée à une exécution sur CPU. Dans les deux cas, commencez avec un modèle raisonnable comme small, mesurez la consommation réelle de votre serveur et augmentez progressivement les ressources si nécessaire. ✨Vous pourrez ensuite générer des sous-titres SRT, traiter automatiquement des dossiers d’enregistrements ou intégrer Whisper à un workflow n8n ou à un LLM local. Pensez enfin à protéger vos fichiers audio, surveiller votre VPS et conserver uniquement les données réellement nécessaires.