Suno Music AI: Pricing and API Code (2026)

Suno music AI is the name most people use for Suno’s text-to-song models, the ones that take a sentence like “slow soul ballad with Rhodes piano and a smoky female vocal” and return a complete two-minute recording with sung words, backing instruments and a mix. That last part is what makes it different from older music tools: you are not getting a MIDI sketch or a loop pack, you are getting audio that sounds like a finished track.

This article covers what the models actually do, where the web app stops being the right tool, which Suno models you can call programmatically, what each call costs, and the specific mistakes that produce forgettable results. There is working code you can run in a few minutes.

What is Suno music AI?

Suno is a generative audio company whose models produce complete songs, vocals included, from short text descriptions. The system has gone through several generations, usually referred to as V3, V4 and V5, and Wikipedia’s entry on Suno has the background on the company and its model history. In the web app at suno.com/create you pick Simple mode, type a description, and a track comes back within a minute or so. There is also Suno Studio, a browser-based generative audio workstation that mixes ordinary DAW features, a timeline and stems, with generation.

“Generative” here means the model has learned the statistical shape of millions of recordings and samples new audio that fits the pattern your prompt describes. It is not stitching clips together from a library. That is why the output can be genuinely novel and also why it sometimes invents a nonsense word in a chorus or a guitar that bends in a way no guitar would.

Two things about Suno music AI surprise people the first time. First, the vocals are synthesised along with the music, not dubbed over it, so the singer’s phrasing responds to the groove. Second, quality varies run to run on the same prompt. Working with these models is less like rendering a file and more like auditioning session musicians: you generate several takes and keep the good one.

How Suno music AI turns text into a song

Every generation, in the app or through an API, is some combination of three inputs.

• Prompt or description. Plain language about mood, instruments, tempo feel and production. This does the heaviest lifting.
• Style. A compact set of genre and production tags, closer to a label on a crate of records than a sentence. “Lo-fi boom bap, dusty tape drums, muted trumpet.”
• Lyrics. Either written by you with structure tags like [Verse] and [Chorus], or left to the model to invent.

Beyond those, the Suno music AI API surface exposes dials that the simple web flow hides: weights that decide how strictly the output follows your style versus your uploaded audio, a weirdness constraint that trades coherence for surprise, a vocal gender hint, and a tempo and key for instrumental beds. Those dials are the practical reason to go to the API even if you only ever make a handful of songs: you can hold everything constant and change one variable, which is impossible when a text box is your only control.

There is also the persona concept. A persona captures the voice and stylistic fingerprint of a track you already made, so later generations can sound like the same artist. If you are producing an album rather than a one-off, personas are what stop track four sounding like a different band than track one.

Suno music AI in the web app vs the API

The honest answer to “which should I use” is that they solve different problems. The app is a creative tool with a human in the loop on every take. The API is infrastructure for when music is one ingredient in something larger: a game that scores itself, a video pipeline that needs a bed under every clip, a product that lets users generate their own themes.

	Suno web app and Studio	Suno music AI via API
Best for	Writing and hand-finishing individual songs	Generating music inside an app or batch job
Control	Timeline, stems, manual editing	Exact parameters per request, reproducible
Volume	One at a time, by hand	Hundreds of variations in a loop
Billing	Subscription allowance	Pay per generation in credits
Integration	Download and upload manually	Audio URL straight into your own storage

If you are hand-crafting a single song for release, open Studio. If you find yourself downloading files and renaming them in batches of twenty, you want the API.

Which Suno music AI models you can call on Unicorn API

Unicorn API gives you one key and one bill across image, video, audio and chat models, with Suno’s music endpoints among them. Prices below are in credits; one credit is $0.01 on a monthly plan. Pricing is per output and rounded up to whole credits, which is why the base rate and the per-track rate differ slightly on a few models.

Model	What you pass	Price
Ai Music API Sounds	model, prompt, sound_key, sound_tempo, sound_loop, grab_lyrics	3 credits per track
Ai Music API Mashup	model, style, title, lyrics, prompt, upload_url_list, weights, variety, duration	12 credits per track
Ai Music API Boost Music Style	content	1 credit per call
Ai Music API Generate Persona	name, style, description, task_id, audio_id, vocal_start, vocal_end	1 credit per track
Ai Music API Get TimeStamped Lyrics	task_id, audio_id	1 credit per track
Ai Music API Generate Music Cover	task_id	1 credit per image

A short tour of what each one is for. Sounds is the main generator: prompt in, track out, with optional key and tempo and a loop flag for beds that need to repeat cleanly. Mashup is the heavier endpoint, taking a list of uploaded audio URLs alongside your style, title and lyrics, with weights that decide how much the result leans on your uploads versus your style description. Boost Music Style takes a scrap of text and expands it into a fuller style description, which is useful when your users type three words and you want a usable prompt. Generate Persona turns an existing generation into a reusable voice. TimeStamped Lyrics returns the words with timings, the input you need for karaoke displays, subtitles or syncing visuals to a line. Generate Music Cover produces artwork for a finished track.

The last two are the ones people miss, and they are the reason API access to Suno music AI is more than a convenience. Timings and personas are not things you can reconstruct afterwards by hand without a lot of tedious work.

Generate a track with the Suno music AI API

Media models on Unicorn API use an asynchronous job pattern, which is standard for anything that takes more than a moment to produce: you create a job, then poll it until it finishes. Create an API key at /keys first and put it in an environment variable rather than in your source. Keys in committed code are the single most common way API credentials leak, and the general background on web API security is worth ten minutes if you are shipping this to users.

curl -s -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"
    }
  }'

That returns a job object with an id and a status. Poll it:

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

When status becomes "succeeded", the audio URL is at outputs[0].url. In Python, with a small helper that handles the polling for every model you call:

import os, time, requests

BASE = "https://api.unicornapi.net"
HEADERS = {"Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}"}

def run(model, payload, poll=3.0, timeout=600):
    job = requests.post(
        f"{BASE}/v1/jobs",
        headers=HEADERS,
        json={"model": model, "input": payload},
        timeout=60,
    ).json()

    deadline = time.time() + timeout
    while job["status"] not in ("succeeded", "failed", "canceled"):
        if time.time() > deadline:
            raise TimeoutError(f"job {job['id']} still {job['status']}")
        time.sleep(poll)
        job = requests.get(
            f"{BASE}/v1/jobs/{job['id']}", headers=HEADERS, timeout=30
        ).json()

    if job["status"] != "succeeded":
        raise RuntimeError(job.get("error") or job["status"])
    return job

track = run("ai-music-api-sounds", {
    "model": "V5",
    "prompt": (
        "Late-night lo-fi hip hop, dusty tape drums at 82 BPM, "
        "muted trumpet, warm vinyl crackle, no vocals"
    ),
    "sound_tempo": 82,
    "sound_loop": True,
})

print(track["outputs"][0]["url"])
print(track)  # keep this: the ids you need next are in here

Three credits for that call. The sound_loop flag matters if the track is going under a game level or a long video, where an audible seam at the loop point is the difference between background music and an annoyance. Full request and response details live in the API docs, and you can click through the same models in the browser playground before writing any code.

Lyrics timings, cover art and a video from the same track

Once a generation exists, the follow-up models reference it by id. Suno returns a task id for the generation and an audio id for each track inside it; both come back with the job you just printed. Pass them to the lyrics and cover endpoints:

# Copy these from the job payload printed above.
TASK_ID = "..."
AUDIO_ID = "..."

lyrics = run("ai-music-api-timestamped-lyrics", {
    "task_id": TASK_ID,
    "audio_id": AUDIO_ID,
})

cover = run("ai-music-api-cover-generate", {"task_id": TASK_ID})

print(lyrics["outputs"][0]["url"], cover["outputs"][0]["url"])

Two more credits, and you have word-level timings plus artwork. If you want art that matches a visual brand rather than the model’s own interpretation, generate it separately: Nano Banana 2 Lite is 4 credits per image and accepts up to 10 reference images, and GPT Image 1.5 is 3 credits at low quality and the better pick when the cover needs legible text, like an album title.

art = run("nano-banana-2-lite", {
    "prompt": (
        "Square album cover, empty night bus interior lit by orange "
        "streetlights, grainy film photograph, no text"
    ),
    "aspect_ratio": "1:1",
})

clip = run("grok-imagine-video-1-5-preview", {
    "image": art["outputs"][0]["url"],
    "prompt": "Slow push in, streetlights drifting past the windows, subtle film grain",
    "duration": 10,
    "resolution": "720p",
})

print(clip["outputs"][0]["url"])

That visualiser clip is 40 credits: Grok Imagine Video 1.5 charges 4 credits per second at 720p, 3 at 480p and 7 at 1080p, and animates a start frame for 1 to 15 seconds. For longer pieces, Grok Imagine Video 1.0 runs 6 to 30 seconds at the same per-second rate. Total for a track, its lyrics timings, a custom cover and a ten-second loop: 49 credits, or 49 cents on a monthly plan. You still have to mux the audio and video together locally with ffmpeg, which nobody charges for.

How much does Suno music AI cost per track?

Credits on monthly plans are $0.01 each: Starter is $25 for 2,500 credits, Creator $50 for 5,000, Studio $100 for 10,000 and Pro $200 for 20,000. Top-up credits are $0.015 each and never expire, which is the right choice for bursty work. Current details are on the pricing page.

In practice:

• One track from Sounds: 3 credits, about $0.03.
• Generating five takes and keeping one: 15 credits, about $0.15 for the keeper.
• A Mashup generation using your own uploaded audio: 12 credits, about $0.12.
• A hundred looping background beds for a game: 300 credits, about $3.
• Track plus lyrics timings plus cover: 5 credits, about $0.05.

Because Mashup is four times the price of Sounds, do your prompt experiments on Sounds and only move to Mashup once the style description is settled. And when a request has variable pricing, check before you run it rather than guessing:

curl -s -X POST https://api.unicornapi.net/v1/models/price \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video-1-5-preview",
    "input": {"duration": 10, "resolution": "720p"}
  }'

That endpoint returns the exact cost of a specific request body, so you can show a user what they are about to spend, or refuse a job that would blow a budget. If you are weighing Suno music AI against other generators on cost and output style, the model comparison runs the same prompts through each, and the full catalog lists everything else on the same key.

Mistakes people make with Suno music AI

Prompting like a search query. “Happy pop song” gets you the average of every happy pop song, which is to say nothing memorable. Name instruments, tempo feel, production era and vocal character. “Sparse 90s trip hop, detuned Wurlitzer, brushed drums at 70 BPM, breathy low female vocal” gives the model something to aim at.

Judging the model on one take. The variance between runs on an identical prompt is large. Generate five, keep one. At 3 credits a take that costs 15 cents, and it is the single biggest quality lever you have.

Ignoring structure in lyrics. If you supply words without [Verse], [Chorus] and [Bridge] tags, the model guesses where the sections go, and it often guesses wrong, running a verse into a chorus with no lift.

Treating output as automatically yours to sell. Commercial rights depend on the terms of the plan you generated under, and the training-data question is being actively litigated by major labels, as the overview of artificial intelligence in music documents. Anything that deliberately imitates a specific named artist is a risk no plan protects you from.

Publishing everything you generate. The volume of low-effort generated output has its own name now, AI slop, and listeners have become good at spotting it. Generating a hundred tracks is cheap; the work is still the selection, the sequencing and knowing when a take is not good enough.

Polling too aggressively. A one-second poll interval on a job that takes a minute is fifty-nine wasted requests. Three to five seconds is fine, and a timeout plus a retry on failed jobs will save you more grief than any prompt tweak.

Where to start

If you have never used Suno music AI, spend ten minutes in the web app to calibrate what the models can and cannot do. If you already know and the manual loop is the bottleneck, the code above is the whole integration: create a job, poll it, read the URL, then add lyrics timings and cover art for two more credits. Grab a key at /keys, and if you work in an editor like Cursor or Claude Code, the MCP setup lets you generate and audition tracks without leaving it.