Name: Music Generation API with Lyrics (MiniMax Music-01)
Brand: magicapi
SKU: api-magicapi-music-generation-with-lyrics-vocals-minimax-music-01
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎵 Music Generation API with Lyrics and Vocals (MiniMax Music-01)

## Overview
Music-01 is a music generation model from MiniMax. It generates up to 1 minute of music with lyrics and vocals in the style of a reference track. You send your `lyrics` and a reference: either a full song with music and vocals (`song_file`), or separate voice (`voice_file`) and instrumental (`instrumental_file`) references.

Each request returns the URL of one audio file.

## Features
- **Style from a reference track**: `song_file` takes a reference song that contains music and vocals.
- **Separate voice and instrumental references**: use `voice_file` and `instrumental_file` instead of a full song. With only an instrumental reference the model generates a track without vocals; with only a voice reference it generates an a cappella vocal hum.
- **Reference files** must be .wav or .mp3 files longer than 15 seconds.
- **Lyrics formatting**: put each lyric line on its own line, use two newlines to add a pause between lines, and put double hash marks (`##`) at the beginning and end of the lyrics to add accompaniment. Lyrics can be at most 350 to 400 characters.
- **Reuse references**: `voice_id` and `instrumental_id` reuse a previously uploaded voice or instrumental ID.
- **Sample rate**: 16000, 24000, 32000 or 44100 (default) Hz.
- **Bitrate**: 32000, 64000, 128000 or 256000 (default) bps.

## Use Cases
1. **Songs in the style of an existing track**: hear new lyrics sung in the style of a reference song.
2. **Songwriting drafts**: try out lyrics quickly before recording.
3. **Short jingles and intros**: brief vocal tracks for videos, podcasts and ads.
4. **Instrumental tracks**: give only an instrumental reference to get music without vocals.

## Visual Examples
### Example Input
Lyrics:
```
[verse]
Ship it on a Friday night
API keys are shining bright
[chorus]
One call, one key, api.market and me
```

Reference song (`song_file`): [listen to the reference song](https://blog.api.market/wp-content/uploads/2026/10/music-1.5-output-api-market.mp3). This is a 60 second excerpt of a song we generated with MiniMax Music-1.5 on api.market.

All other fields were left at their defaults (44100 Hz, 256000 bps).

### Example Output
[Listen to the example](https://blog.api.market/wp-content/uploads/2026/10/music-01-output-api-market.mp3)

The generated track in this example is about 8 seconds long.

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `lyrics` | string | No | `""` (empty) |  | Lyrics with optional formatting. You can use a newline to separate each line of lyrics. You can use two newlines to add a pause between lines. You can use double hash marks (##) at the beginning and end of the lyrics to add accompaniment. Maximum 350 to 400 characters. |
| `song_file` | string (URL) | No | none |  | Reference song, should contain music and vocals. Must be a .wav or .mp3 file longer than 15 seconds. |
| `voice_file` | string (URL) | No | none |  | Voice reference. Must be a .wav or .mp3 file longer than 15 seconds. If only a voice reference is given, an a cappella vocal hum will be generated. |
| `instrumental_file` | string (URL) | No | none |  | Instrumental reference. Must be a .wav or .mp3 file longer than 15 seconds. If only an instrumental reference is given, a track without vocals will be generated. |
| `voice_id` | string | No | none |  | Reuse a previously uploaded voice ID |
| `instrumental_id` | string | No | none |  | Reuse a previously uploaded instrumental ID |
| `sample_rate` | integer | No | `44100` | `16000`, `24000`, `32000`, `44100` | Sample rate for the generated music |
| `bitrate` | integer | No | `256000` | `32000`, `64000`, `128000`, `256000` | Bitrate for the generated music |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.044 per API unit.
- **1 API unit = 1 output audio file.** Each request returns one audio file, so each successful request uses 1 API unit and costs $0.044, whatever the track length, reference files, sample rate or bitrate.
- **Failed or cancelled predictions are not billed.**
- **GET requests to check prediction status** are free and don't count toward API unit usage.
- **No monthly subscription fee.**

## API Documentation

### Base URL
All API requests go to: `https://prod.api.market/api/v1/magicapi/music-generation-with-lyrics-vocals-minimax-music-01`

### Authentication
Send your api.market API key in the `x-api-market-key` header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. The flow is:
1. Send a POST request to `/predictions`. A successful request returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`.
2. Poll GET `/predictions/{id}` with that ID.
3. Keep polling while `status` is `starting` or `processing`.
4. Stop when `status` is `succeeded` (read `output`), `failed` or `canceled` (read `error`).

A polling interval of 1 second and an overall timeout of 600 seconds (10 minutes) work well.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/music-generation-with-lyrics-vocals-minimax-music-01/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "0254c7e2f54315b667dbae03da7c155822ba29ffe0457be5bc246d564be486bd",
    "input": {
      "lyrics": "[verse]\nShip it on a Friday night\nAPI keys are shining bright\n[chorus]\nOne call, one key, api.market and me",
      "song_file": "https://blog.api.market/wp-content/uploads/2026/10/music-1.5-output-api-market.mp3"
    }
  }'
```

Response (201 Created):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "0254c7e2f54315b667dbae03da7c155822ba29ffe0457be5bc246d564be486bd",
  "status": "starting",
  "created_at": "2026-10-13T10:49:23.554Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/music-generation-with-lyrics-vocals-minimax-music-01/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/10/music-01-output-api-market.mp3",
  "error": null,
  "created_at": "2026-10-13T10:49:23.554Z",
  "started_at": "2026-10-13T10:49:24.554Z",
  "completed_at": "2026-10-13T10:49:53.554Z"
}
```

`output` is the URL of the generated audio file.

### Status Codes
- **201 Created**: prediction created (POST `/predictions`). This is the normal success response.
- **200 OK**: prediction details returned (GET `/predictions/{id}`).
- **400 Bad Request**: invalid input, for example a `sample_rate` or `bitrate` outside the allowed values.
- **401 Unauthorized**: missing or invalid API key.
- **404 Not Found**: no prediction with that ID.
- **429 Too Many Requests**: rate limit exceeded.
- **500 Internal Server Error** or **503 Service Unavailable**: temporary server problem; retry later.

## Rate Limits

All plans allow 10 requests per second. Requests above that return `429 Too Many Requests`; back off before retrying and honour any `Retry-After` header. Polling a prediction with GET is free but still counts toward the per-second limit, so poll every 1 to 5 seconds rather than in a tight loop.

## Error Handling
- Check the HTTP status code of every request and read the response body for the error message.
- A prediction can also end with `status` set to `failed`; the `error` field then explains why. Failed predictions are not billed.
- Retry 429, 500 and 503 responses with exponential backoff. Fix the input before retrying a 400.

## Implementation Guide
### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/music-generation-with-lyrics-vocals-minimax-music-01";

async function createAndWaitForPrediction(input) {
  const response = await fetch(`${baseUrl}/predictions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey
    },
    body: JSON.stringify({ version: "0254c7e2f54315b667dbae03da7c155822ba29ffe0457be5bc246d564be486bd", input })
  });

  if (response.status !== 201) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

  const prediction = await response.json();
  return pollForResults(prediction.id);
}

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function pollForResults(predictionId) {
  const maxTimeout = 600000;
  const pollInterval = 1000;
  const startTime = Date.now();

  while (Date.now() - startTime < maxTimeout) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: { "x-api-market-key": apiKey }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${await response.text()}`);
    }

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output;
    }

    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction ${prediction.status}: ${prediction.error || "Unknown error"}`);
    }

    await delay(pollInterval);
  }

  throw new Error("Prediction timed out after 10 minutes");
}

createAndWaitForPrediction({
      "lyrics": "[verse]\nShip it on a Friday night\nAPI keys are shining bright\n[chorus]\nOne call, one key, api.market and me",
      "song_file": "https://blog.api.market/wp-content/uploads/2026/10/music-1.5-output-api-market.mp3"
  }).then((output) => console.log(output));
```

#### Python
```python
import time
import requests

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/music-generation-with-lyrics-vocals-minimax-music-01"

def create_and_wait_for_prediction(input_data):
    headers = {"Content-Type": "application/json", "x-api-market-key": API_KEY}
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "0254c7e2f54315b667dbae03da7c155822ba29ffe0457be5bc246d564be486bd", "input": input_data},
    )

    if response.status_code != 201:
        raise Exception(f"API error: {response.status_code} {response.text}")

    return poll_for_results(response.json()["id"])

def poll_for_results(prediction_id):
    max_timeout = 600
    poll_interval = 1
    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()

    while time.time() - start_time < max_timeout:
        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()

        if prediction["status"] == "succeeded":
            return prediction["output"]

        if prediction["status"] in ("failed", "canceled"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'Unknown error'}")

        time.sleep(poll_interval)

    raise Exception("Prediction timed out after 10 minutes")

print(create_and_wait_for_prediction({
    "lyrics": "[verse]\nShip it on a Friday night\nAPI keys are shining bright\n[chorus]\nOne call, one key, api.market and me",
    "song_file": "https://blog.api.market/wp-content/uploads/2026/10/music-1.5-output-api-market.mp3"
}))
```

## FAQ
- **Which reference do I need?**
  - Send a full song as `song_file`, or a voice reference (`voice_file`), an instrumental reference (`instrumental_file`), or both. Each file must be a .wav or .mp3 longer than 15 seconds.
- **How long are the generated tracks?**
  - Up to 1 minute. The example above is about 8 seconds long.
- **Does the response return voice or instrumental IDs?**
  - No. The response `output` is only the URL of the audio file.
- **What does one track cost?**
  - $0.044 per generated audio file.
- **How long does a prediction take?**
  - It varies by request. Poll every second and stop after 10 minutes.
- **What if my prediction fails?**
  - Failed predictions are not billed. Read the `error` field, adjust the input and try again.

## 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.


MiniMax Music-01 API: generate up to 1 minute of music with your lyrics and vocals in the style of a reference song, voice or instrumental track.