Name: Full-Length Text-to-Music Generator API
Brand: magicapi
SKU: api-magicapi-text-to-music-generator-api-minimax-music-2-6
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎵 Full-Length Text-to-Music Generator API (minimax/music-2.6)

## Overview
Welcome to the Full-Length Text-to-Music Generator API (minimax/music-2.6), a powerful tool that transforms textual prompts into vibrant songs or instrumentals. This API offers high-fidelity music generation with optional auto-generated lyrics, making it perfect for various creative and commercial applications.

## Features
- **Text-to-Music Conversion**: Generate full-length songs or instrumentals from text prompts.
- **Optional Auto-Generated Lyrics**: Set `lyrics_optimizer` to `true` and leave `lyrics` empty to have lyrics written from your prompt (off by default).
- **High Fidelity Audio**: Produce music with excellent audio quality.
- **Customization**: Control music structure and arrangement via tags.
- **Flexible Output Options**: Customize bitrate, sample rate, and audio format.

## Use Cases
1. **Music Production**: Quickly generate background music or complete songs for video content, advertisements, or creative projects.
2. **Game Development**: Create unique soundtracks tailored to the mood and style of specific game levels or scenes.
3. **Marketing Campaigns**: Produce catchy jingles or theme songs to enhance brand identity and engage customers.
4. **Educational Content**: Develop musical pieces for educational material, enhancing learning experiences with customized audio.
5. **Content Creation**: Enable podcasters, YouTubers, and social media influencers to add original music to their content effortlessly.

## Visual Examples

### Example Input

```json
{
  "input": {
    "prompt": "E minor, 90 BPM, acoustic guitar ballad, male vocal, emotional, intimate studio feel",
    "lyrics": "[Verse]\nWalking through the rain tonight\nEvery drop a memory falling down\n\n[Chorus]\nBut I still remember you\nIn every song that plays\n\n[Outro]\nI still remember you..."
  }
}
```

### Example Output

![Example output from Full-Length Text-to-Music Generator API (minimax/music-2.6)](https://blog.api.market/wp-content/uploads/2026/09/music-2-6-output-api-market.mp3)

This exact request was run through api.market and billed 1 API unit ($0.19).
## Pricing
- Pay As You Go (PAYG) pricing - you only pay for what you use
- Price: $0.19 per API unit.
- 1 API unit = 1 output audio file.
- Failed or cancelled predictions are not billed
- GET requests to check prediction status (`GET /api/v1/magicapi/text-to-music-generator-api-minimax-music-2-6/predictions/{id}`) are free and don't count toward API unit usage
- No monthly subscription fee

## API Documentation

### Base URL
All API requests should be made to: `https://prod.api.market/api/v1/magicapi/text-to-music-generator-api-minimax-music-2-6`

### Authentication
Authentication is handled via API key. Include your API key in the request header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API uses asynchronous processing for predictions. The typical flow is:

1. Submit a prediction request to the POST endpoint
2. Receive a prediction ID in the response
3. Poll the GET endpoint with the prediction ID to check status
4. Continue polling until the prediction is complete

### Endpoints
#### Create a Prediction

`POST /api/v1/magicapi/text-to-music-generator-api-minimax-music-2-6/predictions`

**Input parameters** (sent inside `input`; the schema marks no field as always required):

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `lyrics` | string | See description | `""` | Song lyrics, 1 to 3,500 characters. Use `\n` to separate lines and structure tags such as `[Intro]`, `[Verse]`, `[Pre Chorus]`, `[Chorus]`, `[Interlude]`, `[Bridge]`, `[Outro]`, `[Post Chorus]`, `[Transition]`, `[Break]`, `[Hook]`, `[Build Up]`, `[Inst]` or `[Solo]`. Not needed when `is_instrumental` is true. |
| `prompt` | string | See description | `""` | Music style, mood and scenario, 0 to 2,000 characters. Required when `is_instrumental` is true. |
| `is_instrumental` | boolean | No | `false` | Generates music without vocals. When true, `prompt` is required and `lyrics` are not needed. |
| `lyrics_optimizer` | boolean | No | `false` | Generates lyrics from the prompt when `lyrics` is empty. |
| `sample_rate` | integer | No | `44100` | `16000`, `24000`, `32000` or `44100`. |
| `bitrate` | integer | No | `256000` | `32000`, `64000`, `128000` or `256000`. |
| `audio_format` | string | No | `mp3` | `mp3`, `wav` or `pcm`. |
```bash
# Example for creating a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/text-to-music-generator-api-minimax-music-2-6/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "dcd69b2c83c63ed612af65fc9842781fd7cf86db555e0b12ded7c6292bff8b7a",
    "input": {
      "lyrics": "[Verse]\nWalking through the rain tonight\nEvery drop a memory falling down\n\n[Chorus]\nBut I still remember you\nIn every song that plays\n\n[Outro]\nI still remember you...",
      "prompt": "E minor, 90 BPM, acoustic guitar ballad, male vocal, emotional, intimate studio feel",
      "bitrate": 256000,
      "sample_rate": 44100,
      "audio_format": "mp3",
      "is_instrumental": false,
      "lyrics_optimizer": false
    }
  }'
```

#### Check Prediction Status
```bash
# Example for checking prediction status
curl -X GET "https://prod.api.market/api/v1/magicapi/text-to-music-generator-api-minimax-music-2-6/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

#### Sample JSON Response for Checking Status
```json
{
  "id": "abcd1234",
  "status": "succeeded",
  "input": {
    "lyrics": "[Verse]\nWalking through the rain tonight...",
    "prompt": "E minor, 90 BPM, acoustic guitar ballad...",
    "bitrate": 256000,
    "sample_rate": 44100,
    "audio_format": "mp3",
    "is_instrumental": false,
    "lyrics_optimizer": false
  },
  "output": "https://blog.api.market/wp-content/uploads/2026/09/music-2-6-output-api-market.mp3"
}
```

## Status Codes
- **200 OK**: Request successful
- **201 Created**: Resource successfully created
- **400 Bad Request**: Invalid input parameters or malformed request
- **401 Unauthorized**: Missing or invalid API key
- **403 Forbidden**: Valid API key but insufficient permissions
- **404 Not Found**: Resource not found
- **429 Too Many Requests**: Rate limit exceeded
- **500 Internal Server Error**: Server-side error
- **503 Service Unavailable**: Service temporarily unavailable

## Rate Limits
This API may enforce rate limits to ensure optimal performance and resource usage. Ensure your application handles rate limits gracefully and implements retry strategies where necessary.

## Error Handling
### Common Error Responses
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'prompt' is required when 'is_instrumental' is true",
    "status": 400
  }
}
```
### Error Handling Best Practices
- **Interpret error responses**: Understand the error codes and messages returned by the API.
- **Common errors**: Address issues like invalid input or missing parameters promptly based on the error response.
- **Retry strategies**: Implement exponential backoff or fixed interval retry mechanisms for handling transient errors.

## Implementation Guide
### Example Code
#### JavaScript
```javascript
// JavaScript example with proper polling and timeout
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/text-to-music-generator-api-minimax-music-2-6";

async function createAndWaitForPrediction(inputData) {
  try {
    // Step 1: Create the prediction
    const response = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-api-market-key": apiKey
      },
      body: JSON.stringify({ version: "dcd69b2c83c63ed612af65fc9842781fd7cf86db555e0b12ded7c6292bff8b7a", input: inputData })
    });
    
    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }
    
    const prediction = await response.json();
    const predictionId = prediction.id;
    
    // Step 2: Poll for results with timeout
    return await pollForResults(predictionId);
  } catch (error) {
    console.error("Error:", error);
    throw error;
  }
}

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function pollForResults(predictionId) {
  const MAX_TIMEOUT = 600000; // 600 seconds (10 minutes)
  const POLL_INTERVAL = 1000; // 1 second between checks
  
  const startTime = Date.now();
  
  while (Date.now() - startTime < MAX_TIMEOUT) {
    // Check prediction status
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: {
        "x-api-market-key": apiKey
      }
    });
    
    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }
    
    const prediction = await response.json();
    
    // Check status and return if completed
    if (prediction.status === "succeeded") {
      return prediction.output;
    }
    
    // Handle failure
    if (prediction.status === "failed") {
      throw new Error(`Prediction failed: ${prediction.error || "Unknown error"}`);
    }
    
    // Wait before next poll
    await delay(POLL_INTERVAL);
  }
  
  throw new Error("Prediction timed out after 10 minutes");
}
```
#### Python
```python
# Python example with proper polling and timeout
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/text-to-music-generator-api-minimax-music-2-6"

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY
    }
    
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "dcd69b2c83c63ed612af65fc9842781fd7cf86db555e0b12ded7c6292bff8b7a", "input": input_data}
    )
    
    if response.status_code not in (200, 201):
        raise Exception(f"API error: {response.status_code} {response.text}")
    
    prediction = response.json()
    prediction_id = prediction["id"]
    
    # Step 2: Poll for results with timeout
    return poll_for_results(prediction_id)

def poll_for_results(prediction_id):
    MAX_TIMEOUT = 600  # 600 seconds (10 minutes)
    POLL_INTERVAL = 1  # 1 second between checks
    
    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()
    
    while time.time() - start_time < MAX_TIMEOUT:
        # Check prediction status
        response = requests.get(
            f"{BASE_URL}/predictions/{prediction_id}",
            headers=headers
        )
        
        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")
        
        prediction = response.json()
        
        # Check status and return if completed
        if prediction["status"] == "succeeded":
            return prediction["output"]
        
        # Handle failure
        if prediction["status"] == "failed":
            error_msg = prediction.get("error", "Unknown error")
            raise Exception(f"Prediction failed: {error_msg}")
        
        # Wait before next poll
        time.sleep(POLL_INTERVAL)
    
    raise Exception("Prediction timed out after 10 minutes")
```
#### cURL
```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/text-to-music-generator-api-minimax-music-2-6/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "dcd69b2c83c63ed612af65fc9842781fd7cf86db555e0b12ded7c6292bff8b7a",
    "input": {
      "lyrics": "[Verse]\nWalking through the rain tonight\nEvery drop a memory falling down\n\n[Chorus]\nBut I still remember you\nIn every song that plays\n\n[Outro]\nI still remember you...",
      "prompt": "E minor, 90 BPM, acoustic guitar ballad, male vocal, emotional, intimate studio feel",
      "bitrate": 256000,
      "sample_rate": 44100,
      "audio_format": "mp3",
      "is_instrumental": false,
      "lyrics_optimizer": false
    }
  }'

# Step 2: Check prediction status (replace abcd1234 with the actual ID)
curl -X GET "https://prod.api.market/api/v1/magicapi/text-to-music-generator-api-minimax-music-2-6/predictions/abcd1234" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
To optimize API usage and minimize costs:
- **Efficient Polling**: Implement optimal polling intervals to check the prediction status without overwhelming the server.
- **Caching Results**: Cache successful predictions to avoid repeated API calls for the same input.

## FAQ
**Q: Can the API generate instrumental tracks?**
A: Yes. Set `is_instrumental` to `true` and provide a `prompt`; `lyrics` are not needed.

**Q: What happens if my prediction fails?**
A: Failed predictions are not billed, and you can resubmit the request.

**Q: How do I control the song structure?**
A: Use structure tags like [Verse], [Chorus], [Bridge], etc., in the lyrics to control the arrangement.

## Contact Us
If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello@magicapi.com.

Generate songs or instrumentals from a text prompt and your lyrics, or let the model write lyrics from the prompt. MP3, WAV or PCM output.