Name: MiniMax Music Cover Song Restyling API
Brand: magicapi
SKU: api-magicapi-reimagine-music-song-cover-api-minimax-music-cover
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎶 Song Cover API - Restyle a Song, Keep the Melody (MiniMax Music Cover)

## Overview
MiniMax Music Cover makes a cover version of a song. Send the URL of a song and a `prompt` describing the target style, and it returns a new recording in that style. Its developer describes it as changing the voice, instruments, genre and arrangement while keeping the original melody.

By default the singer sings the lyrics extracted from the source song. Pass `lyrics` to replace them. Each request returns the URL of one audio file.

## Features
- **Style from a prompt**: describe the cover in `prompt`, for example "R&B version, smooth vocal, groovy bass" (up to 2000 characters).
- **Source song by URL**: `audio_url` must be a publicly accessible MP3 or WAV file.
- **Keep or replace the lyrics**: leave `lyrics` empty to keep the source song's lyrics, or pass new lyrics (up to 3000 characters). Use `\n` for line breaks and tags such as `[verse]`, `[chorus]` and `[bridge]` to mark sections.
- **Output format**: `mp3` (default), `wav` or `pcm`.
- **Sample rate**: `16000`, `24000`, `32000` or `44100` (default) Hz.
- **Bitrate**: `32000`, `64000`, `128000` or `256000` (default) bits per second.

## Use Cases
1. **Genre versions of your own tracks**: turn a pop demo into an acoustic, rock or R&B version without re-recording it.
2. **Alternative arrangements**: try different instrumentation and vocal styles for the same melody before producing a final mix.
3. **New lyrics on an existing melody**: keep the tune and swap in your own lyrics with `lyrics`.
4. **Content variations**: produce several stylistic takes of one song for videos, ads or games.

## Visual Examples
### Example Input
Source song (`audio_url`): [Listen to the source song](https://blog.api.market/wp-content/uploads/2026/10/music-1.5-output-api-market.mp3)

Prompt: "Acoustic folk version, warm fingerpicked guitar, soft breathy vocal, light hand percussion and gentle harmonies."

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

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

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `audio_url` | string | Yes |  |  | URL of the song to cover. Must be a publicly accessible MP3 or WAV file. |
| `prompt` | string | Yes |  |  | A description of the target style for the cover. For example: 'R&B version, smooth vocal, groovy bass' or 'Hard rock, electric guitar riffs, powerful drums'. Up to 2000 characters. |
| `lyrics` | string | No | `""` |  | Optional lyrics to override the ones extracted from the source song. If not provided, the singer will sing the original song's lyrics. Use \n for line breaks and structure tags like [verse], [chorus], [bridge] to mark sections. Up to 3000 characters. |
| `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 |
| `audio_format` | string | No | `mp3` | `mp3`, `wav`, `pcm` | Audio format for the output |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.375 per API unit.
- **1 API unit = 1 output audio file.** Each request returns one audio file, so each successful request costs $0.375, whatever the song length, lyrics, format, sample rate or bitrate.
- The example request above cost $0.375.
- **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/reimagine-music-song-cover-api-minimax-music-cover`

### 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 2 seconds 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/reimagine-music-song-cover-api-minimax-music-cover/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "0e0ffc7750cd741202e26f8d949d67f5f23f973c17c97adce6fe987217baaca1",
    "input": {
      "audio_url": "https://blog.api.market/wp-content/uploads/2026/10/music-1.5-output-api-market.mp3",
      "prompt": "Acoustic folk version, warm fingerpicked guitar, soft breathy vocal, light hand percussion and gentle harmonies."
    }
  }'
```

Response (201 Created):
```json
{
  "id": "k821t3jhwsrmw0d17frvrgcaam",
  "version": "0e0ffc7750cd741202e26f8d949d67f5f23f973c17c97adce6fe987217baaca1",
  "status": "starting",
  "created_at": "2026-10-14T19:43:53.470Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/reimagine-music-song-cover-api-minimax-music-cover/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "k821t3jhwsrmw0d17frvrgcaam",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/10/music-cover-output-api-market.mp3",
  "error": null,
  "created_at": "2026-10-14T19:43:53.470Z",
  "started_at": "2026-10-14T19:43:54.470Z",
  "completed_at": "2026-10-14T19:44:52.470Z"
}
```

`output` is a single URL string pointing to the generated audio file, in the format set by `audio_format`.

### 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 missing `audio_url` or `prompt`, or a `sample_rate` that is not in the list.
- **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, for example when `audio_url` cannot be downloaded. 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/reimagine-music-song-cover-api-minimax-music-cover";

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: "0e0ffc7750cd741202e26f8d949d67f5f23f973c17c97adce6fe987217baaca1", 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 = 2000;
  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({
  audio_url: "https://blog.api.market/wp-content/uploads/2026/10/music-1.5-output-api-market.mp3",
  prompt: "Acoustic folk version, warm fingerpicked guitar, soft breathy vocal, light hand percussion and gentle harmonies."
}).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/reimagine-music-song-cover-api-minimax-music-cover"

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": "0e0ffc7750cd741202e26f8d949d67f5f23f973c17c97adce6fe987217baaca1", "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 = 2
    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({
    "audio_url": "https://blog.api.market/wp-content/uploads/2026/10/music-1.5-output-api-market.mp3",
    "prompt": "Acoustic folk version, warm fingerpicked guitar, soft breathy vocal, light hand percussion and gentle harmonies.",
}))
```

## FAQ
- **What audio can I send as the source song?**
  - A publicly accessible MP3 or WAV file, passed as a URL in `audio_url`. The file must be downloadable without a login.
- **Does the cover keep the original lyrics?**
  - Yes, by default the singer sings the lyrics extracted from the source song. Pass `lyrics` (up to 3000 characters) to replace them.
- **How do I describe the style I want?**
  - Write it in `prompt`: genre, instruments, vocal style and mood, for example "Hard rock, electric guitar riffs, powerful drums". The prompt can be up to 2000 characters.
- **How much does one cover cost?**
  - $0.375. Each request returns one audio file, billed as one API unit, whatever the song length or output settings.
- **Which output format should I choose?**
  - `mp3` (default) gives the smallest files. Use `wav` or `pcm` for uncompressed audio, and set `sample_rate` and `bitrate` to match your pipeline.
- **Is the 201 response from POST an error?**
  - No. 201 Created means the prediction was accepted. Use the returned `id` to poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.

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


Make a cover of a song in a new style with MiniMax Music Cover: send the song URL and a style prompt, keep the melody, optionally new lyrics. $0.375 per cover.