Murf AI API Nasıl Kullanılır?

Murf AI, stüdyo kalitesinde seslendirmelerle metni doğal sesli konuşmaya dönüştürür. Geliştiriciler, içerikleri seslendiren, makalelerin sesli versiyonlarını oluşturan, sanal asistanlara güç veren ve büyük ölçekte seslendirmeler üreten uygulamalar geliştirmek için Murf AI API'yi entegre eder.

Murf AI API Nedir?

Murf AI, yazılı içeriği gerçekçi insan benzeri sese dönüştüren bulut tabanlı bir metin-konuşma hizmeti sunar. Robotik sesli TTS motorlarının aksine, Murf doğal tonlama, doğru vurgu ve otantik duygusal ifade üretmek için yapay zeka destekli ses sentezi kullanır.

API, bu işlevselliği geliştiricilere sunar. Temel yetenekler şunları içerir:

• Ses Kütüphanesi - Farklı cinsiyetlere, yaşlara ve aksanlara yayılan 120'den fazla yapay zeka sesine erişim
• Çok Dilli Destek - İngilizce, İspanyolca, Fransızca, Almanca ve Hintçe dahil 20'den fazla dilde konuşma üretimi
• Ses Özelleştirme - Hassas kontrol için perde, hız ve vurguyu ayarlama
• Birden Fazla Çıkış Formatı - Sesi MP3, WAV veya FLAC olarak dışa aktarma
• SSML Desteği - Konuşma Sentezi İşaretleme Dili (SSML) kullanarak telaffuzu ince ayar yapma

Geliştiriciler, video anlatımı, podcast üretimi, IVR sistemleri, sesli kitap oluşturma ve erişilebilirlik özellikleri için Murf AI API'sini kullanır. API hem kısa parçaları hem de uzun biçimli içeriği işleyerek çeşitli kullanım durumları için uygun hale getirir.

Murf AI API ile Başlarken

API çağrıları yapmadan önce kimlik doğrulamasını ayarlamanız gerekir. Murf AI, standart REST kurallarına uygun olarak yetkilendirme için API anahtarları kullanır.

Adım 1: Bir Murf AI Hesabı Oluşturun

murf.ai adresini ziyaret edin ve bir hesap oluşturun. Murf, API'yi test etmek için iyi çalışan sınırlı kredili ücretsiz bir katman sunar. Üretim kullanımı için, API erişimini içeren ücretli bir plana ihtiyacınız olacaktır.

Adım 2: Murf AI API Anahtarınızı Oluşturun

Hesap ayarlarınıza gidin ve API bölümünü bulun. Yeni bir API anahtarı oluşturun ve güvenli bir yerde saklayın. Bu anahtar tüm isteklerinizi doğrular.

API anahtarınızı gizli tutun. Asla sürüm kontrolüne aktarmayın veya istemci tarafı kodunda ifşa etmeyin.

Adım 3: Murf AI API Temel URL'sini Anlayın

Tüm Murf AI API istekleri şu adrese gider:

https://api.murf.ai/v1

API, JSON istek ve yanıt gövdeleriyle RESTful kurallarına uyar. Kimlik doğrulama, `api-key` başlığı aracılığıyla gerçekleşir.

Murf AI API Kimlik Doğrulaması

Her API isteği, istek başlıklarında API anahtarınızı gerektirir. Kimlik doğrulama başlığı formatı şöyledir:

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

İşte farklı programlama dillerinde kimlik doğrulamanın nasıl göründüğü:

Murf AI API ile Python Kimlik Doğrulaması

import requests

API_KEY = "your_murf_api_key"
BASE_URL = "https://api.murf.ai/v1"

headers = {
    "api-key": API_KEY,
    "Content-Type": "application/json"
}

# Mevcut sesleri alarak kimlik doğrulamayı test edin
response = requests.get(f"{BASE_URL}/voices", headers=headers)

if response.status_code == 200:
    print("Kimlik doğrulama başarılı!")
    voices = response.json()
    print(f"Mevcut sesler: {len(voices)}")
else:
    print(f"Kimlik doğrulama başarısız: {response.status_code}")

Murf AI API ile JavaScript Kimlik Doğrulaması

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'
};

// Kimlik doğrulamayı test edin
fetch(`${BASE_URL}/voices`, { headers })
    .then(response => response.json())
    .then(data => console.log('Mevcut sesler:', data.length))
    .catch(error => console.error('Kimlik doğrulama başarısız:', error));

Murf AI API ile cURL Kimlik Doğrulaması

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

Başarılı bir kimlik doğrulama 200 durum kodu döndürür. Geçersiz anahtarlar 401 Yetkisiz döndürür.

Murf AI API ile Mevcut Sesleri Çekme

Konuşma üretmeden önce, kullanım durumunuza uygun birini seçmek için mevcut seslerin listesini alın. `/voices` uç noktası, meta verileriyle birlikte erişilebilen tüm sesleri döndürür.

Tüm Sesleri Listele

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

# Ses bilgilerini göster
for voice in voices[:5]:  # İlk 5 sesi göster
    print(f"Ad: {voice['name']}")
    print(f"Ses Kimliği: {voice['voiceId']}")
    print(f"Dil: {voice['language']}")
    print(f"Cinsiyet: {voice['gender']}")
    print(f"Aksan: {voice.get('accent', 'Mevcut Değil')}")
    print("---")

Yanıt, ses özelliklerini içerir:

Sesleri Dile Göre Filtrele

# İngilizce sesleri filtrele
english_voices = [v for v in voices if v['language'].startswith('en')]
print(f"Mevcut İngilizce sesler: {len(english_voices)}")

# İspanyolca sesleri filtrele
spanish_voices = [v for v in voices if v['language'].startswith('es')]
print(f"Mevcut İspanyolca sesler: {len(spanish_voices)}")

Metinden Konuşma Oluşturma

Murf AI API'nin temel işlevi metni konuşmaya dönüştürmektir. `/speech` uç noktası metin ve ses parametrelerini kabul eder ve bir ses dosyası döndürür.

Temel Metin-Konuşma İsteğ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"
}

payload = {
    "text": "Uygulamamıza hoş geldiniz. Bu ses Murf AI kullanılarak oluşturulmuştur.",
    "voiceId": "en-US-marcus",
    "format": "mp3",
    "sampleRate": 24000
}

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

if response.status_code == 200:
    # Ses dosyasını kaydet
    with open("output.mp3", "wb") as f:
        f.write(response.content)
    print("Ses output.mp3 olarak kaydedildi")
else:
    print(f"Hata: {response.status_code} - {response.text}")

İstek Parametreleri

Ses Hızını ve Perdesini Ayarlama

payload = {
    "text": "Bu metin daha yavaş bir hızda ve daha düşük bir perdeyle konuşuluyor.",
    "voiceId": "en-US-marcus",
    "format": "mp3",
    "speed": 0.8,    # Normal hızın %80'i
    "pitch": -2      # Biraz daha düşük perde
}

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

Gelişmiş Kontrol için SSML Kullanımı

Konuşma Sentezi İşaretleme Dili (SSML), telaffuz, duraklamalar, vurgu ve daha fazlası üzerinde ince ayar kontrolü sağlar. Murf AI API, profesyonel düzeyde ses çıkışı için SSML etiketlerini destekler.

SSML Örneği

ssml_text = """
<speak>
    Murf AI'ya hoş geldiniz.
    <break time="500ms"/>
    Metin-konuşma teknolojimiz doğal sesli ses oluşturur.
    <break time="300ms"/>
    <phoneme alphabet="ipa" ph="ˈdeɪtə">veri</phoneme> kelimesi doğru telaffuz edilmiştir.
</speak>
"""

payload = {
    "text": ssml_text,
    "voiceId": "en-US-julia",
    "format": "mp3",
    "ssml": True  # SSML ayrıştırmasını etkinleştir
}

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

Yaygın SSML Etiketleri

Murf AI API'yi Apidog ile Test Etme

Entegrasyon kodu yazmadan önce, API çağrılarınızı etkileşimli olarak test edin. Apidog, istekleri oluşturmak, yanıtları incelemek ve sorunları ayıklamak için görsel bir arayüz sağlar.

Murf AI için Apidog Kurulumu

1. Apidog'u İndirin ve Kurun

Apidog'u ücretsiz edinin. Windows, Mac, Linux ve web tarayıcılarını destekler.

2. Yeni Bir Proje Oluşturun

"Murf AI Entegrasyonu" adında yeni bir proje başlatın. Bu, API uç noktalarınızı düzenli tutar.

3. Ortam Değişkenlerini Ayarlayın

API anahtarınızla bir ortam oluşturun:

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

Ortam değişkenleri hassas verileri istek yapılandırmalarından ayrı tutar.

4. İlk İsteğinizi Oluşturun

Bu ayarlarla yeni bir POST isteği ekleyin:

• URL: {{baseUrl}}/speech
• Başlıklar:
• api-key: {{apiKey}}
• Content-Type: application/json
• Gövde (JSON):

{
    "text": "Apidog ile Murf AI API test ediliyor. Bu bir örnek seslendirmedir.",
    "voiceId": "en-US-marcus",
    "format": "mp3"
}

5. Yanıtı Gönder ve İncele

Gönder'e tıklayın. Apidog yanıt durumunu, başlıkları görüntüler ve oluşturulan ses dosyasını doğrudan indirmenize olanak tanır.

Apidog ile Yaygın Sorunları Ayıklama

Apidog'un istek geçmişi özelliği, başarılı ve başarısız istekleri yan yana karşılaştırmanıza olanak tanıyarak hata ayıklamayı kolaylaştırır.

Murf AI API ile Uzun Biçimli İçeriği İşleme

Makaleler, blog gönderileri veya kitap bölümleri için metni parçalara ayırmanız gerekebilir. Murf AI'nin istek başına karakter limitleri vardır, bu nedenle içeriği bölmek güvenilir işlemeyi sağlar.

Parçalama Stratejisi

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):
    """Metni cümle sınırlarında parçalara ayırır."""
    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"):
    """Uzun biçimli içerik için ses oluşturur."""
    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"Oluşturuldu: {filename}")
        else:
            print(f"Başarısız parça {i+1}: {response.status_code}")

    return audio_files

# Örnek kullanım
long_text = """
Uzun makaleniz veya belge içeriğiniz buraya gelir.
Birden fazla paragraf ve sayfa içerebilir.
Fonksiyon bunu otomatik olarak cümle sınırlarında böler.
"""

audio_files = generate_long_audio(long_text, "en-US-marcus", "article_audio")
print(f"Oluşturulan ses dosyası sayısı: {len(audio_files)}")

Murf AI API ile Ses Dosyalarını Birleştirme

Parçaları oluşturduktan sonra, FFmpeg veya bir Python kütüphanesi kullanarak bunları tek bir dosyada birleştirin:

from pydub import AudioSegment

def concatenate_audio(file_list, output_file="final_audio.mp3"):
    """Birden fazla ses dosyasını tek bir dosyada birleştirir."""
    combined = AudioSegment.empty()

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

    combined.export(output_file, format="mp3")
    print(f"Birleştirilmiş ses {output_file} olarak kaydedildi")
    return output_file

# Parçaları birleştir
concatenate_audio(audio_files, "complete_article.mp3")

Murf AI API ile Hata Yönetimi En İyi Uygulamaları

Üretim uygulamaları sağlam hata yönetimi gerektirir. Murf AI API, açıklayıcı hata mesajlarıyla standart HTTP durum kodları döndürür.

Yaygın Hata Kodları

Sağlam API İstemcisi

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]:
        """Yeniden deneme mantığıyla API isteği yapar."""
        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:
                    # Hız sınırı aşıldı - bekle ve yeniden dene
                    wait_time = 2 ** attempt
                    print(f"Hız sınırı aşıldı. {wait_time}s bekleniyor...")
                    time.sleep(wait_time)
                elif response.status_code >= 500:
                    # Sunucu hatası - yeniden dene
                    time.sleep(1)
                else:
                    # İstemci hatası - yeniden deneme
                    print(f"Hata {response.status_code}: {response.text}")
                    return None

            except requests.RequestException as e:
                print(f"İstek başarısız: {e}")
                time.sleep(1)

        return None

    def get_voices(self) -> list:
        """Mevcut sesleri getirir."""
        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]:
        """Metinden konuşma oluşturur."""
        payload = {
            "text": text,
            "voiceId": voice_id,
            "format": format,
            **kwargs
        }
        response = self._request("POST", "speech", payload)
        return response.content if response else None

# Kullanım
client = MurfAPIClient("your_api_key")
voices = client.get_voices()
audio = client.generate_speech(
    "Merhaba dünya!",
    "en-US-marcus",
    speed=1.0
)

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

Seslendirme Oluşturma Hizmeti Oluşturma

Uygulamalarınız için Murf AI'yı saran eksiksiz bir Flask API oluşturalım:

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():
    """Mevcut sesleri listele."""
    language = request.args.get("language")

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

    if response.status_code != 200:
        return jsonify({"error": "Sesler alınamadı"}), 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():
    """Metinden konuşma oluştur."""
    data = request.json

    if not data or "text" not in data:
        return jsonify({"error": "'text' alanı eksik"}), 400

    if "voiceId" not in data:
        return jsonify({"error": "'voiceId' alanı eksik"}), 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": "Konuşma üretimi başarısız oldu"}), 500

    # Geçici dosyaya kaydet
    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)

Bu hizmet iki uç nokta sunar: biri sesleri listelemek, diğeri konuşma oluşturmak için. Üretim kullanımı için önbelleğe alma, kimlik doğrulama ve kuyruk tabanlı işlemeyle genişletebilirsiniz.

Murf AI API için Hız Sınırları ve Fiyatlandırma Hususları

Murf AI, abonelik planınıza göre hız sınırları uygular. Bu sınırları anlamak, verimli uygulamalar tasarlamanıza yardımcı olur.

API Kullanımını Optimize Etme

• Oluşturulan sesi önbelleğe alın - Tekrarlanan istekler için sonuçları saklayın
• Benzer istekleri birleştirin - Mümkün olduğunda kısa metinleri birleştirin
• Daha düşük örnekleme hızları kullanın - 16000 Hz ses içeriği için iyi çalışır
• Apidog ile izleyin - Kullanım modellerini takip edin ve optimize edin

Popüler Çerçevelerle Entegrasyon

Node.js Entegrasyonu

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

// Kullanım
(async () => {
    const audio = await generateSpeech(
        'Node.js\'ten merhaba!',
        'en-US-marcus'
    );

    fs.writeFileSync('output.mp3', audio);
    console.log('Ses kaydedildi!');
})();

React Ön Uç Entegrasyonu

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('Üretim başarısız oldu:', error);
        } finally {
            setLoading(false);
        }
    };

    return (
        <div className="voice-generator">
            <textarea
                value={text}
                onChange={(e) => setText(e.target.value)}
                placeholder="Konuşmaya dönüştürülecek metni girin..."
            />

            <select value={voiceId} onChange={(e) => setVoiceId(e.target.value)}>
                <option value="en-US-marcus">Marcus (ABD Erkek)</option>
                <option value="en-US-julia">Julia (ABD Kadın)</option>
                <option value="en-GB-oliver">Oliver (İngiltere Erkek)</option>
            </select>

            <button onClick={generateAudio} disabled={loading}>
                {loading ? 'Oluşturuluyor...' : 'Ses Oluştur'}
            </button>

            {audioUrl && (
                <audio controls src={audioUrl}>
                    Tarayıcınız ses oynatmayı desteklemiyor.
                </audio>
            )}
        </div>
    );
}

export default VoiceGenerator;

Sonuç

Murf AI API, geliştiriciler için güçlü metin-konuşma yetenekleri sunar. Basit seslendirmelerden karmaşık çok sesli prodüksiyonlara kadar, API doğal sesli çıktıyla çeşitli gereksinimleri karşılar. Önemli çıkarımlar:

• Kimlik Doğrulama - Tüm çağrılar için istek başlıklarında API anahtarları kullanın
• Ses Seçimi - Diller ve aksanlar arasında 120'den fazla sesi keşfedin
• Özelleştirme - Hızı, perdeyi ayarlayın ve hassas kontrol için SSML kullanın
• Hata Yönetimi - Üretim için yeniden denemeleri ve üstel geri çekilmeyi uygulayın
• Test Etme - Entegrasyonunuzu ayıklamak ve optimize etmek için Apidog kullanın

Deneme yapmak için ücretsiz katmanla başlayın, ardından uygulamanız büyüdükçe ölçeği büyütün. Yüksek kaliteli seslerin ve geliştirici dostu API tasarımının birleşimi, Murf AI'yı ses özellikli uygulamalar için sağlam bir seçim haline getirir.

Oluşturmaya hazır mısınız? Murf AI API çağrılarınızı test etmek ve geliştirme iş akışınızı kolaylaştırmak için Apidog'u indirin.