suno/chirp-v6-wild

text-to-audio

Suno chirp-v6 wild API by SUNO

suno/chirp-v6-wild

Chirp-v6-wild

Suno V6 Wild via APIMart: the experimental V6 variant with bolder, less conventional arrangements. Same modes and pricing as chirp-v6. Async; returns 2 tracks per generation.

Suno chirp-v6 wild is developed by Suno. Atlas Cloud (operated by Atlas Cloud AI LLC) provides access to it and does not own it. All trademarks belong to their respective owners.

INPUT

Prompt

Custom mode

Instrumental

Variety

Vocal gender

Title

Style

Duration

Additional Settings

OUTPUT

Idle

Your song will appear here

Describe the song and click Run to compose it.

Parameters

Code Example
import requests
import time

# Step 1: Start audio generation
generate_url = "https://api.atlascloud.ai/api/v1/model/generateAudio"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}
data = {
    "model": "suno/chirp-v6-wild",  # Required. Model name. options: suno/chirp-v6-wild
    "prompt": "Late-night city lo-fi piano with the sound of rain",  # With custom=false (default): an inspiration description of the song (style, mood, genre, theme)
    "custom": False,  # false = inspiration mode (prompt is a description)
    "instrumental": False,  # Instrumental only, no vocals
    "vocal_gender": "example_value",  # Vocal gender. options: Male | Female
    "title": "example_value",  # Song title
    "style": "example_value",  # Style tags, e
    "negative_tags": "example_value",  # Styles to avoid
    "auto_lyrics": False,  # Let the model rewrite the supplied lyrics creatively
    "style_weight": 0,  # How strongly to follow style. (min: 0, max: 1)
    "weirdness_constraint": 0,  # Creativity / weirdness. (min: 0, max: 1)
    "audio_weight": 0,  # Audio reference weight. (min: 0, max: 1)
    "persona_id": "example_value",  # Persona (voice identity) id
    "variety": "example_value",  # How much the two takes should diverge from the most predictable rendition of the prompt. options: off | normal | high | extra | max
    "duration": 10,  # Target song length in seconds (10–360). (min: 10, max: 360)
}

generate_response = requests.post(generate_url, headers=headers, json=data)
generate_result = generate_response.json()
prediction_id = generate_result["data"]["id"]

# Step 2: Poll for result
poll_url = f"https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}"

def check_status():
    while True:
        response = requests.get(poll_url, headers={"Authorization": "Bearer $ATLASCLOUD_API_KEY"})
        result = response.json()

        if result["data"]["status"] in ["completed", "succeeded"]:
            print("Generated audio:", result["data"]["outputs"][0])
            return result["data"]["outputs"][0]
        elif result["data"]["status"] == "failed":
            raise Exception(result["data"]["error"] or "Generation failed")
        else:
            # Still processing, wait 2 seconds
            time.sleep(2)

audio_url = check_status()

Install

Install the required package for your language.

pip install requests

Authentication

All API requests require authentication via an API key. You can get your API key from the Atlas Cloud dashboard.

export ATLASCLOUD_API_KEY="your-api-key-here"

HTTP Headers

import os

API_KEY = os.environ.get("ATLASCLOUD_API_KEY")
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {API_KEY}"
}

Keep your API key secure

Never expose your API key in client-side code or public repositories. Use environment variables or a backend proxy instead.

Submit a request

import requests

url = "https://api.atlascloud.ai/api/v1/model/generateAudio"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}
data = {
    "model": "your-model",
    "text": "Hello, welcome to AtlasCloud text-to-speech."
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

Submit a Request

Submit an asynchronous generation request. The API returns a prediction ID that you can use to check the status and retrieve the result.

POST/api/v1/model/generateAudio

Request Body

import requests

url = "https://api.atlascloud.ai/api/v1/model/generateAudio"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}

data = {
    "model": "suno/chirp-v6-wild",
    "text": "Hello, welcome to AtlasCloud text-to-speech."
}

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

print(f"Prediction ID: {result['data']['id']}")
print(f"Status: {result['data']['status']}")

Response

{
  "code": 200,
  "data": {
    "id": "pred_abc123",
    "status": "processing",
    "model": "model-name",
    "created_at": "2025-01-01T00:00:00Z"
  }
}

Check Status

Poll the prediction endpoint to check the current status of your request.

GET/api/v1/model/prediction/{prediction_id}

Polling Example

import requests
import time

prediction_id = "pred_abc123"
url = f"https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}"
headers = { "Authorization": "Bearer $ATLASCLOUD_API_KEY" }

while True:
    response = requests.get(url, headers=headers)
    result = response.json()
    status = result["data"]["status"]
    print(f"Status: {status}")

    if status in ["completed", "succeeded"]:
        output_url = result["data"]["outputs"][0]
        print(f"Output URL: {output_url}")
        break
    elif status == "failed":
        print(f"Error: {result['data'].get('error', 'Unknown')}")
        break

    time.sleep(3)

Status Values

processingThe request is still being processed.

completedGeneration is complete. Outputs are available.

succeededGeneration succeeded. Outputs are available.

failedGeneration failed. Check the error field.

Completed Response

{
  "data": {
    "id": "pred_abc123",
    "status": "completed",
    "outputs": [
      "https://storage.atlascloud.ai/outputs/result.mp3"
    ],
    "metrics": {
      "predict_time": 8.3
    },
    "created_at": "2025-01-01T00:00:00Z",
    "completed_at": "2025-01-01T00:00:10Z"
  }
}

Input Schema

The following parameters are accepted in the request body.

Total: 15Required: 1Optional: 14

modelstringrequired

Model name.

Default: "suno/chirp-v6-wild"

suno/chirp-v6-wild

promptstring

With custom=false (default): an inspiration description of the song (style, mood, genre, theme). With custom=true: the actual lyrics, e.g. "[Verse]\n...\n[Chorus]\n...". Required unless custom=true and instrumental=true.

Default: "Late-night city lo-fi piano with the sound of rain"

customboolean

false = inspiration mode (prompt is a description). true = custom mode (prompt is used as lyrics, and title / style / negative_tags / auto_lyrics / persona_id / style_weight / weirdness_constraint / audio_weight / duration take effect).

Default: false

instrumentalboolean

Instrumental only, no vocals.

Default: false

vocal_genderstring

Vocal gender. Takes effect in both modes.

MaleFemale

titlestring

Song title. Only takes effect when custom=true (ignored otherwise).

stylestring

Style tags, e.g. "synthwave, female vocal, cinematic". Only takes effect when custom=true (ignored otherwise).

negative_tagsstring

Styles to avoid. Only takes effect when custom=true.

auto_lyricsboolean

Let the model rewrite the supplied lyrics creatively. Only when custom=true.

Default: false

style_weightnumber

How strongly to follow style. Only when custom=true.

Min: 0Max: 1

weirdness_constraintnumber

Creativity / weirdness. Only when custom=true.

Min: 0Max: 1

audio_weightnumber

Audio reference weight. Only when custom=true.

Min: 0Max: 1

persona_idstring

Persona (voice identity) id. Only when custom=true.

varietystring

How much the two takes should diverge from the most predictable rendition of the prompt. off = conservative, max = most adventurous. Works in both modes.

offnormalhighextramax

durationinteger

Target song length in seconds (10–360). Only takes effect when custom=true; the finished track may differ slightly from the target.

Min: 10Max: 360

Example Request Body

{
  "model": "suno/chirp-v6-wild",
  "prompt": "Late-night city lo-fi piano with the sound of rain",
  "custom": false,
  "instrumental": false,
  "auto_lyrics": false
}

Output Schema

The API returns a prediction response with the generated output URLs.

idstring

modelstring

statusstring

created|processing|completed|failed

outputsarray

Generated song URLs (2 tracks per generation).

thumbnailstring

Cover art generated alongside the song.

Example Response

{
  "id": "pred_abc123",
  "status": "completed",
  "model": "model-name",
  "outputs": [
    "https://storage.atlascloud.ai/outputs/result.png"
  ],
  "metrics": {
    "predict_time": 8.3
  },
  "created_at": "2025-01-01T00:00:00Z",
  "completed_at": "2025-01-01T00:00:10Z"
}

Atlas Cloud Skills

Atlas Cloud Skills integrates 400+ AI models directly into your AI coding assistant. One command to install, then use natural language to generate images, videos, and chat with LLMs.

Supported Clients

Claude Code

OpenAI Codex

Gemini CLI

Cursor

Windsurf

VS Code

Trae

GitHub Copilot

Cline

Roo Code

Amp

Goose

Replit

40+ supported clients

Install

npx skills add AtlasCloudAI/atlas-cloud-skills

Setup API Key

Get your API key from the Atlas Cloud dashboard and set it as an environment variable.

export ATLASCLOUD_API_KEY="your-api-key-here"

Capabilities

Once installed, you can use natural language in your AI assistant to access all Atlas Cloud models.

Image GenerationGenerate images with models like Nano Banana 2, Z-Image, and more.

Video CreationCreate videos from text or images with Kling, Vidu, Veo, etc.

LLM ChatChat with Qwen, DeepSeek, and other large language models.

Media UploadUpload local files for image editing and image-to-video workflows.

Learn more

github.com/AtlasCloudAI/atlas-cloud-skills

MCP Server

Atlas Cloud MCP Server connects your IDE with 400+ AI models via the Model Context Protocol. Works with any MCP-compatible client.

Supported Clients

Cursor

VS Code

Windsurf

Claude Code

OpenAI Codex

Gemini CLI

Cline

Roo Code

100+ supported clients

Install

npx -y atlascloud-mcp

Configuration

Add the following configuration to your IDE's MCP settings file.

{
  "mcpServers": {
    "atlascloud": {
      "command": "npx",
      "args": [
        "-y",
        "atlascloud-mcp"
      ],
      "env": {
        "ATLASCLOUD_API_KEY": "your-api-key-here"
      }
    }
  }
}

Available Tools

atlas_generate_imageGenerate images from text prompts.

atlas_generate_videoCreate videos from text or images.

atlas_chatChat with large language models.

atlas_list_modelsBrowse 400+ available AI models.

atlas_quick_generateOne-step content creation with auto model selection.

atlas_upload_mediaUpload local files for API workflows.

Learn more

github.com/AtlasCloudAI/mcp-server

API Schema

{
  "info": {
    "title": "AtlasCloud API",
    "version": "1.0.0",
    "description": "The AtlasCloud API."
  },
  "openapi": "3.0.0",
  "paths": {
    "/api/v1/model/generateAudio": {
      "post": {
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/Input"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PredictionResponse"
                }
              }
            },
            "description": "The request status."
          }
        },
        "x-api-name": "model_run"
      }
    },
    "/api/v1/model/prediction/{request_id}": {
      "get": {
        "parameters": [
          {
            "in": "path",
            "name": "request_id",
            "required": true,
            "schema": {
              "description": "Request ID",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PredictionResponse"
                }
              }
            },
            "description": "Result of the request."
          }
        },
        "x-api-name": "model_result"
      }
    }
  },
  "components": {
    "schemas": {
      "Input": {
        "type": "object",
        "properties": {
          "model": {
            "type": "string",
            "description": "Model name.",
            "default": "suno/chirp-v6-wild",
            "enum": [
              "suno/chirp-v6-wild"
            ]
          },
          "prompt": {
            "type": "string",
            "description": "With custom=false (default): an inspiration description of the song (style, mood, genre, theme). With custom=true: the actual lyrics, e.g. \"[Verse]\\n...\\n[Chorus]\\n...\". Required unless custom=true and instrumental=true.",
            "default": "Late-night city lo-fi piano with the sound of rain",
            "x-ui-component": "textarea",
            "maxLength": 3000
          },
          "custom": {
            "type": "boolean",
            "description": "false = inspiration mode (prompt is a description). true = custom mode (prompt is used as lyrics, and title / style / negative_tags / auto_lyrics / persona_id / style_weight / weirdness_constraint / audio_weight / duration take effect).",
            "default": false,
            "x-ui-component": "switch"
          },
          "instrumental": {
            "type": "boolean",
            "description": "Instrumental only, no vocals.",
            "default": false,
            "x-ui-component": "switch"
          },
          "vocal_gender": {
            "type": "string",
            "description": "Vocal gender. Takes effect in both modes.",
            "enum": [
              "Male",
              "Female"
            ]
          },
          "title": {
            "type": "string",
            "description": "Song title. Only takes effect when custom=true (ignored otherwise).",
            "maxLength": 200
          },
          "style": {
            "type": "string",
            "description": "Style tags, e.g. \"synthwave, female vocal, cinematic\". Only takes effect when custom=true (ignored otherwise).",
            "maxLength": 500
          },
          "negative_tags": {
            "type": "string",
            "description": "Styles to avoid. Only takes effect when custom=true.",
            "maxLength": 500
          },
          "auto_lyrics": {
            "type": "boolean",
            "description": "Let the model rewrite the supplied lyrics creatively. Only when custom=true.",
            "default": false,
            "x-ui-component": "switch"
          },
          "style_weight": {
            "type": "number",
            "description": "How strongly to follow style. Only when custom=true.",
            "minimum": 0,
            "maximum": 1
          },
          "weirdness_constraint": {
            "type": "number",
            "description": "Creativity / weirdness. Only when custom=true.",
            "minimum": 0,
            "maximum": 1
          },
          "audio_weight": {
            "type": "number",
            "description": "Audio reference weight. Only when custom=true.",
            "minimum": 0,
            "maximum": 1
          },
          "persona_id": {
            "type": "string",
            "description": "Persona (voice identity) id. Only when custom=true."
          },
          "variety": {
            "type": "string",
            "description": "How much the two takes should diverge from the most predictable rendition of the prompt. off = conservative, max = most adventurous. Works in both modes.",
            "enum": [
              "off",
              "normal",
              "high",
              "extra",
              "max"
            ],
            "x-ui-component": "select"
          },
          "duration": {
            "type": "integer",
            "description": "Target song length in seconds (10–360). Only takes effect when custom=true; the finished track may differ slightly from the target.",
            "minimum": 10,
            "maximum": 360,
            "x-ui-component": "slider"
          }
        },
        "required": [
          "model"
        ],
        "x-order-properties": [
          "model",
          "prompt",
          "custom",
          "instrumental",
          "variety",
          "vocal_gender",
          "title",
          "style",
          "duration",
          "negative_tags",
          "auto_lyrics",
          "style_weight",
          "weirdness_constraint",
          "audio_weight",
          "persona_id"
        ]
      },
      "PredictionResponse": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string"
          },
          "model": {
            "type": "string"
          },
          "status": {
            "type": "string",
            "description": "created|processing|completed|failed"
          },
          "outputs": {
            "type": "array",
            "description": "Generated song URLs (2 tracks per generation).",
            "items": {
              "type": "string",
              "x-format": "audio"
            }
          },
          "thumbnail": {
            "type": "string",
            "description": "Cover art generated alongside the song.",
            "x-format": "image"
          },
          "urls": {
            "type": "object"
          }
        }
      }
    }
  }
}

LLM-Friendly Prompt Template

# suno/chirp-v6-wild

> Suno V6 Wild via APIMart: the experimental V6 variant with bolder, less conventional arrangements. Same modes and pricing as chirp-v6. Async; returns 2 tracks per generation.


## Overview

- **Submit endpoint (POST)**: `https://api.atlascloud.ai/api/v1/model/generateAudio` — start an async generation; returns a `prediction_id`
- **Poll endpoint (GET)**: `https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}` — poll this until the prediction finishes
- **Model ID**: `suno/chirp-v6-wild`


## API Information

This model can be used via our HTTP API or more conveniently via our client libraries.
See the input and output schema below, as well as the usage examples.


### Input Schema

The API accepts the following input parameters:

- **`model`** (`string`, _required_):
  Model name.
  - Default: `"suno/chirp-v6-wild"`
  - Options: "suno/chirp-v6-wild"

- **`prompt`** (`string`, _optional_):
  With custom=false (default): an inspiration description of the song (style, mood, genre, theme). With custom=true: the actual lyrics, e.g. "[Verse]\n...\n[Chorus]\n...". Required unless custom=true and instrumental=true.
  - Default: `"Late-night city lo-fi piano with the sound of rain"`

- **`custom`** (`boolean`, _optional_):
  false = inspiration mode (prompt is a description). true = custom mode (prompt is used as lyrics, and title / style / negative_tags / auto_lyrics / persona_id / style_weight / weirdness_constraint / audio_weight / duration take effect).
  - Default: `false`

- **`instrumental`** (`boolean`, _optional_):
  Instrumental only, no vocals.
  - Default: `false`

- **`variety`** (`string`, _optional_):
  How much the two takes should diverge from the most predictable rendition of the prompt. off = conservative, max = most adventurous. Works in both modes.
  - Options: "off", "normal", "high", "extra", "max"

- **`vocal_gender`** (`string`, _optional_):
  Vocal gender. Takes effect in both modes.
  - Options: "Male", "Female"

- **`title`** (`string`, _optional_):
  Song title. Only takes effect when custom=true (ignored otherwise).

- **`style`** (`string`, _optional_):
  Style tags, e.g. "synthwave, female vocal, cinematic". Only takes effect when custom=true (ignored otherwise).

- **`duration`** (`integer`, _optional_):
  Target song length in seconds (10–360). Only takes effect when custom=true; the finished track may differ slightly from the target.
  - Min: 10
  - Max: 360

- **`negative_tags`** (`string`, _optional_):
  Styles to avoid. Only takes effect when custom=true.

- **`auto_lyrics`** (`boolean`, _optional_):
  Let the model rewrite the supplied lyrics creatively. Only when custom=true.
  - Default: `false`

- **`style_weight`** (`number`, _optional_):
  How strongly to follow style. Only when custom=true.
  - Min: 0
  - Max: 1

- **`weirdness_constraint`** (`number`, _optional_):
  Creativity / weirdness. Only when custom=true.
  - Min: 0
  - Max: 1

- **`audio_weight`** (`number`, _optional_):
  Audio reference weight. Only when custom=true.
  - Min: 0
  - Max: 1

- **`persona_id`** (`string`, _optional_):
  Persona (voice identity) id. Only when custom=true.



**Required Parameters Example**:

```json
{
  "model": "suno/chirp-v6-wild"
}
```


**Full Example**:

```json
{
  "model": "suno/chirp-v6-wild",
  "prompt": "Late-night city lo-fi piano with the sound of rain",
  "custom": false,
  "instrumental": false,
  "variety": "off",
  "vocal_gender": "Male",
  "title": "",
  "style": "",
  "duration": 10,
  "negative_tags": "",
  "auto_lyrics": false,
  "style_weight": 0,
  "weirdness_constraint": 0,
  "audio_weight": 0,
  "persona_id": ""
}
```


### Output Schema

The API returns the following output format:


- **`id`** (`string`, _optional_):

- **`model`** (`string`, _optional_):

- **`status`** (`string`, _optional_):
  created|processing|completed|failed

- **`outputs`** (`array[string]`, _optional_):
  Generated song URLs (2 tracks per generation).

- **`thumbnail`** (`string`, _optional_):
  Cover art generated alongside the song.

- **`urls`** (`object`, _optional_):



**Example Response**:

```json
{
  "id": "",
  "model": "",
  "status": "",
  "outputs": [
    ""
  ],
  "thumbnail": "",
  "urls": {}
}
```


## Usage Examples

### cURL

```bash
# Step 1: Start generation (async)
curl -X POST "https://api.atlascloud.ai/api/v1/model/generateAudio" \
  -H "Authorization: Bearer $ATLASCLOUD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "suno/chirp-v6-wild",
  "prompt": "Late-night city lo-fi piano with the sound of rain",
  "custom": false,
  "instrumental": false,
  "variety": "off",
  "vocal_gender": "Male",
  "title": "",
  "style": "",
  "duration": 10,
  "negative_tags": "",
  "auto_lyrics": false,
  "style_weight": 0,
  "weirdness_constraint": 0,
  "audio_weight": 0,
  "persona_id": ""
}'

# Response will contain: {"code": 200, "data": {"id": "prediction_id", "status": "processing"}}

# Step 2: Poll for result (replace {prediction_id} with the id returned above)
curl -X GET "https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}" \
  -H "Authorization: Bearer $ATLASCLOUD_API_KEY"

# Keep polling until status is "completed", "succeeded" or "failed"
# When completed, outputs will contain the generated content URL(s)
```

## Additional Resources

### Documentation

- [Model Playground](https://www.atlascloud.ai/models/suno/chirp-v6-wild)

Cyberpunk, dark synthwave, heavy distorted bass, aggressive drums, futuristic, neon atmosphere, fast tempo, driving energy, male vocals, industrial electro

Suno V6 Wild (suno/chirp-v6-wild)

Generate a full song — vocals or instrumental — from a text prompt, powered by Suno v6-wild: the experimental V6 variant — bolder, less conventional arrangements and genre blends. Each generation returns 2 tracks plus cover art.

Two modes

mode	set	`prompt` means
Inspiration	`custom: false` (default)	a description of the song: style, mood, genre, theme
Custom	`custom: true`	the actual lyrics, e.g. `[Verse] ... [Chorus] ...`

In custom mode you can also set title, style, negative_tags, auto_lyrics, persona_id, style_weight, weirdness_constraint, audio_weight and duration. Those fields are silently ignored in inspiration mode. vocal_gender, instrumental and variety work in both modes.

Parameters

field	required	notes
`prompt`	yes	description (inspiration mode) or lyrics (custom mode), ≤3000 chars. Optional only when `custom: true` and `instrumental: true`
`custom`	no	`false` = inspiration (default), `true` = your own lyrics
`instrumental`	no	instrumental only, no vocals
`variety`	no	`off` / `normal` / `high` / `extra` / `max` — how far the two takes stray from the obvious rendition. Both modes. New in V6
`vocal_gender`	no	`Male` / `Female` — both modes
`title`	no	song title — custom mode only
`style`	no	style tags, e.g. `synthwave, female vocal, cinematic` — custom mode only
`duration`	no	target length in seconds, 10–360 — custom mode only. New in V6
`negative_tags`	no	styles to avoid — custom mode only
`auto_lyrics`	no	let the model rewrite your lyrics — custom mode only
`style_weight`	no	0.00–1.00 — custom mode only
`weirdness_constraint`	no	0.00–1.00 — custom mode only
`audio_weight`	no	0.00–1.00 — custom mode only
`persona_id`	no	voice identity id — custom mode only

Output

outputs holds 2 audio URLs (two takes of the same request); the cover art is returned separately in thumbnail so it is never mixed into the audio list.

Notes

Async: submitting returns a request id; poll /api/v1/model/prediction/{request_id} until status is completed or failed. Generation typically takes 30–120s.
Billing: $0.132 per generation (both tracks included) — charged per request, not per track. Failed generations are not billed.
Upgrading from suno/chirp-v5 and the other chirp-v3/v4/v5 models: those engines were retired upstream. The request body is unchanged — swap model to suno/chirp-v6-wild and everything else keeps working.

Example

Inspiration mode:

{
  "model": "suno/chirp-v6-wild",
  "prompt": "Late-night city lo-fi piano with the sound of rain"
}

Custom mode with your own lyrics and a target length:

{
  "model": "suno/chirp-v6-wild",
  "custom": true,
  "prompt": "[Verse]\nMorning light through the kitchen window\n[Chorus]\nSlow down, slow down, the day can wait",
  "title": "Slow Morning",
  "style": "acoustic folk, warm female vocal, gentle guitar",
  "vocal_gender": "Female",
  "duration": 60,
  "variety": "high"
}

Explore Similar Models

NEW

text-to-audio

Suno chirp-v6

Suno V6 text-to-music via APIMart: inspiration mode (custom=false) turns a description into a song; custom mode (custom=true) uses your own lyrics, with variety and target duration controls. Async; returns 2 tracks per generation.

Suno chirp-v6-mini

Suno V6 Mini via APIMart: the lighter, faster V6 variant for drafts and short clips. Same modes and pricing as chirp-v6. Async; returns 2 tracks per generation.

MiniMax Music 3.0

MiniMax Music 3.0 is MiniMax's 11.1B-parameter open-weights music model that turns a musical description and optional lyrics into a complete, fully arranged and mixed song of up to five minutes - vocals, instrumentation and production included - in a single generation, with section-tag control over the arrangement and vocal or instrumental output.

MiniMax Lyrics Generation

MiniMax Lyrics Generation is a dedicated lyric-writing model that turns a one-line theme into a complete, professionally structured set of song lyrics - title, style tags, and sections marked with [Verse]/[Chorus] structure tags - and can also edit, continue, or restructure existing lyrics, with output directly usable as the lyrics input of MiniMax's music models.

Seed Audio 1.0

Doubao‑Audio‑Generate‑1.0 is Doubao Voice’s next‑generation audio‑generation engine. The industry‑first commercial tool creates film‑grade audio with just one prompt. It eliminates cumbersome audio‑engineering work. Creators generate publish‑ready radio dramas, podcasts and branded audio easily, shifting from a simple voice‑generator to an AI audio director. It serves audiobooks, serialized episodes and commercial audio for high‑quality narrative‑driven production.

xAI TTS v1

xAI TTS v1 is a high-fidelity text-to-speech model that converts text into natural, expressive speech with sub-second latency, supporting 20 languages and 80+ voices with fine-grained delivery control.

Seed ASR 2.0

BytePlus Seed Speech recording-file recognition (ASR 2.0): transcribe an audio file to text with punctuation, ITN, sentence segmentation, speaker diarization, and 51-language support.

MiniMax Music 2.6

MiniMax text-to-music (latest): generate a full vocal or instrumental song from a style prompt plus lyrics with [Verse]/[Chorus] structure tags. Synchronous single-call generation.

ElevenLabs v3 Text-to-Speech

ElevenLabs v3 Text-to-Speech model. High-quality speech generation from text prompts.

xAI STT v1

xAI STT v1 is a production-grade speech-to-text model that transcribes audio into accurate, formatted text. It supports 24+ languages with automatic language detection, word-level timestamps, speaker diarization, multichannel transcription, and inverse text normalization.

From

$0.002/min

One API for All Media AI.

Explore all models