วิธีใช้ Murf AI API

Murf AI เปลี่ยนข้อความเป็นคำพูดที่เป็นธรรมชาติพร้อมเสียงพากย์คุณภาพระดับสตูดิโอ นักพัฒนาสามารถผสานรวม Murf AI API เพื่อสร้างแอปพลิเคชันที่บรรยายเนื้อหา สร้างไฟล์เสียงจากบทความ ขับเคลื่อนผู้ช่วยเสมือน และสร้างเสียงพากย์ได้ในปริมาณมาก

Murf AI API คืออะไร?

Murf AI ให้บริการข้อความเป็นคำพูดบนคลาวด์ที่แปลงเนื้อหาที่เป็นลายลักษณ์อักษรให้เป็นเสียงที่เหมือนมนุษย์จริง ไม่เหมือนกับเครื่องมือ TTS ที่มีเสียงเหมือนหุ่นยนต์ Murf ใช้การสังเคราะห์เสียงที่ขับเคลื่อนด้วย AI เพื่อสร้างน้ำเสียงที่เป็นธรรมชาติ การเน้นคำที่เหมาะสม และการแสดงอารมณ์ที่แท้จริง

API นี้เปิดเผยฟังก์ชันการทำงานสำหรับนักพัฒนา ความสามารถหลัก ได้แก่:

• คลังเสียง - เข้าถึงเสียง AI มากกว่า 120 เสียงที่ครอบคลุมเพศ อายุ และสำเนียงที่แตกต่างกัน
• รองรับหลายภาษา - สร้างเสียงพูดในกว่า 20 ภาษา รวมถึงอังกฤษ สเปน ฝรั่งเศส เยอรมัน และฮินดี
• การปรับแต่งเสียง - ปรับระดับเสียง ความเร็ว และการเน้นเพื่อการควบคุมที่แม่นยำ
• รูปแบบเอาต์พุตที่หลากหลาย - ส่งออกไฟล์เสียงเป็น MP3, WAV หรือ FLAC
• รองรับ SSML - ปรับแต่งการออกเสียงโดยใช้ Speech Synthesis Markup Language

นักพัฒนาใช้ Murf AI API สำหรับการบรรยายวิดีโอ การผลิตพอดคาสต์ ระบบ IVR การสร้างหนังสือเสียง และคุณสมบัติการเข้าถึง API รองรับทั้งข้อความสั้นๆ และเนื้อหาแบบยาว ทำให้เหมาะสำหรับการใช้งานที่หลากหลาย

เริ่มต้นใช้งาน Murf AI API

ก่อนทำการเรียก API คุณต้องตั้งค่าการรับรองความถูกต้อง Murf AI ใช้คีย์ API สำหรับการอนุญาต โดยเป็นไปตามข้อกำหนด REST มาตรฐาน

ขั้นตอนที่ 1: สร้างบัญชี Murf AI

ไปที่ murf.ai และลงทะเบียนบัญชี Murf มีแพ็กเกจฟรีพร้อมเครดิตจำกัด ซึ่งเหมาะสำหรับการทดสอบ API สำหรับการใช้งานจริง คุณจะต้องใช้แผนแบบชำระเงินที่รวมการเข้าถึง API

ขั้นตอนที่ 2: สร้างคีย์ Murf AI API ของคุณ

ไปที่การตั้งค่าบัญชีของคุณและค้นหาส่วน API สร้าง คีย์ API ใหม่และจัดเก็บไว้อย่างปลอดภัย คีย์นี้จะใช้ในการรับรองความถูกต้องคำขอทั้งหมดของคุณ

เก็บคีย์ API ของคุณเป็นความลับ ห้ามคอมมิตเข้าสู่ระบบควบคุมเวอร์ชันหรือเปิดเผยในโค้ดฝั่งไคลเอ็นต์

ขั้นตอนที่ 3: ทำความเข้าใจ URL พื้นฐานของ Murf AI API

คำขอ Murf AI API ทั้งหมดจะถูกส่งไปยัง:

https://api.murf.ai/v1

API เป็นไปตามข้อกำหนด RESTful โดยใช้เนื้อหาคำขอและการตอบกลับแบบ JSON การรับรองความถูกต้องเกิดขึ้นผ่านส่วนหัว api-key

การรับรองความถูกต้องของ Murf AI API

คำขอ API ทุกรายการต้องมีคีย์ API ของคุณอยู่ในส่วนหัวคำขอ รูปแบบส่วนหัวการรับรองความถูกต้องคือ:

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

นี่คือลักษณะของการรับรองความถูกต้องในภาษาโปรแกรมต่างๆ:

การรับรองความถูกต้อง Python ด้วย 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}")

การรับรองความถูกต้อง JavaScript ด้วย 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));

การรับรองความถูกต้อง cURL ด้วย Murf AI API

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

การรับรองความถูกต้องที่สำเร็จจะส่งคืนรหัสสถานะ 200 คีย์ที่ไม่ถูกต้องจะส่งคืน 401 Unauthorized

การดึงเสียงที่พร้อมใช้งานด้วย Murf AI API

ก่อนสร้างเสียงพูด ให้ดึงรายการเสียงที่พร้อมใช้งานเพื่อเลือกเสียงที่เหมาะสมกับกรณีการใช้งานของคุณ ปลายทาง /voices จะส่งคืนเสียงทั้งหมดที่สามารถเข้าถึงได้พร้อมข้อมูลเมตา

แสดงรายการเสียงทั้งหมด

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

การตอบกลับจะรวมคุณสมบัติเสียง:

กรองเสียงตามภาษา

# 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)}")

การสร้างเสียงพูดจากข้อความ

ฟังก์ชันหลักของ Murf AI API คือการแปลงข้อความเป็นเสียงพูด ปลายทาง /speech ยอมรับพารามิเตอร์ข้อความและเสียง โดยจะส่งคืนไฟล์เสียง

คำขอแปลงข้อความเป็นเสียงพูดพื้นฐาน

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

พารามิเตอร์คำขอ

การปรับความเร็วและระดับเสียง

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)

การใช้ SSML เพื่อการควบคุมขั้นสูง

Speech Synthesis Markup Language (SSML) ให้การควบคุมการออกเสียง การหยุดชั่วคราว การเน้น และอื่นๆ ได้อย่างละเอียด Murf AI API รองรับแท็ก SSML สำหรับเอาต์พุตเสียงระดับมืออาชีพ

ตัวอย่าง 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)

แท็ก SSML ทั่วไป

การทดสอบ Murf AI API ด้วย Apidog

ก่อนเขียนโค้ดเพื่อผสานรวม ให้ทดสอบการเรียก API ของคุณแบบโต้ตอบ Apidog มีอินเทอร์เฟซแบบภาพสำหรับสร้างคำขอ ตรวจสอบการตอบกลับ และดีบักปัญหาต่างๆ

การตั้งค่า Apidog สำหรับ Murf AI

1. ดาวน์โหลดและติดตั้ง Apidog

รับ Apidog ฟรี รองรับ Windows, Mac, Linux และเว็บเบราว์เซอร์

2. สร้างโปรเจกต์ใหม่

เริ่มต้นโปรเจกต์ใหม่ชื่อ "Murf AI Integration" เพื่อจัดระเบียบปลายทาง API ของคุณ

3. ตั้งค่าตัวแปรสภาพแวดล้อม

สร้างสภาพแวดล้อมด้วยคีย์ API ของคุณ:

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

ตัวแปรสภาพแวดล้อมช่วยแยกข้อมูลที่ละเอียดอ่อนออกจากการกำหนดค่าคำขอ

4. สร้างคำขอแรกของคุณ

เพิ่มคำขอ POST ใหม่ด้วยการตั้งค่าเหล่านี้:

• URL: {{baseUrl}}/speech
• ส่วนหัว:
• api-key: {{apiKey}}
• Content-Type: application/json
• เนื้อหา (JSON):

{
    "text": "Testing Murf AI API with Apidog. This is a sample voiceover.",
    "voiceId": "en-US-marcus",
    "format": "mp3"
}

5. ส่งและตรวจสอบการตอบกลับ

คลิก ส่ง Apidog จะแสดงสถานะการตอบกลับ ส่วนหัว และอนุญาตให้คุณดาวน์โหลดไฟล์เสียงที่สร้างขึ้นได้โดยตรง

การดีบักปัญหาทั่วไปด้วย Apidog

คุณสมบัติประวัติคำขอของ Apidog ช่วยให้คุณเปรียบเทียบคำขอที่สำเร็จและล้มเหลวเคียงข้างกัน ทำให้การดีบักเป็นเรื่องง่าย

การจัดการเนื้อหาแบบยาวด้วย Murf AI API

สำหรับบทความ บล็อกโพสต์ หรือบทในหนังสือ คุณอาจต้องประมวลผลข้อความเป็นส่วนๆ Murf AI มีการจำกัดจำนวนอักขระต่อคำขอ ดังนั้นการแบ่งเนื้อหาจึงช่วยให้มั่นใจได้ถึงการประมวลผลที่เชื่อถือได้

กลยุทธ์การแบ่งส่วน (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):
    """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 = """
Your long article or document content goes here.
It can span multiple paragraphs and pages.
The function splits it automatically at sentence boundaries.
"""

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

การรวมไฟล์เสียงด้วย Murf AI API

หลังจากสร้างส่วนต่างๆ แล้ว ให้รวมเข้าเป็นไฟล์เดียวโดยใช้ FFmpeg หรือไลบรารี 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"Combined audio saved to {output_file}")
    return output_file

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

แนวทางปฏิบัติที่ดีที่สุดในการจัดการข้อผิดพลาดด้วย Murf AI API

แอปพลิเคชันที่ใช้งานจริงจำเป็นต้องมีการจัดการข้อผิดพลาดที่แข็งแกร่ง Murf AI API ส่งคืนรหัสสถานะ HTTP มาตรฐานพร้อมข้อความข้อผิดพลาดที่อธิบายรายละเอียด

รหัสข้อผิดพลาดทั่วไป

ไคลเอ็นต์ API ที่แข็งแกร่ง

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)

การสร้างบริการสร้างเสียงพากย์

มาสร้าง Flask API ที่สมบูรณ์ซึ่งใช้ Murf AI สำหรับแอปพลิเคชันของคุณกัน:

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