Hướng dẫn sử dụng Murf AI API

Murf AI biến văn bản thành giọng nói tự nhiên với các bản lồng tiếng chất lượng phòng thu. Các nhà phát triển tích hợp API Murf AI để xây dựng các ứng dụng kể chuyện nội dung, tạo phiên bản âm thanh của bài viết, cung cấp năng lượng cho trợ lý ảo và tạo lồng tiếng theo quy mô.

button

Murf AI API là gì?

Murf AI cung cấp dịch vụ chuyển văn bản thành giọng nói (text-to-speech) dựa trên đám mây, chuyển đổi nội dung viết thành âm thanh giống người thật một cách chân thực. Không giống như các công cụ TTS có giọng nói robot, Murf sử dụng công nghệ tổng hợp giọng nói được hỗ trợ bởi AI để tạo ra ngữ điệu tự nhiên, nhấn nhá phù hợp và biểu cảm cảm xúc chân thực.

API này cung cấp chức năng trên cho các nhà phát triển. Các khả năng chính bao gồm:

• Thư viện giọng nói - Truy cập hơn 120 giọng nói AI thuộc nhiều giới tính, độ tuổi và giọng điệu khác nhau
• Hỗ trợ đa ngôn ngữ - Tạo giọng nói bằng hơn 20 ngôn ngữ bao gồm tiếng Anh, tiếng Tây Ban Nha, tiếng Pháp, tiếng Đức và tiếng Hindi
• Tùy chỉnh giọng nói - Điều chỉnh cao độ, tốc độ và nhấn nhá để kiểm soát chính xác
• Nhiều định dạng đầu ra - Xuất âm thanh dưới dạng MP3, WAV hoặc FLAC
• Hỗ trợ SSML - Điều chỉnh cách phát âm bằng Ngôn ngữ đánh dấu tổng hợp giọng nói (Speech Synthesis Markup Language)

Các nhà phát triển sử dụng API Murf AI để lồng tiếng video, sản xuất podcast, hệ thống IVR, tạo sách nói và các tính năng hỗ trợ tiếp cận. API xử lý cả các đoạn văn ngắn và nội dung dài, làm cho nó phù hợp với nhiều trường hợp sử dụng đa dạng.

Bắt đầu với Murf AI API

Trước khi thực hiện các lệnh gọi API, bạn cần thiết lập xác thực. Murf AI sử dụng khóa API để cấp quyền, tuân theo các quy ước REST tiêu chuẩn.

Bước 1: Tạo tài khoản Murf AI

Truy cập murf.ai và đăng ký tài khoản. Murf cung cấp gói miễn phí với số lượng tín dụng hạn chế, hoạt động tốt để kiểm thử API. Để sử dụng trong sản xuất, bạn sẽ cần một gói trả phí bao gồm quyền truy cập API.

Bước 2: Tạo khóa API Murf AI của bạn

Điều hướng đến cài đặt tài khoản của bạn và tìm phần API. Tạo một khóa API mới và lưu trữ nó một cách an toàn. Khóa này xác thực tất cả các yêu cầu của bạn.

Giữ khóa API của bạn bảo mật. Không bao giờ cam kết nó vào kiểm soát phiên bản hoặc để lộ nó trong mã phía client.

Bước 3: Hiểu về URL cơ sở của Murf AI API

Tất cả các yêu cầu API Murf AI đều gửi đến:

https://api.murf.ai/v1

API tuân theo các quy ước RESTful với các thân yêu cầu và phản hồi JSON. Xác thực diễn ra thông qua tiêu đề api-key.

Xác thực Murf AI API

Mỗi yêu cầu API đều cần khóa API của bạn trong các tiêu đề yêu cầu. Định dạng tiêu đề xác thực là:

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

Đây là cách xác thực trông như thế nào trong các ngôn ngữ lập trình khác nhau:

Xác thực Python với Murf AI API

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("Xác thực thành công!")
    voices = response.json()
    print(f"Giọng nói có sẵn: {len(voices)}")
else:
    print(f"Xác thực thất bại: {response.status_code}")

Xác thực JavaScript với Murf AI API

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('Giọng nói có sẵn:', data.length))
    .catch(error => console.error('Xác thực thất bại:', error));

Xác thực cURL với Murf AI API

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

Xác thực thành công sẽ trả về mã trạng thái 200. Các khóa không hợp lệ sẽ trả về 401 Unauthorized.

Lấy danh sách giọng nói có sẵn với Murf AI API

Trước khi tạo giọng nói, hãy truy xuất danh sách các giọng nói có sẵn để chọn một giọng nói phù hợp với trường hợp sử dụng của bạn. Endpoint /voices trả về tất cả các giọng nói có thể truy cập với siêu dữ liệu của chúng.

Liệt kê tất cả giọng nói

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

# Display voice information
for voice in voices[:5]:  # Show first 5 voices
    print(f"Tên: {voice['name']}")
    print(f"ID giọng nói: {voice['voiceId']}")
    print(f"Ngôn ngữ: {voice['language']}")
    print(f"Giới tính: {voice['gender']}")
    print(f"Giọng điệu: {voice.get('accent', 'Không có')}")
    print("---")

Phản hồi bao gồm các thuộc tính giọng nói:

Lọc giọng nói theo ngôn ngữ

# Filter for English voices
english_voices = [v for v in voices if v['language'].startswith('en')]
print(f"Giọng nói tiếng Anh có sẵn: {len(english_voices)}")

# Filter for Spanish voices
spanish_voices = [v for v in voices if v['language'].startswith('es')]
print(f"Giọng nói tiếng Tây Ban Nha có sẵn: {len(spanish_voices)}")

Tạo giọng nói từ văn bản

Chức năng cốt lõi của Murf AI API là chuyển đổi văn bản thành giọng nói. Endpoint /speech chấp nhận các tham số văn bản và giọng nói, trả về một tệp âm thanh.

Yêu cầu chuyển văn bản thành giọng nói cơ bản

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": "Chào mừng đến với ứng dụng của chúng tôi. Âm thanh này được tạo bằng 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("Âm thanh đã được lưu vào output.mp3")
else:
    print(f"Lỗi: {response.status_code} - {response.text}")

Tham số yêu cầu

Điều chỉnh tốc độ và cao độ giọng nói

payload = {
    "text": "Văn bản này được nói với tốc độ chậm hơn và cao độ thấp hơn.",
    "voiceId": "en-US-marcus",
    "format": "mp3",
    "speed": 0.8,    # 80% của tốc độ bình thường
    "pitch": -2      # Cao độ thấp hơn một chút
}

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

Sử dụng SSML để kiểm soát nâng cao

Ngôn ngữ đánh dấu tổng hợp giọng nói (SSML) cung cấp khả năng kiểm soát chi tiết về cách phát âm, tạm dừng, nhấn nhá và nhiều hơn nữa. Murf AI API hỗ trợ các thẻ SSML để xuất âm thanh chất lượng chuyên nghiệp.

Ví dụ SSML

ssml_text = """
<speak>
    Chào mừng đến với <emphasis level="strong">Murf AI</emphasis>.
    <break time="500ms"/>
    Công nghệ chuyển văn bản thành giọng nói của chúng tôi tạo ra âm thanh <prosody rate="slow">tự nhiên</prosody>.
    <break time="300ms"/>
    Từ <phoneme alphabet="ipa" ph="ˈdeɪtə">data</phoneme> được phát âm chính xác.
</speak>
"""

payload = {
    "text": ssml_text,
    "voiceId": "en-US-julia",
    "format": "mp3",
    "ssml": True  # Enable SSML parsing
}

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

Các thẻ SSML thông dụng

Kiểm thử Murf AI API với Apidog

Trước khi viết mã tích hợp, hãy kiểm thử các lệnh gọi API của bạn một cách tương tác. Apidog cung cấp một giao diện trực quan để tạo yêu cầu, kiểm tra phản hồi và gỡ lỗi.

Thiết lập Apidog cho Murf AI

1. Tải xuống và cài đặt Apidog

Tải Apidog miễn phí. Nó hỗ trợ Windows, Mac, Linux và trình duyệt web.

button

2. Tạo một dự án mới

Bắt đầu một dự án mới có tên "Murf AI Integration". Điều này giúp bạn sắp xếp các endpoint API của mình.

3. Thiết lập biến môi trường

Tạo một môi trường với khóa API của bạn:

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

Các biến môi trường giữ dữ liệu nhạy cảm tách biệt khỏi cấu hình yêu cầu.

4. Tạo yêu cầu đầu tiên của bạn

Thêm một yêu cầu POST mới với các cài đặt sau:

• URL: {{baseUrl}}/speech
• Tiêu đề:
• api-key: {{apiKey}}
• Content-Type: application/json
• Thân (JSON):

{
    "text": "Đang kiểm thử Murf AI API với Apidog. Đây là một bản lồng tiếng mẫu.",
    "voiceId": "en-US-marcus",
    "format": "mp3"
}

5. Gửi và kiểm tra phản hồi

Nhấp vào Gửi. Apidog hiển thị trạng thái phản hồi, tiêu đề và cho phép bạn tải xuống tệp âm thanh đã tạo trực tiếp.

Gỡ lỗi các vấn đề thường gặp với Apidog

Tính năng lịch sử yêu cầu của Apidog cho phép bạn so sánh các yêu cầu thành công và thất bại cạnh nhau, giúp việc gỡ lỗi trở nên đơn giản.

Xử lý nội dung dài với Murf AI API

Đối với các bài viết, bài đăng trên blog hoặc các chương sách, bạn có thể cần xử lý văn bản theo từng đoạn. Murf AI có giới hạn ký tự cho mỗi yêu cầu, vì vậy việc chia nhỏ nội dung đảm bảo quá trình xử lý đáng tin cậy.

Chiến lược chia nhỏ

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):
    """Split text into chunks at sentence boundaries."""
    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"):
    """Generate audio for long-form content."""
    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"Đã tạo: {filename}")
        else:
            print(f"Lỗi đoạn {i+1}: {response.status_code}")

    return audio_files

# Example usage
long_text = """
Nội dung bài viết hoặc tài liệu dài của bạn sẽ được đặt ở đây.
Nó có thể kéo dài qua nhiều đoạn văn và trang.
Hàm này sẽ tự động chia nhỏ nó tại các ranh giới câu.
"""

audio_files = generate_long_audio(long_text, "en-US-marcus", "article_audio")
print(f"Đã tạo {len(audio_files)} tệp âm thanh")

Nối các tệp âm thanh với Murf AI API

Sau khi tạo các đoạn, hãy kết hợp chúng thành một tệp duy nhất bằng FFmpeg hoặc thư viện Python:

from pydub import AudioSegment

def concatenate_audio(file_list, output_file="final_audio.mp3"):
    """Combine multiple audio files into one."""
    combined = AudioSegment.empty()

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

    combined.export(output_file, format="mp3")
    print(f"Âm thanh kết hợp đã được lưu vào {output_file}")
    return output_file

# Combine the chunks
concatenate_audio(audio_files, "complete_article.mp3")

Các phương pháp hay nhất về xử lý lỗi với Murf AI API

Các ứng dụng sản xuất cần xử lý lỗi mạnh mẽ. Murf AI API trả về các mã trạng thái HTTP tiêu chuẩn với thông báo lỗi mô tả.

Các mã lỗi thường gặp

Client API mạnh mẽ

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]:
        """Make API request with retry logic."""
        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:
                    # Rate limited - wait and retry
                    wait_time = 2 ** attempt
                    print(f"Bị giới hạn tốc độ. Đang chờ {wait_time}s...")
                    time.sleep(wait_time)
                elif response.status_code >= 500:
                    # Server error - retry
                    time.sleep(1)
                else:
                    # Client error - don't retry
                    print(f"Lỗi {response.status_code}: {response.text}")
                    return None

            except requests.RequestException as e:
                print(f"Yêu cầu thất bại: {e}")
                time.sleep(1)

        return None

    def get_voices(self) -> list:
        """Fetch available voices."""
        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]:
        """Generate speech from text."""
        payload = {
            "text": text,
            "voiceId": voice_id,
            "format": format,
            **kwargs
        }
        response = self._request("POST", "speech", payload)
        return response.content if response else None

# Usage
client = MurfAPIClient("your_api_key")
voices = client.get_voices()
audio = client.generate_speech(
    "Xin chào thế giới!",
    "en-US-marcus",
    speed=1.0
)

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

Xây dựng dịch vụ tạo lồng tiếng

Hãy xây dựng một API Flask hoàn chỉnh tích hợp Murf AI cho các ứng dụng của bạn:

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():
    """List available voices."""
    language = request.args.get("language")

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

    if response.status_code != 200:
        return jsonify({"error": "Failed to fetch voices"}), 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():
    """Generate speech from text."""
    data = request.json

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

    if "voiceId" not in data:
        return jsonify({"error": "Missing 'voiceId' field"}), 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": "Speech generation failed"}), 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)

Dịch vụ này cung cấp hai endpoint: một để liệt kê các giọng nói và một để tạo giọng nói. Bạn có thể mở rộng nó với tính năng caching, xác thực và xử lý dựa trên hàng đợi cho việc sử dụng trong sản xuất.

Giới hạn tốc độ và cân nhắc về giá cho Murf AI API

Murf AI áp dụng giới hạn tốc độ dựa trên gói đăng ký của bạn. Việc hiểu các giới hạn này giúp bạn thiết kế các ứng dụng hiệu quả.

Tối ưu hóa việc sử dụng API

• Lưu trữ âm thanh đã tạo vào bộ đệm (cache) - Lưu trữ kết quả cho các yêu cầu lặp lại
• Gộp các yêu cầu tương tự - Kết hợp các văn bản ngắn khi có thể
• Sử dụng tốc độ lấy mẫu thấp hơn - 16000 Hz hoạt động tốt cho nội dung giọng nói
• Giám sát với Apidog - Theo dõi các mẫu sử dụng và tối ưu hóa

Tích hợp với các framework phổ biến

Tích hợp 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('Lỗi:', error.response?.data || error.message);
        throw error;
    }
}

// Usage
(async () => {
    const audio = await generateSpeech(
        'Xin chào từ Node.js!',
        'en-US-marcus'
    );

    fs.writeFileSync('output.mp3', audio);
    console.log('Âm thanh đã được lưu!');
})();

Tích hợp React Frontend

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('Tạo thất bại:', error);
        } finally {
            setLoading(false);
        }
    };

    return (
        <div className="voice-generator">
            <textarea
                value={text}
                onChange={(e) => setText(e.target.value)}
                placeholder="Nhập văn bản để chuyển đổi thành giọng nói..."
            />

            <select value={voiceId} onChange={(e) => setVoiceId(e.target.value)}>
                <option value="en-US-marcus">Marcus (Nam Mỹ)</option>
                <option value="en-US-julia">Julia (Nữ Mỹ)</option>
                <option value="en-GB-oliver">Oliver (Nam Anh)</option>
            </select>

            <button onClick={generateAudio} disabled={loading}>
                {loading ? 'Đang tạo...' : 'Tạo Âm thanh'}
            </button>

            {audioUrl && (
                <audio controls src={audioUrl}>
                    Trình duyệt của bạn không hỗ trợ phát âm thanh.
                </audio>
            )}
        </div>
    );
}

export default VoiceGenerator;

Kết luận

Murf AI API mở ra khả năng chuyển văn bản thành giọng nói mạnh mẽ cho các nhà phát triển. Từ lồng tiếng đơn giản đến sản xuất đa giọng phức tạp, API xử lý các yêu cầu đa dạng với đầu ra âm thanh tự nhiên. Các điểm chính cần ghi nhớ:

• Xác thực - Sử dụng khóa API trong tiêu đề yêu cầu cho tất cả các lệnh gọi
• Chọn giọng nói - Khám phá hơn 120 giọng nói thuộc nhiều ngôn ngữ và giọng điệu
• Tùy chỉnh - Điều chỉnh tốc độ, cao độ và sử dụng SSML để kiểm soát chính xác
• Xử lý lỗi - Triển khai tính năng thử lại và exponential backoff cho sản xuất
• Kiểm thử - Sử dụng Apidog để gỡ lỗi và tối ưu hóa tích hợp của bạn

Hãy bắt đầu với gói miễn phí để thử nghiệm, sau đó mở rộng quy mô khi ứng dụng của bạn phát triển. Sự kết hợp giữa giọng nói chất lượng cao và thiết kế API thân thiện với nhà phát triển làm cho Murf AI trở thành một lựa chọn vững chắc cho các ứng dụng hỗ trợ giọng nói.

Sẵn sàng xây dựng? Tải xuống Apidog để kiểm thử các lệnh gọi Murf AI API của bạn và hợp lý hóa quy trình phát triển của bạn.

button