Whisper : transcription audio avec l'API OpenAI

Qu'est-ce que Whisper

Whisper est un modèle de reconnaissance vocale (Speech-to-Text) open-source développé par OpenAI. Entraîné sur 680 000 heures d'audio multilingue, il atteint des performances proches de l'humain pour la transcription et supporte plus de 50 langues.

Il est disponible de deux façons :

• API OpenAI — accès cloud via api.openai.com, sans GPU requis
• Local — modèle open-source exécutable sur votre machine avec Python

Transcription via l'API OpenAI

L'endpoint de transcription est /v1/audio/transcriptions. Voici comment l'utiliser avec le SDK officiel Node.js :

import OpenAI from 'openai';
import fs from 'fs';

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

async function transcribeAudio(filePath: string): Promise<string> {
  const transcription = await openai.audio.transcriptions.create({
    file: fs.createReadStream(filePath),
    model: 'whisper-1',
    language: 'fr',        // facultatif : détection automatique si omis
    response_format: 'text', // 'text' | 'json' | 'srt' | 'vtt' | 'verbose_json'
  });

  return transcription.text;
}

// Usage
const text = await transcribeAudio('./interview.mp3');
console.info(text);

Pour obtenir les timestamps de chaque mot ou segment, utilisez verbose_json :

const transcription = await openai.audio.transcriptions.create({
  file: fs.createReadStream(filePath),
  model: 'whisper-1',
  response_format: 'verbose_json',
  timestamp_granularities: ['segment', 'word'],
});

// Accès aux segments avec timestamps
transcription.segments?.forEach(segment => {
  console.info(`[${segment.start}s - ${segment.end}s] ${segment.text}`);
});

Formats audio supportés

L'API Whisper accepte les formats suivants :

• mp3, mp4, mpeg, mpga
• m4a, wav, webm, ogg, flac

Limite de taille : 25 MB par fichier. Pour les fichiers plus longs, découpez-les avec ffmpeg :

# Découper un fichier audio en segments de 10 minutes
ffmpeg -i long-audio.mp3 -f segment -segment_time 600 -c copy segment_%03d.mp3

# Puis transcrire chaque segment
for i in segment_*.mp3; do
  echo "Transcription de $i..."
done

Traduction automatique

En plus de la transcription, Whisper peut traduire un audio vers l'anglais en une seule requête via l'endpoint /v1/audio/translations :

// Traduit automatiquement n'importe quelle langue vers l'anglais
const translation = await openai.audio.translations.create({
  file: fs.createReadStream('./audio-en-francais.mp3'),
  model: 'whisper-1',
  response_format: 'text',
});

console.info(translation);
// Texte en anglais, traduit depuis le français

Intégration dans une app web

Exemple complet : enregistrer l'audio du microphone et le transcrire en temps réel.

// Route API Next.js : app/api/transcribe/route.ts
import OpenAI from 'openai';
import { NextRequest } from 'next/server';

const openai = new OpenAI();

export async function POST(req: NextRequest) {
  const formData = await req.formData();
  const file = formData.get('audio') as File;

  if (!file) {
    return Response.json({ error: 'Fichier audio manquant' }, { status: 400 });
  }

  const transcription = await openai.audio.transcriptions.create({
    file,
    model: 'whisper-1',
    language: 'fr',
  });

  return Response.json({ text: transcription.text });
}

Côté client avec l'API MediaRecorder :

'use client';
import { useState, useRef } from 'react';

export function VoiceRecorder() {
  const [transcript, setTranscript] = useState('');
  const [isRecording, setIsRecording] = useState(false);
  const mediaRecorderRef = useRef<MediaRecorder | null>(null);
  const chunksRef = useRef<Blob[]>([]);

  async function startRecording() {
    const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
    const recorder = new MediaRecorder(stream, { mimeType: 'audio/webm' });

    recorder.ondataavailable = (e) => chunksRef.current.push(e.data);
    recorder.onstop = async () => {
      const blob = new Blob(chunksRef.current, { type: 'audio/webm' });
      const formData = new FormData();
      formData.append('audio', blob, 'recording.webm');

      const res = await fetch('/api/transcribe', { method: 'POST', body: formData });
      const { text } = await res.json();
      setTranscript(text);
      chunksRef.current = [];
    };

    mediaRecorderRef.current = recorder;
    recorder.start();
    setIsRecording(true);
  }

  function stopRecording() {
    mediaRecorderRef.current?.stop();
    setIsRecording(false);
  }

  return (
    <div>
      <button onClick={isRecording ? stopRecording : startRecording}>
        {isRecording ? 'Arrêter' : 'Enregistrer'}
      </button>
      {transcript && <p>{transcript}</p>}
    </div>
  );
}

Whisper en local avec Python

Si vous préférez ne pas envoyer vos audios vers l'API OpenAI, vous pouvez exécuter Whisper localement. Il existe 5 tailles de modèles : tiny, base, small, medium, large.

# Installation
pip install openai-whisper

# Transcription en ligne de commande
whisper audio.mp3 --language French --model medium

# Ou en Python
import whisper

model = whisper.load_model("medium")
result = model.transcribe("audio.mp3", language="fr")
print(result["text"])