Comment Utiliser L'API de Murf AI

Murf AI transforme le texte en parole naturelle avec des voix off de qualité studio. Les développeurs intègrent l'API Murf AI pour créer des applications qui narrent du contenu, génèrent des versions audio d'articles, alimentent des assistants virtuels et produisent des voix off à grande échelle.

Qu'est-ce que l'API Murf AI ?

Murf AI propose un service de synthèse vocale basé sur le cloud qui convertit le contenu écrit en audio réaliste et semblable à la voix humaine. Contrairement aux moteurs TTS au son robotique, Murf utilise la synthèse vocale basée sur l'IA pour produire une intonation naturelle, un accent approprié et une expression émotionnelle authentique.

L'API expose cette fonctionnalité aux développeurs. Les principales capacités incluent :

• Bibliothèque de voix - Accédez à plus de 120 voix IA couvrant différents genres, âges et accents
• Prise en charge multilingue - Générez de la parole dans plus de 20 langues, y compris l'anglais, l'espagnol, le français, l'allemand et l'hindi
• Personnalisation de la voix - Ajustez la hauteur, la vitesse et l'accent pour un contrôle précis
• Plusieurs formats de sortie - Exportez l'audio au format MP3, WAV ou FLAC
• Prise en charge SSML - Affinez la prononciation à l'aide du langage de balisage de synthèse vocale (SSML)

Les développeurs utilisent l'API Murf AI pour la narration vidéo, la production de podcasts, les systèmes IVR, la génération de livres audio et les fonctionnalités d'accessibilité. L'API gère à la fois les courts extraits et le contenu long, ce qui la rend adaptée à divers cas d'utilisation.

Démarrer avec l'API Murf AI

Avant d'effectuer des appels API, vous devez configurer l'authentification. Murf AI utilise des clés API pour l'autorisation, en suivant les conventions REST standard.

Étape 1 : Créer un compte Murf AI

Visitez murf.ai et créez un compte. Murf propose un niveau gratuit avec des crédits limités, ce qui est idéal pour tester l'API. Pour une utilisation en production, vous aurez besoin d'un plan payant incluant l'accès à l'API.

Étape 2 : Générer votre clé API Murf AI

Accédez aux paramètres de votre compte et localisez la section API. Générez une nouvelle clé API et stockez-la en toute sécurité. Cette clé authentifie toutes vos requêtes.

Gardez votre clé API confidentielle. Ne la soumettez jamais au contrôle de version et ne l'exposez jamais dans le code côté client.

Étape 3 : Comprendre l'URL de base de l'API Murf AI

Toutes les requêtes de l'API Murf AI sont envoyées à :

https://api.murf.ai/v1

L'API suit les conventions RESTful avec des corps de requête et de réponse JSON. L'authentification se fait via l'en-tête api-key.

Authentification de l'API Murf AI

Chaque requête API nécessite votre clé API dans les en-têtes de requête. Le format de l'en-tête d'authentification est :

api-key: YOUR_API_KEY
Content-Type: application/json

Voici à quoi ressemble l'authentification dans différents langages de programmation :

Authentification Python avec l'API Murf AI

import requests

API_KEY = "your_murf_api_key"
BASE_URL = "https://api.murf.ai/v1"

headers = {
    "api-key": API_KEY,
    "Content-Type": "application/json"
}

# Test authentication by fetching available voices
response = requests.get(f"{BASE_URL}/voices", headers=headers)

if response.status_code == 200:
    print("Authentication successful!")
    voices = response.json()
    print(f"Available voices: {len(voices)}")
else:
    print(f"Authentication failed: {response.status_code}")

Authentification JavaScript avec l'API Murf AI

const API_KEY = 'your_murf_api_key';
const BASE_URL = 'https://api.murf.ai/v1';

const headers = {
    'api-key': API_KEY,
    'Content-Type': 'application/json'
};

// Test authentication
fetch(`${BASE_URL}/voices`, { headers })
    .then(response => response.json())
    .then(data => console.log('Voices available:', data.length))
    .catch(error => console.error('Auth failed:', error));

Authentification cURL avec l'API Murf AI

curl -X GET "https://api.murf.ai/v1/voices" \
  -H "api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

Une authentification réussie renvoie un code d'état 200. Les clés non valides renvoient 401 Non autorisé.

Récupération des voix disponibles avec l'API Murf AI

Avant de générer la parole, récupérez la liste des voix disponibles pour en sélectionner une qui correspond à votre cas d'utilisation. Le point de terminaison /voices renvoie toutes les voix accessibles avec leurs métadonnées.

Lister toutes les voix

import requests

API_KEY = "your_murf_api_key"
BASE_URL = "https://api.murf.ai/v1"

headers = {
    "api-key": API_KEY,
    "Content-Type": "application/json"
}

response = requests.get(f"{BASE_URL}/voices", headers=headers)
voices = response.json()

# Show first 5 voices
for voice in voices[:5]:  
    print(f"Name: {voice['name']}")
    print(f"Voice ID: {voice['voiceId']}")
    print(f"Language: {voice['language']}")
    print(f"Gender: {voice['gender']}")
    print(f"Accent: {voice.get('accent', 'N/A')}")
    print("---")

La réponse inclut les propriétés de la voix :

Filtrer les voix par langue

# Filter for English voices
english_voices = [v for v in voices if v['language'].startswith('en')]
print(f"Voix anglaises disponibles : {len(english_voices)}")

# Filter for Spanish voices
spanish_voices = [v for v in voices if v['language'].startswith('es')]
print(f"Voix espagnoles disponibles : {len(spanish_voices)}")

Générer de la parole à partir de texte

La fonctionnalité principale de l'API Murf AI est la conversion de texte en parole. Le point de terminaison /speech accepte le texte et les paramètres de voix, renvoyant un fichier audio.

Requête de synthèse vocale de base

import requests

API_KEY = "your_murf_api_key"
BASE_URL = "https://api.murf.ai/v1"

headers = {
    "api-key": API_KEY,
    "Content-Type": "application/json"
}

payload = {
    "text": "Bienvenue sur notre application. Cet audio a été généré avec Murf AI.",
    "voiceId": "en-US-marcus",
    "format": "mp3",
    "sampleRate": 24000
}

response = requests.post(
    f"{BASE_URL}/speech",
    headers=headers,
    json=payload
)

if response.status_code == 200:
    # Save the audio file
    with open("output.mp3", "wb") as f:
        f.write(response.content)
    print("Audio enregistré dans output.mp3")
else:
    print(f"Erreur : {response.status_code} - {response.text}")

Paramètres de requête

Ajuster la vitesse et la hauteur de la voix

payload = {
    "text": "Ce texte est prononcé à un rythme plus lent et avec une hauteur plus basse.",
    "voiceId": "en-US-marcus",
    "format": "mp3",
    "speed": 0.8,    # 80% de la vitesse normale
    "pitch": -2      # Hauteur légèrement plus basse
}

response = requests.post(f"{BASE_URL}/speech", headers=headers, json=payload)

Utilisation de SSML pour un contrôle avancé

Le langage de balisage de synthèse vocale (SSML) offre un contrôle précis sur la prononciation, les pauses, l'accentuation et bien plus encore. L'API Murf AI prend en charge les balises SSML pour une sortie audio de qualité professionnelle.

Exemple SSML

ssml_text = """
<speak>
    Bienvenue chez <emphasis level="strong">Murf AI</emphasis>.
    <break time="500ms"/>
    Notre technologie de synthèse vocale crée un son <prosody rate="slow">naturel</prosody>.
    <break time="300ms"/>
    Le mot <phoneme alphabet="ipa" ph="ˈdeɪtə">data</phoneme> est prononcé correctement.
</speak>
"""

payload = {
    "text": ssml_text,
    "voiceId": "en-US-julia",
    "format": "mp3",
    "ssml": True  # Activer l'analyse SSML
}

response = requests.post(f"{BASE_URL}/speech", headers=headers, json=payload)

Balises SSML courantes

Tester l'API Murf AI avec Apidog

Avant d'écrire du code d'intégration, testez vos appels API de manière interactive. Apidog fournit une interface visuelle pour élaborer des requêtes, inspecter les réponses et déboguer les problèmes.

Configuration d'Apidog pour Murf AI

1. Télécharger et installer Apidog

Obtenez Apidog gratuitement. Il prend en charge Windows, Mac, Linux et les navigateurs web.

2. Créer un nouveau projet

Démarrez un nouveau projet nommé "Intégration Murf AI". Cela permet d'organiser vos points de terminaison API.

3. Configurer les variables d'environnement

Créez un environnement avec votre clé API :

{
    "baseUrl": "https://api.murf.ai/v1",
    "apiKey": "votre_clé_api_murf"
}

Les variables d'environnement maintiennent les données sensibles séparées des configurations de requête.

4. Créer votre première requête

Ajoutez une nouvelle requête POST avec ces paramètres :

• URL: {{baseUrl}}/speech
• En-têtes:
• api-key: {{apiKey}}
• Content-Type: application/json
• Corps (JSON):

{
    "text": "Test de l'API Murf AI avec Apidog. Ceci est un exemple de voix off.",
    "voiceId": "en-US-marcus",
    "format": "mp3"
}

5. Envoyer et inspecter la réponse

Cliquez sur Envoyer. Apidog affiche l'état de la réponse, les en-têtes et vous permet de télécharger directement le fichier audio généré.

Déboguer les problèmes courants avec Apidog

La fonctionnalité d'historique des requêtes d'Apidog vous permet de comparer côte à côte les requêtes réussies et échouées, ce qui simplifie le débogage.

Gérer le contenu long avec l'API Murf AI

Pour les articles, les billets de blog ou les chapitres de livre, vous devrez peut-être traiter le texte par morceaux. Murf AI a des limites de caractères par requête, donc le découpage du contenu assure un traitement fiable.

Stratégie de découpage

import requests

API_KEY = "your_murf_api_key"
BASE_URL = "https://api.murf.ai/v1"

headers = {
    "api-key": API_KEY,
    "Content-Type": "application/json"
}

def chunk_text(text, max_chars=3000):
    """Divise le texte en morceaux aux limites des phrases."""
    sentences = text.replace('!', '.').replace('?', '.').split('.')
    chunks = []
    current_chunk = ""

    for sentence in sentences:
        sentence = sentence.strip()
        if not sentence:
            continue

        if len(current_chunk) + len(sentence) + 2 > max_chars:
            chunks.append(current_chunk.strip())
            current_chunk = sentence + ". "
        else:
            current_chunk += sentence + ". "

    if current_chunk.strip():
        chunks.append(current_chunk.strip())

    return chunks

def generate_long_audio(text, voice_id, output_prefix="output"):
    """Génère de l'audio pour le contenu long."""
    chunks = chunk_text(text)
    audio_files = []

    for i, chunk in enumerate(chunks):
        payload = {
            "text": chunk,
            "voiceId": voice_id,
            "format": "mp3"
        }

        response = requests.post(
            f"{BASE_URL}/speech",
            headers=headers,
            json=payload
        )

        if response.status_code == 200:
            filename = f"{output_prefix}_{i+1}.mp3"
            with open(filename, "wb") as f:
                f.write(response.content)
            audio_files.append(filename)
            print(f"Généré : {filename}")
        else:
            print(f"Morceau {i+1} échoué : {response.status_code}")

    return audio_files

# Exemple d'utilisation
long_text = """
Votre contenu d'article ou de document long va ici.
Il peut s'étendre sur plusieurs paragraphes et pages.
La fonction le divise automatiquement aux limites des phrases.
"""

audio_files = generate_long_audio(long_text, "en-US-marcus", "article_audio")
print(f"{len(audio_files)} fichiers audio générés")

Concaténer les fichiers audio avec l'API Murf AI

Après avoir généré les morceaux, combinez-les en un seul fichier à l'aide de FFmpeg ou d'une bibliothèque Python :

from pydub import AudioSegment

def concatenate_audio(file_list, output_file="final_audio.mp3"):
    """Combine plusieurs fichiers audio en un seul."""
    combined = AudioSegment.empty()

    for filename in file_list:
        audio = AudioSegment.from_mp3(filename)
        combined += audio

    combined.export(output_file, format="mp3")
    print(f"Audio combiné enregistré dans {output_file}")
    return output_file

# Combiner les morceaux
concatenate_audio(audio_files, "complete_article.mp3")

Meilleures pratiques de gestion des erreurs avec l'API Murf AI

Les applications de production nécessitent une gestion robuste des erreurs. L'API Murf AI renvoie des codes d'état HTTP standard avec des messages d'erreur descriptifs.

Codes d'erreur courants

Client API robuste

import requests
import time
from typing import Optional

class MurfAPIClient:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.murf.ai/v1"
        self.headers = {
            "api-key": api_key,
            "Content-Type": "application/json"
        }

    def _request(self, method: str, endpoint: str,
                 data: dict = None, retries: int = 3) -> Optional[requests.Response]:
        """Effectue une requête API avec une logique de réessai."""
        url = f"{self.base_url}/{endpoint}"

        for attempt in range(retries):
            try:
                if method == "GET":
                    response = requests.get(url, headers=self.headers)
                else:
                    response = requests.post(url, headers=self.headers, json=data)

                if response.status_code == 200:
                    return response
                elif response.status_code == 429:
                    # Débit limité - attendez et réessayez
                    wait_time = 2 ** attempt
                    print(f"Débit limité. Attente de {wait_time}s...")
                    time.sleep(wait_time)
                elif response.status_code >= 500:
                    # Erreur du serveur - réessayer
                    time.sleep(1)
                else:
                    # Erreur du client - ne pas réessayer
                    print(f"Erreur {response.status_code} : {response.text}")
                    return None

            except requests.RequestException as e:
                print(f"Requête échouée : {e}")
                time.sleep(1)

        return None

    def get_voices(self) -> list:
        """Récupère les voix disponibles."""
        response = self._request("GET", "voices")
        return response.json() if response else []

    def generate_speech(self, text: str, voice_id: str,
                        format: str = "mp3", **kwargs) -> Optional[bytes]:
        """Génère de la parole à partir de texte."""
        payload = {
            "text": text,
            "voiceId": voice_id,
            "format": format,
            **kwargs
        }
        response = self._request("POST", "speech", payload)
        return response.content if response else None

# Utilisation
client = MurfAPIClient("your_api_key")
voices = client.get_voices()
audio = client.generate_speech(
    "Bonjour le monde !",
    "en-US-marcus",
    speed=1.0
)

if audio:
    with open("output.mp3", "wb") as f:
        f.write(audio)

Construire un service de génération de voix off

Construisons une API Flask complète qui enveloppe Murf AI pour vos applications :

from flask import Flask, request, jsonify, send_file
import requests
import os
import uuid

app = Flask(__name__)

MURF_API_KEY = os.environ.get("MURF_API_KEY")
MURF_BASE_URL = "https://api.murf.ai/v1"

headers = {
    "api-key": MURF_API_KEY,
    "Content-Type": "application/json"
}

@app.route("/api/voices", methods=["GET"])
def list_voices():
    """Liste les voix disponibles."""
    language = request.args.get("language")

    response = requests.get(f"{MURF_BASE_URL}/voices", headers=headers)

    if response.status_code != 200:
        return jsonify({"error": "Échec de la récupération des voix"}), 500

    voices = response.json()

    if language:
        voices = [v for v in voices if v["language"].startswith(language)]

    return jsonify(voices)

@app.route("/api/synthesize", methods=["POST"])
def synthesize():
    """Génère de la parole à partir de texte."""
    data = request.json

    if not data or "text" not in data:
        return jsonify({"error": "Champ 'text' manquant"}), 400

    if "voiceId" not in data:
        return jsonify({"error": "Champ 'voiceId' manquant"}), 400

    payload = {
        "text": data["text"],
        "voiceId": data["voiceId"],
        "format": data.get("format", "mp3"),
        "speed": data.get("speed", 1.0),
        "pitch": data.get("pitch", 0)
    }

    response = requests.post(
        f"{MURF_BASE_URL}/speech",
        headers=headers,
        json=payload
    )

    if response.status_code != 200:
        return jsonify({"error": "Échec de la génération de la parole"}), 500

    # Save to temp file
    filename = f"audio_{uuid.uuid4().hex}.mp3"
    filepath = os.path.join("/tmp", filename)

    with open(filepath, "wb") as f:
        f.write(response.content)

    return send_file(
        filepath,
        mimetype="audio/mpeg",
        as_attachment=True,
        download_name=filename
    )

if __name__ == "__main__":
    app.run(debug=True, port=5000)

Ce service expose deux points de terminaison : un pour lister les voix et un autre pour générer de la parole. Vous pouvez l'étendre avec la mise en cache, l'authentification et le traitement basé sur des files d'attente pour une utilisation en production.

Limites de débit et considérations tarifaires pour l'API Murf AI

Murf AI applique des limites de débit basées sur votre plan d'abonnement. Comprendre ces limites vous aide à concevoir des applications efficaces.

Optimisation de l'utilisation de l'API

• Mettre en cache l'audio généré - Stockez les résultats pour les requêtes répétées
• Regrouper les requêtes similaires - Combinez les textes courts lorsque c'est possible
• Utiliser des fréquences d'échantillonnage plus basses - 16000 Hz fonctionne bien pour le contenu vocal
• Surveiller avec Apidog - Suivez les modèles d'utilisation et optimisez

Intégration avec les frameworks populaires

Intégration Node.js

const axios = require('axios');
const fs = require('fs');

const API_KEY = process.env.MURF_API_KEY;
const BASE_URL = 'https://api.murf.ai/v1';

async function generateSpeech(text, voiceId, options = {}) {
    try {
        const response = await axios.post(
            `${BASE_URL}/speech`,
            {
                text,
                voiceId,
                format: options.format || 'mp3',
                speed: options.speed || 1.0,
                pitch: options.pitch || 0
            },
            {
                headers: {
                    'api-key': API_KEY,
                    'Content-Type': 'application/json'
                },
                responseType: 'arraybuffer'
            }
        );

        return Buffer.from(response.data);
    } catch (error) {
        console.error('Erreur :', error.response?.data || error.message);
        throw error;
    }
}

// Usage
(async () => {
    const audio = await generateSpeech(
        'Bonjour depuis Node.js !',
        'en-US-marcus'
    );

    fs.writeFileSync('output.mp3', audio);
    console.log('Audio enregistré !');
})();

Intégration Frontend React

import React, { useState } from 'react';

function VoiceGenerator() {
    const [text, setText] = useState('');
    const [voiceId, setVoiceId] = useState('en-US-marcus');
    const [audioUrl, setAudioUrl] = useState(null);
    const [loading, setLoading] = useState(false);

    const generateAudio = async () => {
        setLoading(true);

        try {
            const response = await fetch('/api/synthesize', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ text, voiceId })
            });

            const blob = await response.blob();
            const url = URL.createObjectURL(blob);
            setAudioUrl(url);
        } catch (error) {
            console.error('La génération a échoué :', error);
        } finally {
            setLoading(false);
        }
    };

    return (
        <div className="voice-generator">
            <textarea
                value={text}
                onChange={(e) => setText(e.target.value)}
                placeholder="Entrez le texte à convertir en parole..."
            />

            <select value={voiceId} onChange={(e) => setVoiceId(e.target.value)}>
                <option value="en-US-marcus">Marcus (homme américain)</option>
                <option value="en-US-julia">Julia (femme américaine)</option>
                <option value="en-GB-oliver">Oliver (homme britannique)</option>
            </select>

            <button onClick={generateAudio} disabled={loading}>
                {loading ? 'Génération...' : 'Générer l\'audio'}
            </button>

            {audioUrl && (
                <audio controls src={audioUrl}>
                    Votre navigateur ne prend pas en charge la lecture audio.
                </audio>
            )}
        </div>
    );
}

export default VoiceGenerator;

Conclusion

L'API Murf AI offre aux développeurs de puissantes capacités de synthèse vocale. Des voix off simples aux productions multi-voix complexes, l'API répond à diverses exigences avec une sortie sonore naturelle. Points clés à retenir :

• Authentification - Utilisez les clés API dans les en-têtes de requête pour tous les appels
• Sélection de la voix - Explorez plus de 120 voix dans différentes langues et accents
• Personnalisation - Ajustez la vitesse, la hauteur et utilisez SSML pour un contrôle précis
• Gestion des erreurs - Mettez en œuvre des réessais et un délai d'attente exponentiel pour la production
• Test - Utilisez Apidog pour déboguer et optimiser votre intégration

Commencez par le niveau gratuit pour expérimenter, puis passez à l'échelle supérieure à mesure que votre application se développe. La combinaison de voix de haute qualité et d'une conception d'API conviviale pour les développeurs fait de Murf AI un excellent choix pour les applications à commande vocale.

Prêt à construire ? Téléchargez Apidog pour tester vos appels API Murf AI et optimiser votre flux de travail de développement.