Query Status

import requests
import time

def wait_for_completion(task_id, max_wait=300, poll_interval=5):
    """
    Poll task status until completion or timeout

    Args:
        task_id: The task ID to monitor
        max_wait: Maximum time to wait in seconds (default 300s)
        poll_interval: Time between polls in seconds (default 5s)

    Returns:
        Task data if successful, None if timeout or error
    """
    url = f"https://gptproto.com/v1/suno/fetch/{task_id}"
    headers = {
        "Authorization": "YOUR_API_KEY",
        "Content-Type": "application/json"
    }

    start_time = time.time()

    while time.time() - start_time < max_wait:
        try:
            response = requests.get(url, headers=headers)
            result = response.json()

            if result["code"] != "success" or not result["data"]:
                print(f"Error: {result.get('message', 'Unknown error')}")
                return None

            task = result["data"][0]
            status = task["status"]

            elapsed = int(time.time() - start_time)
            print(f"[{elapsed}s] Status: {status}", end="")

            if status == "completed":
                print(f"\n✓ Music generated successfully!")
                print(f"Audio URL: {task['audio_url']}")
                return task

            elif status == "failed":
                error_msg = task.get('error_message', 'Unknown error')
                print(f"\n✗ Generation failed: {error_msg}")
                return None

            elif status == "processing":
                progress = task.get('progress', 0)
                print(f" - Progress: {progress}%")

            else:  # queued
                print(" - Waiting in queue...")

            time.sleep(poll_interval)

        except Exception as e:
            print(f"\nError querying task: {e}")
            time.sleep(poll_interval)

    print(f"\n✗ Timeout: Task did not complete within {max_wait} seconds")
    return None

# Usage
task_id = "15410652-357c-47fa-8ad9-a4a145fbfa14"
result = wait_for_completion(task_id)

if result:
    print(f"Title: {result.get('title', 'Untitled')}")
    print(f"Duration: {result.get('duration', 0)} seconds")

async function waitForCompletion(taskId, maxWait = 300, pollInterval = 5) {
  const url = `https://gptproto.com/v1/suno/fetch/${taskId}`;
  const headers = {
    'Authorization': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  };

  const startTime = Date.now();

  while ((Date.now() - startTime) / 1000 < maxWait) {
    try {
      const response = await fetch(url, { method: 'GET', headers });
      const result = await response.json();

      if (result.code !== 'success' || !result.data) {
        console.log(`Error: ${result.message || 'Unknown error'}`);
        return null;
      }

      const task = result.data[0];
      const elapsed = Math.floor((Date.now() - startTime) / 1000);

      process.stdout.write(`[${elapsed}s] Status: ${task.status}`);

      if (task.status === 'completed') {
        console.log('\n✓ Music generated successfully!');
        console.log(`Audio URL: ${task.audio_url}`);
        return task;
      } else if (task.status === 'failed') {
        console.log(`\n✗ Generation failed: ${task.error_message || 'Unknown error'}`);
        return null;
      } else if (task.status === 'processing') {
        console.log(` - Progress: ${task.progress || 0}%`);
      } else {
        console.log(' - Waiting in queue...');
      }

      await new Promise(resolve => setTimeout(resolve, pollInterval * 1000));
    } catch (error) {
      console.log(`\nError querying task: ${error}`);
      await new Promise(resolve => setTimeout(resolve, pollInterval * 1000));
    }
  }

  console.log(`\n✗ Timeout: Task did not complete within ${maxWait} seconds`);
  return null;
}

// Usage
const taskId = '15410652-357c-47fa-8ad9-a4a145fbfa14';
waitForCompletion(taskId).then(result => {
  if (result) {
    console.log(`Title: ${result.title || 'Untitled'}`);
    console.log(`Duration: ${result.duration || 0} seconds`);
  }
});

import requests
import time
import os

class SunoMusicGenerator:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://gptproto.com/v1/suno"
        self.headers = {
            "Authorization": api_key,
            "Content-Type": "application/json"
        }

    def submit_task(self, prompt, **kwargs):
        """Submit a music generation task"""
        url = f"{self.base_url}/submit/music"
        payload = {"prompt": prompt, **kwargs}

        response = requests.post(url, headers=self.headers, json=payload)
        result = response.json()

        if result["code"] == "success":
            print(f"✓ Task submitted: {result['data']}")
            return result["data"]
        else:
            raise Exception(f"Error: {result['message']}")

    def query_task(self, task_id):
        """Query task status"""
        url = f"{self.base_url}/fetch/{task_id}"
        response = requests.get(url, headers=self.headers)
        result = response.json()

        if result["code"] == "success" and result["data"]:
            return result["data"][0]
        return None

    def wait_for_completion(self, task_id, max_wait=300, poll_interval=5):
        """Wait for task to complete"""
        start_time = time.time()

        while time.time() - start_time < max_wait:
            task = self.query_task(task_id)

            if not task:
                return None

            elapsed = int(time.time() - start_time)
            print(f"[{elapsed}s] {task['status']}", end="")

            if task["status"] == "completed":
                print(" ✓")
                return task
            elif task["status"] == "failed":
                print(f" ✗ {task.get('error_message', 'Unknown error')}")
                return None
            elif task["status"] == "processing":
                print(f" - {task.get('progress', 0)}%")
            else:
                print(" - queued")

            time.sleep(poll_interval)

        print(f"\n✗ Timeout after {max_wait}s")
        return None

    def download_audio(self, audio_url, output_path):
        """Download the generated audio"""
        response = requests.get(audio_url)

        if response.status_code == 200:
            os.makedirs(os.path.dirname(output_path), exist_ok=True)

            with open(output_path, 'wb') as f:
                f.write(response.content)

            print(f"✓ Downloaded to: {output_path}")
            return True

        return False

    def generate_and_download(self, prompt, output_dir="./music", **kwargs):
        """Complete workflow: submit, wait, and download"""
        # Submit task
        task_id = self.submit_task(prompt, **kwargs)

        # Wait for completion
        task = self.wait_for_completion(task_id)

        if not task:
            print("✗ Generation failed or timed out")
            return None

        # Download audio
        title = task.get("title", "untitled").replace(" ", "_")
        output_path = os.path.join(output_dir, f"{title}.mp3")

        if self.download_audio(task["audio_url"], output_path):
            return {
                "task_id": task_id,
                "audio_path": output_path,
                "task_data": task
            }

        return None

# Usage
generator = SunoMusicGenerator("YOUR_API_KEY")

result = generator.generate_and_download(
    prompt="Epic orchestral battle music with dramatic crescendo",
    tags="orchestral, epic, cinematic",
    make_instrumental=True
)

if result:
    print(f"\n{'='*50}")
    print(f"Task ID: {result['task_id']}")
    print(f"Audio File: {result['audio_path']}")
    print(f"Title: {result['task_data']['title']}")
    print(f"Duration: {result['task_data']['duration']}s")
    print(f"{'='*50}")