Welcome to Suno API

Suno API enables you to create high-quality AI-generated music, lyrics, and audio content using state-of-the-art AI models. Whether you’re building music applications, automating creative workflows, or developing audio content, our API provides comprehensive tools for music generation and audio processing.

Authentication

All API requests require authentication using Bearer tokens. Please obtain your API key from the API Key Management Page.
Keep your API key secure and never share it publicly. If you suspect your key has been compromised, reset it immediately.

API Base URL

https://api.api.box

Authentication Header

Authorization: Bearer YOUR_API_KEY

Quick Start Guide

Step 1: Generate Your First Music Track

Start with a simple music generation request:
curl -X POST "https://api.api.box/api/v1/generate" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A peaceful and soothing piano piece with soft melodies",
    "customMode": false,
    "instrumental": true,
    "model": "V3_5",
    "callBackUrl": "https://your-app.com/callback"
  }'

Step 2: Check Task Status

Use the returned task ID to check generation status:
curl -X GET "https://api.api.box/api/v1/generate/record-info?taskId=YOUR_TASK_ID" \
  -H "Authorization: Bearer YOUR_API_KEY"

Response Format

Success Response:
{
  "code": 200,
  "msg": "success",
  "data": {
    "taskId": "5c79****be8e"
  }
}
Task Status Response:
{
  "code": 200,
  "msg": "success",
  "data": {
    "taskId": "5c79****be8e",
    "status": "SUCCESS",
    "response": {
      "data": [
        {
          "id": "8551****662c",
          "audio_url": "https://example.cn/****.mp3",
          "stream_audio_url": "https://example.cn/****",
          "image_url": "https://example.cn/****.jpeg",
          "prompt": "A peaceful and soothing piano piece",
          "title": "Peaceful Piano",
          "tags": "peaceful, soothing, piano",
          "duration": 198.44,
          "createTime": "2025-01-01 00:00:00"
        }
      ]
    }
  }
}

Core Features

  • Text-to-Music: Input text descriptions to generate corresponding musical compositions
  • Music Extension: Seamlessly create longer versions based on existing audio
  • Lyrics Generation: Generate structured lyrical content from creative prompts
  • Upload & Cover: Upload audio files and transform them into different musical styles
  • Vocal Separation: Separate music into independent tracks like vocals and instrumentals
  • Format Conversion: Support for WAV and other high-quality audio format outputs
  • Music Videos: Convert audio to visualized music videos
  • Style Enhancement: Enhance and optimize existing music’s stylistic features

AI Models

Choose the right model for your needs:

V3_5

Better Song StructureUp to 4 minutes, improved song organization

V4

Improved VocalsUp to 4 minutes, enhanced vocal quality

V4_5

Smart PromptsUp to 8 minutes, faster generation speed

V4_5PLUS

Richer TonesUp to 8 minutes, new creative approaches

Generation Modes

customMode
boolean
required
Controls parameter complexity:
  • false: Simple mode, only requires prompt
  • true: Advanced mode, requires style and title
instrumental
boolean
required
Determines whether music contains vocals:
  • true: Instrumental only (no lyrics)
  • false: Contains vocals/lyrics

Key Parameters

prompt
string
required
Text description of the desired music. Be specific about genre, mood, and instruments.Character Limits:
  • Non-custom mode: 400 characters
  • Custom mode (V3_5 & V4): 3000 characters
  • Custom mode (V4_5 & V4_5PLUS): 5000 characters
style
string
Music style specification (custom mode only).Examples: Jazz, Classical, Electronic, Pop, Rock, Hip-hopCharacter Limits:
  • V3_5 & V4: 200 characters
  • V4_5 & V4_5PLUS: 1000 characters
title
string
Title for the generated music track (custom mode only).Maximum Length: 80 characters

Complete Workflow Example

Here’s a complete example of generating music with lyrics and waiting for completion:
class SunoAPI {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://api.api.box/api/v1';
  }
  
  async generateMusic(prompt, options = {}) {
    const response = await fetch(`${this.baseUrl}/generate`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        prompt,
        customMode: options.customMode || false,
        instrumental: options.instrumental || false,
        model: options.model || 'V3_5',
        style: options.style,
        title: options.title,
        negativeTags: options.negativeTags,
        callBackUrl: options.callBackUrl || 'https://your-app.com/callback'
      })
    });
    
    const result = await response.json();
    if (result.code !== 200) {
      throw new Error(`Generation failed: ${result.msg}`);
    }
    
    return result.data.taskId;
  }
  
  async extendMusic(audioId, options = {}) {
    const response = await fetch(`${this.baseUrl}/generate/extend`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        audioId,
        defaultParamFlag: options.defaultParamFlag || false,
        model: options.model || 'V3_5',
        prompt: options.prompt,
        style: options.style,
        title: options.title,
        continueAt: options.continueAt,
        callBackUrl: options.callBackUrl || 'https://your-app.com/callback'
      })
    });
    
    const result = await response.json();
    if (result.code !== 200) {
      throw new Error(`Extension failed: ${result.msg}`);
    }
    
    return result.data.taskId;
  }
  
  async generateLyrics(prompt, callBackUrl) {
    const response = await fetch(`${this.baseUrl}/lyrics`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        prompt,
        callBackUrl
      })
    });
    
    const result = await response.json();
    if (result.code !== 200) {
      throw new Error(`Lyrics generation failed: ${result.msg}`);
    }
    
    return result.data.taskId;
  }
  
  async waitForCompletion(taskId, maxWaitTime = 600000) { // Max wait 10 minutes
    const startTime = Date.now();
    
    while (Date.now() - startTime < maxWaitTime) {
      const status = await this.getTaskStatus(taskId);
      
      if (status.status === 'SUCCESS') {
        return status.response;
      } else if (status.status.includes('FAILED') || status.status === 'SENSITIVE_WORD_ERROR') {
        throw new Error(`Generation failed: ${status.errorMessage || status.status}`);
      }
      
      // Wait 10 seconds before checking again
      await new Promise(resolve => setTimeout(resolve, 10000));
    }
    
    throw new Error('Generation timeout');
  }
  
  async getTaskStatus(taskId) {
    const response = await fetch(`${this.baseUrl}/generate/record-info?taskId=${taskId}`, {
      headers: {
        'Authorization': `Bearer ${this.apiKey}`
      }
    });
    
    const result = await response.json();
    return result.data;
  }
  
  async getRemainingCredits() {
    const response = await fetch(`${this.baseUrl}/generate/credit`, {
      headers: {
        'Authorization': `Bearer ${this.apiKey}`
      }
    });
    
    const result = await response.json();
    return result.data.credits;
  }
}

// Usage example
async function main() {
  const api = new SunoAPI('YOUR_API_KEY');
  
  try {
    // Check remaining credits
    const credits = await api.getRemainingCredits();
    console.log(`Remaining credits: ${credits}`);
    
    // Generate music with lyrics
    console.log('Starting music generation...');
    const taskId = await api.generateMusic(
      'A nostalgic folk song about childhood memories',
      { 
        customMode: true,
        instrumental: false,
        model: 'V4_5',
        style: 'folk, acoustic guitar, nostalgic',
        title: 'Childhood Dreams'
      }
    );
    
    // Wait for completion
    console.log(`Task ID: ${taskId}. Waiting for completion...`);
    const result = await api.waitForCompletion(taskId);
    
    console.log('Music generation successful!');
    console.log('Generated tracks:');
    result.data.forEach((track, index) => {
      console.log(`Track ${index + 1}:`);
      console.log(`  Title: ${track.title}`);
      console.log(`  Audio URL: ${track.audio_url}`);
      console.log(`  Duration: ${track.duration} seconds`);
      console.log(`  Tags: ${track.tags}`);
    });
    
    // Extend the first track
    const firstTrack = result.data[0];
    console.log('\nExtending first track...');
    const extendTaskId = await api.extendMusic(firstTrack.id, {
      defaultParamFlag: true,
      prompt: 'Continue with a hopeful chorus',
      style: 'folk, uplifting',
      title: 'Childhood Dreams Extended',
      continueAt: 60,
      model: 'V4_5'
    });
    
    const extendResult = await api.waitForCompletion(extendTaskId);
    console.log('Music extension successful!');
    console.log('Extended track URL:', extendResult.data[0].audio_url);
    
  } catch (error) {
    console.error('Error:', error.message);
  }
}

main();

Status Codes and Task Status

PENDING
Processing
Task is waiting for processing or currently generating
TEXT_SUCCESS
Partial Complete
Lyrics/text generation successfully completed
FIRST_SUCCESS
Partial Complete
First track generation completed
SUCCESS
Complete
All tracks generated successfully
CREATE_TASK_FAILED
Error
Task creation failed
GENERATE_AUDIO_FAILED
Error
Audio generation failed
SENSITIVE_WORD_ERROR
Error
Content filtered due to sensitive words

HTTP Status Codes

200
Success
Request successful
400
Bad Request
Invalid parameters or missing required fields
401
Unauthorized
No access permission, check API key
404
Not Found
Invalid request method or path
405
Rate Limited
Call limit exceeded
413
Content Too Long
Prompt or theme too long
429
Insufficient Credits
Account credits insufficient
455
Maintenance
System maintenance in progress
500
Server Error
Internal server error

Best Practices

Error Handling

Support

Need help? Our technical support team is here to assist you.
  • Email: support@api.box
  • Documentation: Check detailed API documentation and examples
  • API Status: View our status page for real-time API health information

Ready to start creating amazing AI music? Get your API key and start creating today!