Download Asynchronous Task Result

GET https://aivoiceclonefree.com/api/async-clone/task-result/{task_id}

Authorization: Bearer YOUR_API_KEY

curl -X GET "https://aivoiceclonefree.com/api/async-clone/task-result/abc123def456ghi789" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  --output "generated_audio.wav"

import requests
 
task_id = "abc123def456ghi789"
url = f"https://aivoiceclonefree.com/api/async-clone/task-result/{task_id}"
headers = {
    "Authorization": "Bearer YOUR_API_KEY"
}
 
response = requests.get(url, headers=headers)
 
if response.status_code == 200:
    with open("generated_audio.wav", "wb") as audio_file:
        audio_file.write(response.content)
    print("Audio file downloaded successfully!")
else:
    print(f"Error: {response.status_code}")

const taskId = "abc123def456ghi789";
 
fetch(`https://aivoiceclonefree.com/api/async-clone/task-result/${taskId}`, {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY'
  }
})
.then(response => {
  if (response.ok) {
    return response.blob();
  }
  throw new Error('Failed to download audio');
})
.then(audioBlob => {
  // Create download link
  const url = window.URL.createObjectURL(audioBlob);
  const a = document.createElement('a');
  a.href = url;
  a.download = 'generated_audio.wav';
  a.click();
  window.URL.revokeObjectURL(url);
});

{
  "detail": "Invalid or missing API key"
}

{
  "detail": "Access denied. Task belongs to another user"
}

{
  "detail": "Task not found or result not available"
}

{
  "detail": "Task not completed yet. Current status: processing"
}

{
  "detail": "Task result has expired and is no longer available"
}

import requests
import time
import json
 
class VoiceCloningClient:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://aivoiceclonefree.com/api"
        self.headers = {"Authorization": f"Bearer {api_key}"}
    
    def create_task(self, audio_file_path, text):
        """Create an asynchronous voice cloning task"""
        url = f"{self.base_url}/async-clone/create-task"
        
        with open(audio_file_path, "rb") as audio_file:
            files = {"audio_file": audio_file}
            data = {"text": text}
            
            response = requests.post(url, headers=self.headers, files=files, data=data)
            return response.json()
    
    def check_status(self, task_id):
        """Check the status of a task"""
        url = f"{self.base_url}/async-clone/task-status/{task_id}"
        response = requests.get(url, headers=self.headers)
        return response.json()
    
    def download_result(self, task_id, output_path):
        """Download the generated audio file"""
        url = f"{self.base_url}/async-clone/task-result/{task_id}"
        response = requests.get(url, headers=self.headers)
        
        if response.status_code == 200:
            with open(output_path, "wb") as audio_file:
                audio_file.write(response.content)
            return True
        return False
    
    def clone_voice_async(self, audio_file_path, text, output_path, max_wait=600):
        """Complete async voice cloning workflow"""
        # Step 1: Create task
        print("Creating task...")
        task_data = self.create_task(audio_file_path, text)
        task_id = task_data["task_id"]
        print(f"Task created: {task_id}")
        
        # Step 2: Wait for completion
        print("Waiting for completion...")
        start_time = time.time()
        
        while time.time() - start_time < max_wait:
            status_data = self.check_status(task_id)
            status = status_data["status"]
            
            print(f"Status: {status}")
            
            if status == "completed":
                # Step 3: Download result
                print("Downloading result...")
                if self.download_result(task_id, output_path):
                    print(f"Audio saved to: {output_path}")
                    return True
                else:
                    print("Failed to download result")
                    return False
            
            elif status == "failed":
                print(f"Task failed: {status_data.get('error', 'Unknown error')}")
                return False
            
            # Wait before next check
            time.sleep(30)
        
        print("Task did not complete within timeout")
        return False
 
# Usage example
client = VoiceCloningClient("YOUR_API_KEY")
success = client.clone_voice_async(
    audio_file_path="voice_sample.wav",
    text="This is a long text that will be processed asynchronously...",
    output_path="generated_speech.wav"
)
 
if success:
    print("Voice cloning completed successfully!")
else:
    print("Voice cloning failed.")

def download_with_resume(url, headers, output_path):
    """Download with resume capability for large files"""
    resume_pos = 0
    
    if os.path.exists(output_path):
        resume_pos = os.path.getsize(output_path)
        headers['Range'] = f'bytes={resume_pos}-'
    
    response = requests.get(url, headers=headers, stream=True)
    
    mode = 'ab' if resume_pos > 0 else 'wb'
    
    with open(output_path, mode) as f:
        for chunk in response.iter_content(chunk_size=8192):
            if chunk:
                f.write(chunk)
    
    return response.status_code == 200 or response.status_code == 206