Como Usar a API da Murf AI

O Murf AI transforma texto em fala com som natural e narrações com qualidade de estúdio. Desenvolvedores integram a API do Murf AI para construir aplicações que narram conteúdo, criam versões em áudio de artigos, alimentam assistentes virtuais e geram narrações em escala.

O que é a API Murf AI?

Murf AI fornece um serviço de texto para fala baseado em nuvem que converte conteúdo escrito em áudio realista e semelhante ao humano. Diferente dos mecanismos de TTS com som robótico, o Murf usa síntese de voz alimentada por IA para produzir entonação natural, ênfase adequada e expressão emocional autêntica.

A API expõe essa funcionalidade para desenvolvedores. As principais capacidades incluem:

• Biblioteca de Vozes - Acesse mais de 120 vozes de IA abrangendo diferentes gêneros, idades e sotaques
• Suporte a Múltiplos Idiomas - Gere fala em mais de 20 idiomas, incluindo inglês, espanhol, francês, alemão e hindi
• Personalização de Voz - Ajuste tom, velocidade e ênfase para controle preciso
• Múltiplos Formatos de Saída - Exporte áudio como MP3, WAV ou FLAC
• Suporte SSML - Ajuste a pronúncia usando a Speech Synthesis Markup Language

Desenvolvedores usam a API Murf AI para narração de vídeo, produção de podcast, sistemas IVR, geração de audiolivros e recursos de acessibilidade. A API lida tanto com trechos curtos quanto com conteúdo de formato longo, tornando-a adequada para diversos casos de uso.

Introdução à API Murf AI

Antes de fazer chamadas à API, você precisa configurar a autenticação. O Murf AI usa chaves de API para autorização, seguindo as convenções REST padrão.

Passo 1: Crie uma Conta Murf AI

Visite murf.ai e registre-se para uma conta. O Murf oferece um plano gratuito com créditos limitados, o que funciona bem para testar a API. Para uso em produção, você precisará de um plano pago que inclua acesso à API.

Passo 2: Gere sua Chave de API Murf AI

Navegue até as configurações da sua conta e localize a seção de API. Gere uma nova chave de API e armazene-a com segurança. Esta chave autentica todas as suas requisições.

Mantenha sua chave de API confidencial. Nunca a publique no controle de versão ou a exponha em código do lado do cliente.

Passo 3: Entenda a URL Base da API Murf AI

Todas as requisições da API Murf AI vão para:

https://api.murf.ai/v1

A API segue as convenções RESTful com corpos de requisição e resposta em JSON. A autenticação ocorre via o cabeçalho api-key.

Autenticação da API Murf AI

Cada requisição à API exige sua chave de API nos cabeçalhos da requisição. O formato do cabeçalho de autenticação é:

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

Veja como a autenticação aparece em diferentes linguagens de programação:

Autenticação Python com a 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"
}

# Teste de autenticação buscando as vozes disponíveis
response = requests.get(f"{BASE_URL}/voices", headers=headers)

if response.status_code == 200:
    print("Autenticação bem-sucedida!")
    voices = response.json()
    print(f"Vozes disponíveis: {len(voices)}")
else:
    print(f"Autenticação falhou: {response.status_code}")

Autenticação JavaScript com a 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'
};

// Teste de autenticação
fetch(`${BASE_URL}/voices`, { headers })
    .then(response => response.json())
    .then(data => console.log('Vozes disponíveis:', data.length))
    .catch(error => console.error('Autenticação falhou:', error));

Autenticação cURL com a API Murf AI

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

Uma autenticação bem-sucedida retorna um código de status 200. Chaves inválidas retornam 401 Não Autorizado.

Obtendo Vozes Disponíveis com a API Murf AI

Antes de gerar a fala, recupere a lista de vozes disponíveis para selecionar uma que se adapte ao seu caso de uso. O endpoint /voices retorna todas as vozes acessíveis com seus metadados.

Listar Todas as Vozes

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()

# Exibir informações da voz
for voice in voices[:5]:  # Mostrar as 5 primeiras vozes
    print(f"Nome: {voice['name']}")
    print(f"ID da Voz: {voice['voiceId']}")
    print(f"Idioma: {voice['language']}")
    print(f"Gênero: {voice['gender']}")
    print(f"Sotaque: {voice.get('accent', 'N/A')}")
    print("---")

A resposta inclui propriedades da voz:

Filtrar Vozes por Idioma

# Filtrar por vozes em inglês
english_voices = [v for v in voices if v['language'].startswith('en')]
print(f"Vozes em inglês disponíveis: {len(english_voices)}")

# Filtrar por vozes em espanhol
spanish_voices = [v for v in voices if v['language'].startswith('es')]
print(f"Vozes em espanhol disponíveis: {len(spanish_voices)}")

Gerando Fala a Partir de Texto

A funcionalidade central da API Murf AI é converter texto em fala. O endpoint /speech aceita parâmetros de texto e voz, retornando um arquivo de áudio.

Requisição Básica de Texto para Fala

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": "Bem-vindo(a) ao nosso aplicativo. Este áudio foi gerado usando 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:
    # Salvar o arquivo de áudio
    with open("output.mp3", "wb") as f:
        f.write(response.content)
    print("Áudio salvo em output.mp3")
else:
    print(f"Erro: {response.status_code} - {response.text}")

Parâmetros de Requisição

Ajustando a Velocidade e o Tom da Voz

payload = {
    "text": "Este texto é falado em um ritmo mais lento e com um tom mais baixo.",
    "voiceId": "en-US-marcus",
    "format": "mp3",
    "speed": 0.8,    # 80% da velocidade normal
    "pitch": -2      # Tom ligeiramente mais baixo
}

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

Usando SSML para Controle Avançado

Speech Synthesis Markup Language (SSML) fornece controle preciso sobre pronúncia, pausas, ênfase e muito mais. A API Murf AI suporta tags SSML para saída de áudio de nível profissional.

Exemplo de SSML

ssml_text = """
<speak>
    Bem-vindo(a) ao <emphasis level="strong">Murf AI</emphasis>.
    <break time="500ms"/>
    Nossa tecnologia de texto para fala cria áudio <prosody rate="slow">com som natural</prosody>.
    <break time="300ms"/>
    A palavra <phoneme alphabet="ipa" ph="ˈdeɪtə">dados</phoneme> é pronunciada corretamente.
</speak>
"""

payload = {
    "text": ssml_text,
    "voiceId": "en-US-julia",
    "format": "mp3",
    "ssml": True  # Habilitar análise de SSML
}

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

Tags SSML Comuns

Testando a API Murf AI com Apidog

Antes de escrever o código de integração, teste suas chamadas de API interativamente. O Apidog oferece uma interface visual para criar requisições, inspecionar respostas e depurar problemas.

Configurando o Apidog para Murf AI

1. Baixe e Instale o Apidog

Obtenha o Apidog gratuitamente. Ele suporta Windows, Mac, Linux e navegadores web.

2. Crie um Novo Projeto

Inicie um novo projeto chamado "Murf AI Integration". Isso mantém seus endpoints de API organizados.

3. Configure as Variáveis de Ambiente

Crie um ambiente com sua chave de API:

{
    "baseUrl": "https://api.murf.ai/v1",
    "apiKey": "your_murf_api_key"
}

As variáveis de ambiente mantêm dados sensíveis separados das configurações de requisição.

4. Crie Sua Primeira Requisição

Adicione uma nova requisição POST com estas configurações:

• URL: {{baseUrl}}/speech
• Cabeçalhos:
• api-key: {{apiKey}}
• Content-Type: application/json
• Corpo (JSON):

{
    "text": "Testando a API Murf AI com Apidog. Esta é uma narração de exemplo.",
    "voiceId": "en-US-marcus",
    "format": "mp3"
}

5. Envie e Inspecione a Resposta

Clique em Enviar. O Apidog exibe o status da resposta, os cabeçalhos e permite baixar o arquivo de áudio gerado diretamente.

Depurando Problemas Comuns com Apidog

O recurso de histórico de requisições do Apidog permite comparar requisições bem-sucedidas e falhas lado a lado, tornando a depuração simples.

Lidando com Conteúdo de Longo Formato com a API Murf AI

Para artigos, posts de blog ou capítulos de livros, pode ser necessário processar o texto em partes. O Murf AI tem limites de caracteres por requisição, então dividir o conteúdo garante um processamento confiável.

Estratégia de Fragmentação (Chunking)

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):
    """Divide o texto em pedaços nos limites das frases."""
    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"):
    """Gera áudio para conteúdo de longo formato."""
    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"Gerado: {filename}")
        else:
            print(f"Fragmento {i+1} falhou: {response.status_code}")

    return audio_files

# Exemplo de uso
long_text = """
Seu artigo longo ou conteúdo de documento vai aqui.
Ele pode abranger vários parágrafos e páginas.
A função o divide automaticamente nos limites das frases.
"""

audio_files = generate_long_audio(long_text, "en-US-marcus", "article_audio")
print(f"Gerados {len(audio_files)} arquivos de áudio")

Concatenando Arquivos de Áudio com a API Murf AI

Depois de gerar os fragmentos, combine-os em um único arquivo usando FFmpeg ou uma biblioteca Python:

from pydub import AudioSegment

def concatenate_audio(file_list, output_file="final_audio.mp3"):
    """Combina múltiplos arquivos de áudio em um."""
    combined = AudioSegment.empty()

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

    combined.export(output_file, format="mp3")
    print(f"Áudio combinado salvo em {output_file}")
    return output_file

# Combinar os fragmentos
concatenate_audio(audio_files, "complete_article.mp3")

Melhores Práticas de Tratamento de Erros com a API Murf AI

Aplicações em produção precisam de um tratamento de erros robusto. A API Murf AI retorna códigos de status HTTP padrão com mensagens de erro descritivas.

Códigos de Erro Comuns

Cliente API Robusto

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]:
        """Faz requisições à API com lógica de repetição."""
        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:
                    # Limite de taxa atingido - espere e tente novamente
                    wait_time = 2 ** attempt
                    print(f"Limite de taxa atingido. Esperando {wait_time}s...")
                    time.sleep(wait_time)
                elif response.status_code >= 500:
                    # Erro de servidor - tente novamente
                    time.sleep(1)
                else:
                    # Erro de cliente - não tente novamente
                    print(f"Erro {response.status_code}: {response.text}")
                    return None

            except requests.RequestException as e:
                print(f"Requisição falhou: {e}")
                time.sleep(1)

        return None

    def get_voices(self) -> list:
        """Busca as vozes disponíveis."""
        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]:
        """Gera fala a partir de texto."""
        payload = {
            "text": text,
            "voiceId": voice_id,
            "format": format,
            **kwargs
        }
        response = self._request("POST", "speech", payload)
        return response.content if response else None

# Uso
client = MurfAPIClient("your_api_key")
voices = client.get_voices()
audio = client.generate_speech(
    "Olá mundo!",
    "en-US-marcus",
    speed=1.0
)

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

Construindo um Serviço de Geração de Locução

Vamos construir uma API Flask completa que envolve o Murf AI para suas aplicações:

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():
    """Lista as vozes disponíveis."""
    language = request.args.get("language")

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

    if response.status_code != 200:
        return jsonify({"error": "Falha ao buscar vozes"}), 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():
    """Gera fala a partir de texto."""
    data = request.json

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

    if "voiceId" not in data:
        return jsonify({"error": "Campo 'voiceId' ausente"}), 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": "Falha na geração da fala"}), 500

    # Salvar em arquivo temporário
    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)

Este serviço expõe dois endpoints: um para listar vozes e outro para gerar fala. Você pode estendê-lo com cache, autenticação e processamento baseado em fila para uso em produção.

Considerações sobre Limites de Taxa e Preços para a API Murf AI

O Murf AI impõe limites de taxa com base no seu plano de assinatura. Compreender esses limites ajuda você a projetar aplicações eficientes.

Otimizando o Uso da API

• Armazene áudio gerado em cache - Armazene os resultados para requisições repetidas
• Agrupe requisições semelhantes - Combine textos curtos sempre que possível
• Use taxas de amostragem mais baixas - 16000 Hz funciona bem para conteúdo de voz
• Monitore com Apidog - Acompanhe padrões de uso e otimize

Integrando com Frameworks Populares

Integração 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('Erro:', error.response?.data || error.message);
        throw error;
    }
}

// Uso
(async () => {
    const audio = await generateSpeech(
        'Olá do Node.js!',
        'en-US-marcus'
    );

    fs.writeFileSync('output.mp3', audio);
    console.log('Áudio salvo!');
})();

Integração com 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('Falha na geração:', error);
        } finally {
            setLoading(false);
        }
    };

    return (
        <div className="voice-generator">
            <textarea
                value={text}
                onChange={(e) => setText(e.target.value)}
                placeholder="Digite o texto para converter em fala..."
            />

            <select value={voiceId} onChange={(e) => setVoiceId(e.target.value)}>
                <option value="en-US-marcus">Marcus (Masculino EUA)</option>
                <option value="en-US-julia">Julia (Feminino EUA)</option>
                <option value="en-GB-oliver">Oliver (Masculino Reino Unido)</option>
            </select>

            <button onClick={generateAudio} disabled={loading}>
                {loading ? 'Gerando...' : 'Gerar Áudio'}
            </button>

            {audioUrl && (
                <audio controls src={audioUrl}>
                    Seu navegador não suporta a reprodução de áudio.
                </audio>
            )}
        </div>
    );
}

export default VoiceGenerator;

Conclusão

A API Murf AI oferece poderosas capacidades de texto para fala para desenvolvedores. De narrações simples a produções complexas com múltiplas vozes, a API lida com diversos requisitos com saída de som natural. Principais pontos a destacar:

• Autenticação - Use chaves de API nos cabeçalhos de requisição para todas as chamadas
• Seleção de Voz - Explore mais de 120 vozes em vários idiomas e sotaques
• Personalização - Ajuste velocidade, tom e use SSML para controle preciso
• Tratamento de Erros - Implemente novas tentativas e backoff exponencial para produção
• Testes - Use Apidog para depurar e otimizar sua integração

Comece com o nível gratuito para experimentar, depois escale conforme sua aplicação cresce. A combinação de vozes de alta qualidade e design de API amigável ao desenvolvedor torna o Murf AI uma escolha sólida para aplicações habilitadas para voz.

Pronto para construir? Baixe o Apidog para testar suas chamadas à API Murf AI e otimizar seu fluxo de trabalho de desenvolvimento.