Murf AI API 활용법

Murf AI는 텍스트를 스튜디오 품질의 보이스오버로 자연스러운 음성으로 변환합니다. 개발자는 Murf AI API를 통합하여 콘텐츠를 내레이션하고, 기사의 오디오 버전을 만들고, 가상 비서를 구동하고, 대규모로 보이스오버를 생성하는 애플리케이션을 구축합니다.

Murf AI API란 무엇인가요?

Murf AI는 작성된 콘텐츠를 사실적인 사람의 음성 오디오로 변환하는 클라우드 기반 텍스트 음성 변환 서비스를 제공합니다. 로봇처럼 들리는 TTS 엔진과 달리, Murf는 AI 기반 음성 합성을 사용하여 자연스러운 억양, 적절한 강조, 그리고 진정한 감정 표현을 생성합니다.

API는 개발자를 위해 이 기능을 노출합니다. 주요 기능은 다음과 같습니다.

• 음성 라이브러리 - 다양한 성별, 연령, 악센트를 아우르는 120개 이상의 AI 음성 액세스
• 다국어 지원 - 영어, 스페인어, 프랑스어, 독일어, 힌디어를 포함한 20개 이상의 언어로 음성 생성
• 음성 사용자 지정 - 정밀한 제어를 위해 음높이, 속도 및 강조 조정
• 다중 출력 형식 - MP3, WAV 또는 FLAC으로 오디오 내보내기
• SSML 지원 - 음성 합성 마크업 언어를 사용하여 발음 미세 조정

개발자들은 Murf AI API를 비디오 내레이션, 팟캐스트 제작, IVR 시스템, 오디오북 생성 및 접근성 기능에 사용합니다. 이 API는 짧은 스니펫과 긴 형식의 콘텐츠를 모두 처리하므로 다양한 사용 사례에 적합합니다.

Murf AI API 시작하기

API 호출을 하기 전에 인증을 설정해야 합니다. Murf AI는 표준 REST 규칙에 따라 권한 부여를 위해 API 키를 사용합니다.

1단계: Murf AI 계정 생성

murf.ai를 방문하여 계정을 만드세요. Murf는 API 테스트에 적합한 제한된 크레딧이 포함된 무료 등급을 제공합니다. 프로덕션 사용을 위해서는 API 액세스가 포함된 유료 요금제가 필요합니다.

2단계: Murf AI API 키 생성

계정 설정으로 이동하여 API 섹션을 찾으세요. 새 API 키를 생성하고 안전하게 보관하세요. 이 키는 모든 요청을 인증합니다.

API 키는 기밀로 유지하세요. 버전 제어에 커밋하거나 클라이언트 측 코드에 노출해서는 안 됩니다.

3단계: Murf AI API 기본 URL 이해하기

모든 Murf AI API 요청은 다음으로 전송됩니다.

https://api.murf.ai/v1

API는 JSON 요청 및 응답 본문과 함께 RESTful 규칙을 따릅니다. 인증은 api-key 헤더를 통해 이루어집니다.

Murf AI API 인증

모든 API 요청에는 요청 헤더에 API 키가 필요합니다. 인증 헤더 형식은 다음과 같습니다.

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

다음은 다양한 프로그래밍 언어에서의 인증 방식입니다.

Murf AI API를 사용한 Python 인증

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

Murf AI API를 사용한 JavaScript 인증

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

Murf AI API를 사용한 cURL 인증

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

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

응답에는 음성 속성이 포함됩니다.

언어별 음성 필터링

# 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 사용

SSML(Speech Synthesis Markup Language)은 발음, 일시 중지, 강조 등에 대한 정밀한 제어를 제공합니다. 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 태그

Apidog로 Murf AI API 테스트하기

통합 코드를 작성하기 전에 API 호출을 대화식으로 테스트하세요. Apidog는 요청을 작성하고, 응답을 검사하고, 문제를 디버깅하기 위한 시각적 인터페이스를 제공합니다.

Murf AI용 Apidog 설정

1. Apidog 다운로드 및 설치

Apidog를 무료로 다운로드하세요. Windows, Mac, Linux 및 웹 브라우저를 지원합니다.

2. 새 프로젝트 생성

"Murf AI 통합"이라는 이름으로 새 프로젝트를 시작하세요. 이렇게 하면 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는 요청당 문자 제한이 있으므로 콘텐츠를 분할하면 안정적인 처리가 보장됩니다.

청킹 전략

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):
    """텍스트를 문장 경계에서 청크로 분할합니다."""
    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"):
    """긴 형식 콘텐츠에 대한 오디오를 생성합니다."""
    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"):
    """여러 오디오 파일을 하나로 결합합니다."""
    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]:
        """재시도 로직을 사용하여 API 요청을 합니다."""
        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:
                    # 속도 제한됨 - 대기 후 재시도
                    wait_time = 2 ** attempt
                    print(f"Rate limited. Waiting {wait_time}s...")
                    time.sleep(wait_time)
                elif response.status_code >= 500:
                    # 서버 오류 - 재시도
                    time.sleep(1)
                else:
                    # 클라이언트 오류 - 재시도 안함
                    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:
        """사용 가능한 음성을 가져옵니다."""
        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]:
        """텍스트에서 음성을 생성합니다."""
        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)

보이스오버 생성 서비스 구축

애플리케이션을 위해 Murf AI를 래핑하는 완전한 Flask API를 구축해 보겠습니다.

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():
    """사용 가능한 음성을 나열합니다."""
    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():
    """텍스트에서 음성을 생성합니다."""
    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

    # 임시 파일에 저장
    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)

이 서비스는 두 개의 엔드포인트를 노출합니다: 하나는 음성을 나열하고 다른 하나는 음성을 생성합니다. 프로덕션 사용을 위해 캐싱, 인증 및 큐 기반 처리로 확장할 수 있습니다.

Murf AI API의 속도 제한 및 가격 고려 사항

Murf AI는 구독 요금제에 따라 속도 제한을 시행합니다. 이러한 제한을 이해하면 효율적인 애플리케이션을 설계하는 데 도움이 됩니다.

API 사용 최적화

• 생성된 오디오 캐시 - 반복 요청에 대한 결과 저장
• 유사한 요청 일괄 처리 - 가능한 경우 짧은 텍스트 결합
• 낮은 샘플 레이트 사용 - 16000Hz는 음성 콘텐츠에 잘 작동합니다
• Apidog로 모니터링 - 사용 패턴 추적 및 최적화

인기 프레임워크와의 통합

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('Error:', error.response?.data || error.message);
        throw error;
    }
}

// 사용법
(async () => {
    const audio = await generateSpeech(
        'Hello from Node.js!',
        'en-US-marcus'
    );

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

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('Generation failed:', error);
        } finally {
            setLoading(false);
        }
    };

    return (
        <div className="voice-generator">
            <textarea
                value={text}
                onChange={(e) => setText(e.target.value)}
                placeholder="음성으로 변환할 텍스트를 입력하세요..."
            />

            <select value={voiceId} onChange={(e) => setVoiceId(e.target.value)}>
                <option value="en-US-marcus">마커스 (미국 남성)</option>
                <option value="en-US-julia">줄리아 (미국 여성)</option>
                <option value="en-GB-oliver">올리버 (영국 남성)</option>
            </select>

            <button onClick={generateAudio} disabled={loading}>
                {loading ? '생성 중...' : '오디오 생성'}
            </button>

            {audioUrl && (
                <audio controls src={audioUrl}>
                    귀하의 브라우저는 오디오 재생을 지원하지 않습니다.
                </audio>
            )}
        </div>
    );
}

export default VoiceGenerator;

결론

Murf AI API는 개발자에게 강력한 텍스트 음성 변환 기능을 제공합니다. 간단한 보이스오버부터 복잡한 다중 음성 제작에 이르기까지, 이 API는 자연스러운 음성 출력으로 다양한 요구 사항을 처리합니다. 핵심 요약:

• 인증 - 모든 호출에 요청 헤더에 API 키 사용
• 음성 선택 - 언어 및 악센트 전반에 걸쳐 120개 이상의 음성 탐색
• 사용자 지정 - 속도, 음높이 조정 및 SSML을 사용하여 정밀 제어
• 오류 처리 - 프로덕션 환경을 위한 재시도 및 지수 백오프 구현
• 테스트 - Apidog를 사용하여 통합 디버깅 및 최적화

무료 등급으로 실험을 시작한 다음, 애플리케이션이 성장함에 따라 확장하세요. 고품질 음성과 개발자 친화적인 API 디자인의 조합은 Murf AI를 음성 지원 애플리케이션을 위한 견고한 선택으로 만듭니다.

구축할 준비가 되셨나요? Apidog를 다운로드하여 Murf AI API 호출을 테스트하고 개발 워크플로우를 간소화하세요.