获取任务结果

{
    "audio_url": "https://pub-86e8fdaa1c484bfb856e9d0f2cf54e2a.r2.dev/1748144964376_0791dacf_voice_clone_result_d24db52d-c6ea-4722-b630-723bae3eb6dd.mp3"
}

curl -X GET "https://aivoiceclonefree.com/api/instant/task-result?task_id=1406bf34-735c-4b21-98ac-a135b2afb1c8&api_key=your_api_key_here"

class VoiceCloneAPI {
  constructor(apiKey, baseUrl = 'https://aivoiceclonefree.com') {
    this.apiKey = apiKey;
    this.baseUrl = baseUrl;
  }
 
  // 创建异步任务
  async createTask(audioFile, text) {
    const formData = new FormData();
    formData.append('audio', audioFile);
    formData.append('text', text);
    formData.append('api_key', this.apiKey);
 
    const response = await fetch(`${this.baseUrl}/api/instant/create-task`, {
      method: 'POST',
      body: formData
    });
 
    return response.json();
  }
 
  // 查询任务状态
  async getTaskStatus(taskId) {
    const response = await fetch(
      `${this.baseUrl}/api/instant/task-status?task_id=${taskId}&api_key=${this.apiKey}`
    );
    return response.json();
  }
 
  // 获取任务结果
  async getTaskResult(taskId) {
    const response = await fetch(
      `${this.baseUrl}/api/instant/task-result?task_id=${taskId}&api_key=${this.apiKey}`
    );
    return response.json();
  }
 
  // 完整的异步克隆流程
  async cloneVoiceAsync(audioFile, text) {
    try {
      // 1. 创建任务
      console.log('创建语音克隆任务...');
      const taskResponse = await this.createTask(audioFile, text);
      const taskId = taskResponse.task_id;
      console.log(`任务ID: ${taskId}`);
 
      // 2. 轮询状态
      console.log('等待任务完成...');
      let status = 'pending';
      const maxAttempts = 20;
      const interval = 30000; // 30秒
 
      for (let i = 0; i < maxAttempts && status !== 'completed' && status !== 'failed'; i++) {
        await new Promise(resolve => setTimeout(resolve, interval));
        
        const statusResponse = await this.getTaskStatus(taskId);
        status = statusResponse.status;
        console.log(`状态检查 ${i + 1}: ${status}`);
      }
 
      // 3. 获取结果
      if (status === 'completed') {
        console.log('任务完成，获取结果...');
        const result = await this.getTaskResult(taskId);
        console.log('音频文件URL:', result.audio_url);
        return result;
      } else {
        throw new Error(`任务失败或超时，最终状态: ${status}`);
      }
 
    } catch (error) {
      console.error('语音克隆过程中出错:', error);
      throw error;
    }
  }
}
 
// 使用示例
const api = new VoiceCloneAPI('your_api_key_here');
 
// 获取音频文件（例如从文件输入）
const audioInput = document.getElementById('audioFile');
const audioFile = audioInput.files[0];
const text = "这是要合成的长文本内容...";
 
api.cloneVoiceAsync(audioFile, text)
  .then(result => {
    console.log('语音克隆完成！');
    console.log('音频URL:', result.audio_url);
    
    // 可以创建音频元素播放或提供下载链接
    const audio = new Audio(result.audio_url);
    audio.play();
  })
  .catch(error => {
    console.error('错误:', error);
  });

import requests
import time
 
class VoiceCloneAPI:
    def __init__(self, api_key, base_url='https://aivoiceclonefree.com'):
        self.api_key = api_key
        self.base_url = base_url
 
    def create_task(self, audio_file_path, text):
        """创建异步任务"""
        with open(audio_file_path, 'rb') as audio_file:
            files = {'audio': audio_file}
            data = {
                'text': text,
                'api_key': self.api_key
            }
            
            response = requests.post(
                f'{self.base_url}/api/instant/create-task',
                files=files,
                data=data
            )
            
        return response.json()
 
    def get_task_status(self, task_id):
        """查询任务状态"""
        params = {
            'task_id': task_id,
            'api_key': self.api_key
        }
        
        response = requests.get(
            f'{self.base_url}/api/instant/task-status',
            params=params
        )
        
        return response.json()
 
    def get_task_result(self, task_id):
        """获取任务结果"""
        params = {
            'task_id': task_id,
            'api_key': self.api_key
        }
        
        response = requests.get(
            f'{self.base_url}/api/instant/task-result',
            params=params
        )
        
        return response.json()
 
    def clone_voice_async(self, audio_file_path, text):
        """完整的异步克隆流程"""
        try:
            # 1. 创建任务
            print('创建语音克隆任务...')
            task_response = self.create_task(audio_file_path, text)
            task_id = task_response['task_id']
            print(f'任务ID: {task_id}')
 
            # 2. 轮询状态
            print('等待任务完成...')
            status = 'pending'
            max_attempts = 20
            interval = 30  # 30秒
 
            for i in range(max_attempts):
                if status in ['completed', 'failed']:
                    break
                    
                time.sleep(interval)
                status_response = self.get_task_status(task_id)
                status = status_response['status']
                print(f'状态检查 {i + 1}: {status}')
 
            # 3. 获取结果
            if status == 'completed':
                print('任务完成，获取结果...')
                result = self.get_task_result(task_id)
                print('音频文件URL:', result['audio_url'])
                return result
            else:
                raise Exception(f'任务失败或超时，最终状态: {status}')
 
        except Exception as e:
            print(f'语音克隆过程中出错: {e}')
            raise
 
# 使用示例
if __name__ == '__main__':
    api = VoiceCloneAPI('your_api_key_here')
    
    try:
        result = api.clone_voice_async(
            'path/to/audio/sample.mp3',
            '这是要合成的长文本内容...'
        )
        
        print('语音克隆完成！')
        print('音频URL:', result['audio_url'])
        
        # 可以下载音频文件
        audio_response = requests.get(result['audio_url'])
        with open('generated_voice.mp3', 'wb') as f:
            f.write(audio_response.content)
        print('音频文件已下载为 generated_voice.mp3')
        
    except Exception as e:
        print(f'错误: {e}')