Suno API: Official Status, Pricing and Code (2026)

The Suno API is how developers get Suno’s music models to write songs, sounds, lyrics and mashups from code instead of clicking through the Suno app. The catch is that “Suno API” means different things depending on who you ask, and picking the wrong one can cost you a banned account or a rewrite later. This guide sorts out the options, explains what each Suno model does and costs, and walks through working code you can run today.

What is the Suno API?

Suno (the company is Suno Inc.) makes one of the best-known AI music generators. Its app turns a short text prompt into a full song with vocals and instruments, and it also writes lyrics, extends tracks and remixes existing audio. People search for “suno ai music generator” or “suno ai song maker” when they want to use the app, and for “suno api” when they want their own software to do the same thing automatically.

An API (application programming interface) is a defined way for one program to ask another for work and get a result back. For music, that usually looks like this:

1. Your code sends a request with a prompt and some settings (style, title, lyrics, model version).
2. The service starts a job, which is an asynchronous task: it runs in the background because generating audio takes much longer than a normal web request.
3. Your code checks the job status (polling) until it finishes, then downloads the audio file from a URL.

Typical things developers build on a Suno API include background music for videos, personalised songs for greeting or gift apps, jingles for podcasts, game soundtracks that change per level, and tools that let musicians sketch ideas quickly. All of them need the same few capabilities: generate a track, control the style, supply or generate lyrics, and get the file back reliably.

Is there an official Suno API?

This is the most common question, and the honest answer needs some care. Suno has mainly focused on its consumer app, which has a free tier and paid plans. It has not run a broadly open, self-serve developer portal where anyone can sign up, get a key and read full public documentation, the way you can with large chat model providers. If Suno opens or expands official developer access, its own website is the place to confirm the current terms.

That gap is why the search results for “suno api” are crowded with third parties. Several sites use “Suno API” in their name or domain, and some read as if they were Suno itself. Before you send money or audio to any of them, check who actually runs the service, what their terms say about commercial use, and how long they have been operating.

What happened to Suno AI?

Suno grew quickly and then became the subject of lawsuits from major record labels over how its models were trained. In November 2025, Warner Music Group formed a partnership with Suno and, as part of it, sold Suno the concert-discovery service Songkick. Suno still operates its app and keeps releasing new model versions. For developers, the practical takeaway is that licensing terms around AI music are still moving, so read the current terms of whichever service you use before you ship songs in a commercial product.

Unofficial wrappers vs hosted Suno API providers

There are three realistic ways to call Suno models from code. They differ a lot in risk and effort.

1. Open-source wrappers

The best-known example is the gcui-art/suno-api project on GitHub. Its own description says it is an unofficial project intended for learning and research. Wrappers like this work by reusing your logged-in Suno account session (the cookie your browser stores after you sign in) and automating the same requests the web app makes. That means:

• You are limited by your own account’s plan and daily limits.
• Any change to Suno’s web app can break it without warning.
• Automating a consumer account may conflict with the app’s terms of service.
• You host it yourself, and some setups also need a captcha-solving service.

Wrappers are fine for experiments on your own machine. They are a poor foundation for a product with paying users.

2. Hosted Suno API providers

These companies run the infrastructure, give you an API key, and charge per track or per request. You get documentation, asynchronous jobs and usually webhooks or polling. The main questions are reliability, which features they expose (lyrics, mashups, personas, cover art), and whether you also need other model types elsewhere.

3. Aggregators with one key for everything

An aggregator is a hosted provider that also offers image, video, audio and chat models under the same key and bill. Unicorn API works this way: the Suno models sit next to image models for cover art and video models for visualisers, all priced in credits. If your app only ever needs music, a single-purpose provider can work; if it also needs artwork, video or a chat model to write prompts, one key saves you from managing several accounts and invoices.

Route	Setup effort	Reliability	Billing	Good for
Open-source wrapper	High: self-host, manage session cookies	Breaks when the web app changes	Your Suno subscription	Learning, personal experiments
Hosted music provider	Low: get a key, call REST	Depends on the provider	Per track, music only	Music-only products
Aggregator (Unicorn API)	Low: one key, one job endpoint	Managed service	Credits across all model types	Apps that mix music with images, video or chat

The Suno models on Unicorn API

Unicorn API exposes Suno’s music features as separate models. Each one is called through the same job endpoint, so once you can run one, you can run them all. Prices below are the listed per-output rates; every output rounds up to whole credits.

Model	What you use it for	Key inputs	Listed price
Ai Music API Sounds	Generate a track or sound from a text prompt	model, prompt, sound_key, sound_tempo, sound_loop, grab_lyrics	2.5 credits per track
Ai Music API Mashup	Combine uploaded audio into a new track with your style and lyrics	model, prompt, style, title, lyrics, upload_url_list, persona_id, weights	12 credits per track
Ai Music API Generate Lyrics	Write lyrics from a prompt	prompt	0.4 credits
Ai Music API Boost Music Style	Turn a short style idea into a fuller style description	content	0.4 credits
Ai Music API Generate Music Cover	Create cover art for an earlier music task	task_id	0 credits
Ai Music API Generate Persona	Save a vocal identity from a generated song for reuse	name, task_id, audio_id, description, style, vocal_start, vocal_end	0 credits

Sounds: the quickest way to a track

Sounds takes a prompt plus an inner model field for the Suno version, for example "V5". Optional fields let you set the musical key (sound_key), tempo (sound_tempo) and whether the result should loop (sound_loop), which is handy for game and app background audio.

Mashup: the most controllable option

Mashup is the heavyweight of this Suno API family. You pass public URLs to source audio in upload_url_list, then steer the result with style, title, lyrics, vocal_gender, duration and tuning knobs such as style_weight, audio_weight and weirdness_constraint. It can also take a persona_id so a recurring vocal identity carries across tracks.

Lyrics, style boost, cover art and persona

These are helpers. Generate Lyrics writes words you can feed into Mashup. Boost Music Style expands a terse style like “lo-fi house” into something richer. Generate Music Cover and Generate Persona both work from a previous music task through task_id, and both are listed at 0 credits. Each model page shows which identifier to pass.

How to call the Suno API: a working example

Here is the full flow, from key to downloaded audio file.

Step 1: Create a key

Create a key on the API keys page and store it in an environment variable so it never ends up in your code or Git history:

export UNICORN_API_KEY="your-key-here"

Step 2: Submit a job with curl

curl -X POST https://api.unicornapi.net/v1/jobs \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"ai-music-api-sounds","input":{"model":"V5","prompt":"An upbeat acoustic guitar track with light percussion"}}'

Note the two model fields. The outer one picks the Unicorn API model (ai-music-api-sounds); the inner one inside input picks the Suno version (V5). The response contains a job ID.

Step 3: Poll until it succeeds

curl https://api.unicornapi.net/v1/jobs/JOB_ID \
  -H "Authorization: Bearer $UNICORN_API_KEY"

Repeat every few seconds until status is "succeeded", then read outputs[0].url.

A complete Python script

This script submits a Sounds job, polls it, and saves the audio locally. It needs the requests package.

import os
import time
from urllib.parse import urlparse

import requests

API = "https://api.unicornapi.net"
HEADERS = {
    "Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}",
    "Content-Type": "application/json",
}


def run_job(model, job_input, poll_seconds=5):
    r = requests.post(
        f"{API}/v1/jobs",
        headers=HEADERS,
        json={"model": model, "input": job_input},
        timeout=30,
    )
    r.raise_for_status()
    job_id = r.json()["id"]

    while True:
        r = requests.get(f"{API}/v1/jobs/{job_id}", headers=HEADERS, timeout=30)
        r.raise_for_status()
        job = r.json()
        if job["status"] == "succeeded":
            return job
        # See /docs for the full list of job statuses.
        if job["status"] in ("failed", "canceled"):
            raise RuntimeError(f"Job {job_id} ended with status {job['status']}")
        time.sleep(poll_seconds)


job = run_job("ai-music-api-sounds", {
    "model": "V5",
    "prompt": "An upbeat acoustic guitar track with light percussion",
})

url = job["outputs"][0]["url"]
filename = os.path.basename(urlparse(url).path) or "track.mp3"
audio = requests.get(url, timeout=120)
audio.raise_for_status()
with open(filename, "wb") as f:
    f.write(audio.content)
print("Saved", filename)

A mashup in JavaScript

The same pattern works for any model. This Node 18+ example (save it as an .mjs file) runs a mashup from two source tracks you host publicly:

const API = "https://api.unicornapi.net";
const headers = {
  Authorization: `Bearer ${process.env.UNICORN_API_KEY}`,
  "Content-Type": "application/json",
};

const res = await fetch(`${API}/v1/jobs`, {
  method: "POST",
  headers,
  body: JSON.stringify({
    model: "ai-music-api-mashup",
    input: {
      model: "V4",
      title: "Coastline Remix",
      style: "lo-fi house, warm bass, soft vocals",
      prompt: "Blend both songs into a relaxed late-night groove",
      upload_url_list: [
        "https://example.com/song-a.mp3",
        "https://example.com/song-b.mp3",
      ],
    },
  }),
});
if (!res.ok) throw new Error(`Submit failed: ${res.status}`);
let job = await res.json();

while (job.status !== "succeeded") {
  if (job.status === "failed") throw new Error(`Job ${job.id} failed`);
  await new Promise((r) => setTimeout(r, 5000));
  const poll = await fetch(`${API}/v1/jobs/${job.id}`, { headers });
  if (!poll.ok) throw new Error(`Poll failed: ${poll.status}`);
  job = await poll.json();
}

console.log("Track ready:", job.outputs[0].url);

Full request and response details are in the API documentation. If you work in an AI coding tool, you can also call these models from Cursor or Claude Code through MCP; see using the API from agents.

Suno API pricing: what a song actually costs

Suno API pricing varies widely between providers, so it helps to work out the real cost per finished song rather than comparing headline numbers. On Unicorn API everything is billed in credits. Monthly plans give credits at $0.01 each (Starter $25, Creator $50, Studio $100, Pro $200 per month). Top-up credits cost $0.015 each and never expire. Details are on the pricing page.

Two rules matter for budgeting. First, each output rounds up to whole credits, so a 0.4-credit lyrics call bills as 1 credit and a 2.5-credit Sounds track as 3. Second, you can get the exact price of any request before running it with POST /v1/models/price, which is the safest way to show users a cost before they click generate.

Worked example: a full mashup pipeline

Say your app takes a user’s two songs and a mood, and returns a new track with lyrics and cover art:

Step	Model	Credits billed	On a plan	On top-ups
Expand the mood into a style	Boost Music Style	1	$0.01	$0.015
Write lyrics	Generate Lyrics	1	$0.01	$0.015
Make the track	Mashup	12	$0.12	$0.18
Cover art	Generate Music Cover	0	$0.00	$0.00
Total		14	$0.14	$0.21

The Starter plan’s 2,500 credits cover about 178 of these pipelines a month. If you only need short loops from Sounds at 3 credits each, the same plan covers about 833 tracks.

Adding custom artwork or a music video

The free cover generator is enough for many apps. If you want artwork in your own brand style, Nano Banana 2 Lite makes an image for 4 credits and accepts up to 10 reference images, and GPT Image 1.5 is the better pick when the cover needs legible text such as a song title (4 credits at medium quality). To turn that cover into a short visualiser, Grok Imagine Video 1.5 animates a start frame: a 10-second clip at 720p is 45 credits. For longer clips up to 30 seconds, Grok Imagine Video 1.0 runs at the same per-second rate. Our Grok Imagine prompt guide covers how to write motion prompts that match the beat of a track.

Common mistakes when using a Suno API

Most problems developers hit with a Suno API come from a handful of avoidable choices.

• Assuming a site named “Suno API” is Suno. Many are independent resellers. Check the operator, terms and track record before you commit.
• Shipping a cookie-based wrapper to production. It ties your whole product to one consumer account and breaks when the web app changes. Use a hosted endpoint with a real key.
• Waiting synchronously. Music generation is a background job. Do not hold an HTTP request open for your user; return a job ID, poll every few seconds (not in a tight loop), and update the UI when the job succeeds.
• Mixing up the two model fields. The outer model is the Unicorn API model ID; the inner input.model is the Suno version, such as V5 or V4. Swapping them gives a validation error.
• Passing private audio URLs to Mashup. The service has to download the files, so upload_url_list needs URLs it can reach. Signed URLs with a short expiry are a good compromise.
• Ignoring rounding. Each output rounds up to whole credits. If you call Generate Lyrics ten times per song to pick the best version, that is 10 credits, not 4.
• Not keeping your files. Copy finished audio to your own storage rather than treating the job URL as permanent hosting.
• Skipping the licensing check. AI music rights are still being worked out between labels and AI companies. Read the current terms for commercial use, and tell your own users what they can do with generated songs.
• Vague prompts. “A happy song” leaves too much to chance. Name the genre, instruments, tempo feel and mood, and use Boost Music Style when you only have a one-word idea.

Which Suno API route should you choose?

If you are curious how the Suno API calls work and only need a handful of songs for yourself, an open-source wrapper running against your own Suno subscription is a reasonable weekend project. Treat it as a learning tool.

If you are building something other people will use, pick a hosted API with a real key, published pricing and asynchronous jobs. Then ask whether your product needs anything besides music. Most music apps end up needing cover art, a short video for social sharing, or a chat model to turn a user’s description into a good prompt. That is where one key and one bill pays off: the Suno models, the image models and the video models all use the same job endpoint and the same credits, so adding a feature is a new model ID rather than a new vendor.

To get started, browse the full model catalog, create a key, and run the Python script above. Your first Sounds track costs a few credits, and you can check the exact price before you send the request.