Cara Menggunakan Murf AI API: Panduan Lengkap

Murf AI mengubah teks menjadi ucapan yang terdengar alami dengan sulih suara berkualitas studio. Developer mengintegrasikan Murf AI API untuk membangun aplikasi yang menarasikan konten, membuat versi audio artikel, mendukung asisten virtual, dan menghasilkan sulih suara dalam skala besar.

Apa Itu Murf AI API?

Murf AI menyediakan layanan text-to-speech berbasis cloud yang mengubah konten tertulis menjadi audio realistis yang mirip manusia. Berbeda dengan mesin TTS yang terdengar robotik, Murf menggunakan sintesis suara bertenaga AI untuk menghasilkan intonasi alami, penekanan yang tepat, dan ekspresi emosional yang autentik.

API ini mengekspos fungsionalitas ini untuk para developer. Kemampuan utamanya meliputi:

• Pustaka Suara - Akses 120+ suara AI yang mencakup berbagai jenis kelamin, usia, dan aksen
• Dukungan Multi-bahasa - Hasilkan ucapan dalam 20+ bahasa termasuk Inggris, Spanyol, Prancis, Jerman, dan Hindi
• Kustomisasi Suara - Sesuaikan nada, kecepatan, dan penekanan untuk kontrol yang tepat
• Berbagai Format Output - Ekspor audio sebagai MP3, WAV, atau FLAC
• Dukungan SSML - Sempurnakan pelafalan menggunakan Speech Synthesis Markup Language

Developer menggunakan Murf AI API untuk narasi video, produksi podcast, sistem IVR, pembuatan buku audio, dan fitur aksesibilitas. API ini menangani cuplikan pendek dan konten bentuk panjang, sehingga cocok untuk beragam kasus penggunaan.

Memulai dengan Murf AI API

Sebelum melakukan panggilan API, Anda perlu menyiapkan autentikasi. Murf AI menggunakan kunci API untuk otorisasi, mengikuti konvensi REST standar.

Langkah 1: Membuat Akun Murf AI

Kunjungi murf.ai dan daftar akun. Murf menawarkan tingkatan gratis dengan kredit terbatas, yang berfungsi baik untuk menguji API. Untuk penggunaan produksi, Anda akan memerlukan paket berbayar yang mencakup akses API.

Langkah 2: Hasilkan Kunci API Murf AI Anda

Navigasikan ke pengaturan akun Anda dan temukan bagian API. Hasilkan kunci API baru dan simpan dengan aman. Kunci ini mengautentikasi semua permintaan Anda.

Jaga kerahasiaan kunci API Anda. Jangan pernah memasukkannya ke kontrol versi atau mengeksposnya dalam kode sisi klien.

Langkah 3: Memahami URL Dasar Murf AI API

Semua permintaan Murf AI API ditujukan ke:

https://api.murf.ai/v1

API ini mengikuti konvensi RESTful dengan badan permintaan dan respons JSON. Autentikasi terjadi melalui header api-key.

Autentikasi Murf AI API

Setiap permintaan API memerlukan kunci API Anda di header permintaan. Format header autentikasi adalah:

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

Berikut adalah tampilan autentikasi dalam berbagai bahasa pemrograman:

Autentikasi Python dengan 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("Authentication successful!")
    voices = response.json()
    print(f"Available voices: {len(voices)}")
else:
    print(f"Authentication failed: {response.status_code}")

Autentikasi JavaScript dengan 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('Voices available:', data.length))
    .catch(error => console.error('Auth failed:', error));

Autentikasi cURL dengan Murf AI API

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

Autentikasi yang berhasil mengembalikan kode status 200. Kunci yang tidak valid mengembalikan 401 Unauthorized.

Mengambil Suara yang Tersedia dengan Murf AI API

Sebelum menghasilkan ucapan, ambil daftar suara yang tersedia untuk memilih yang sesuai dengan kasus penggunaan Anda. Endpoint /voices mengembalikan semua suara yang dapat diakses beserta metadatanya.

Daftar Semua Suara

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

Respons tersebut mencakup properti suara:

Filter Suara berdasarkan Bahasa

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

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

Menghasilkan Ucapan dari Teks

Fungsionalitas inti Murf AI API adalah mengubah teks menjadi ucapan. Endpoint /speech menerima parameter teks dan suara, mengembalikan file audio.

Permintaan Text-to-Speech Dasar

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": "Welcome to our application. This audio was generated using 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 saved to output.mp3")
else:
    print(f"Error: {response.status_code} - {response.text}")

Parameter Permintaan

Menyesuaikan Kecepatan dan Nada Suara

payload = {
    "text": "This text is spoken at a slower pace with a lower pitch.",
    "voiceId": "en-US-marcus",
    "format": "mp3",
    "speed": 0.8,    # 80% of normal speed
    "pitch": -2      # Slightly lower pitch
}

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

Menggunakan SSML untuk Kontrol Tingkat Lanjut

Speech Synthesis Markup Language (SSML) menyediakan kontrol terperinci atas pelafalan, jeda, penekanan, dan lainnya. Murf AI API mendukung tag SSML untuk output audio berkualitas profesional.

Contoh SSML

ssml_text = """
<speak>
    Welcome to <emphasis level="strong">Murf AI</emphasis>.
    <break time="500ms"/>
    Our text-to-speech technology creates <prosody rate="slow">natural sounding</prosody> audio.
    <break time="300ms"/>
    The word <phoneme alphabet="ipa" ph="ˈdeɪtə">data</phoneme> is pronounced correctly.
</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)

Tag SSML Umum

Menguji Murf AI API dengan Apidog

Sebelum menulis kode integrasi, uji panggilan API Anda secara interaktif. Apidog menyediakan antarmuka visual untuk membuat permintaan, memeriksa respons, dan men-debug masalah.

Menyiapkan Apidog untuk Murf AI

1. Unduh dan Instal Apidog

Dapatkan Apidog secara gratis. Ini mendukung Windows, Mac, Linux, dan peramban web.

2. Buat Proyek Baru

Mulai proyek baru bernama "Integrasi Murf AI". Ini menjaga endpoint API Anda tetap terorganisir.

3. Siapkan Variabel Lingkungan

Buat lingkungan dengan kunci API Anda:

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

Variabel lingkungan menjaga data sensitif terpisah dari konfigurasi permintaan.

4. Buat Permintaan Pertama Anda

Tambahkan permintaan POST baru dengan pengaturan ini:

• URL: {{baseUrl}}/speech
• Headers:
• api-key: {{apiKey}}
• Content-Type: application/json
• Body (JSON):

{
    "text": "Menguji Murf AI API dengan Apidog. Ini adalah contoh sulih suara.",
    "voiceId": "en-US-marcus",
    "format": "mp3"
}

5. Kirim dan Periksa Respons

Klik Kirim. Apidog menampilkan status respons, header, dan memungkinkan Anda mengunduh file audio yang dihasilkan secara langsung.

Mendebug Masalah Umum dengan Apidog

Fitur riwayat permintaan Apidog memungkinkan Anda membandingkan permintaan yang berhasil dan gagal secara berdampingan, membuat debugging menjadi mudah.

Menangani Konten Bentuk Panjang dengan Murf AI API

Untuk artikel, posting blog, atau bab buku, Anda mungkin perlu memproses teks dalam potongan-potongan. Murf AI memiliki batasan karakter per permintaan, jadi membagi konten memastikan pemrosesan yang andal.

Strategi Pemotongan

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"Generated: {filename}")
        else:
            print(f"Failed chunk {i+1}: {response.status_code}")

    return audio_files

# Example usage
long_text = """
Konten artikel atau dokumen panjang Anda ada di sini.
Ini dapat mencakup beberapa paragraf dan halaman.
Fungsi ini memisahkannya secara otomatis pada batas kalimat.
"""

audio_files = generate_long_audio(long_text, "en-US-marcus", "article_audio")
print(f"Generated {len(audio_files)} audio files")

Menggabungkan File Audio dengan Murf AI API

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"Combined audio saved to {output_file}")
    return output_file

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

Praktik Terbaik Penanganan Kesalahan dengan Murf AI API

Aplikasi produksi memerlukan penanganan kesalahan yang kuat. Murf AI API mengembalikan kode status HTTP standar dengan pesan kesalahan yang deskriptif.

Kode Kesalahan Umum

Klien API yang Robust

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"Rate limited. Waiting {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"Error {response.status_code}: {response.text}")
                    return None

            except requests.RequestException as e:
                print(f"Request failed: {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(
    "Hello world!",
    "en-US-marcus",
    speed=1.0
)

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

Membangun Layanan Pembuatan Sulih Suara

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