# The Suno API in 2026: How to Generate Full Songs (and What It Costs)

> There is no official Suno API. How to call Suno V4.5 Plus programmatically, what each song costs, and the exact request and polling format.

- **Published**: 2026-07-27
- **Tag**: Engineering
- **Read time**: 7 min

---

Suno does not publish an official public API. If you want to generate full songs — vocals, lyrics, structure — from inside your own app, you need a provider that exposes Suno as an endpoint. Here that endpoint is `suno`, priced at **13.21 credits per generation, which is $0.1321** (1 credit = $0.01), and you are only charged when a song actually comes back.

That's the whole post in one paragraph. The rest is the detail you'll need to ship it.

# Why "there's no official API" matters

Most model APIs are a thin wrapper over a documented public endpoint. Suno isn't. That has three practical consequences for you as a builder:

1. **You can't get an official price list**, so per-generation cost is set by whoever fronts the model.
2. **Reliability is not a given.** Music generation is a long-running job, and upstream capacity fluctuates.
3. **You need an async contract.** You will not get a finished song back on an open HTTP connection — it takes far longer than a sane request timeout.

So the two things worth comparing between providers are: what you pay per finished song, and what happens when a generation fails.

# What a song costs

| Model | Model id | Price per generation |
|---|---|---|
| Suno | `suno` | **$0.1321** (13.21 credits) |

Two details that change your real cost more than the sticker price:

- **Failed, errored or empty generations are refunded automatically.** You pay for songs you actually receive — more on that in [Never pay for a failed generation](/blog/never-pay-for-failed-jobs).
- **Credits never expire.** A $5 top-up gets you 500 credits — roughly 37 songs — and it's still there next month. Larger packs add bonus credits (+5% at $500, +10% at $1,250).

Current pricing for every model is always on the [pricing page](/pricing).

# How to call it

Suno is a two-step, create-then-poll flow. Create the task:

```http
POST https://you.bot/api/v1/generate
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

{
  "modelId": "suno",
  "input": {
    "modelVersion": "V4_5PLUS",
    "customMode": false,
    "prompt": "An upbeat synthwave track with driving bass, bright arpeggios and a nostalgic 80s feel.",
    "title": "Neon Drive",
    "style": "synthwave, energetic, retro",
    "instrumental": false
  }
}
```

Response:

```json
{ "taskId": "281e5b0…f39b9", "creditsCharged": 13.21 }
```

Then poll until it's done:

```http
GET https://you.bot/api/v1/task/{taskId}?model=suno
```

When `state` is `success`, your audio is in `resultUrls`:

```json
{ "state": "success", "resultUrls": ["https://…"] }
```

Prefer not to poll? Pass a `callbackUrl` in the create request and you'll get a signed webhook when the song is ready.

## Python, end to end

```python
import os, time, requests

API = "https://you.bot/api/v1"
H = {"Authorization": f"Bearer {os.environ['YOUBOT_API_KEY']}"}

def make_song(prompt, title, style):
    r = requests.post(f"{API}/generate", headers=H, json={
        "modelId": "suno",
        "input": {"modelVersion": "V4_5PLUS", "prompt": prompt,
                  "title": title, "style": style, "instrumental": False},
    }).json()
    task_id = r["taskId"]

    while True:
        t = requests.get(f"{API}/task/{task_id}", headers=H,
                         params={"model": "suno"}).json()
        if t["state"] == "success":
            return t["resultUrls"]
        if t["state"] in ("failed", "error"):
            raise RuntimeError(t)          # credits are refunded automatically
        time.sleep(5)

print(make_song("lofi beat, rainy night, mellow keys", "Rainy Lofi", "lofi, chill"))
```

# The input parameters that actually matter

| Parameter | Required | Notes |
|---|---|---|
| `prompt` | Yes | Describe the music, not just the topic. Instrumentation and mood beat adjectives. |
| `title` | Yes | Shows up as the track title. |
| `style` | Yes | Comma-separated genre and mood tags, e.g. `synthwave, energetic, retro`. |
| `modelVersion` | Yes | `V5` · `V4_5PLUS` (default) · `V4_5` · `V4` |
| `customMode` | No | Default `false`. Turn on for tighter control over structure and lyrics. |
| `instrumental` | No | `true` for no vocals. |
| `vocalGender` | No | `m` or `f` |
| `styleWeight`, `audioWeight`, `weirdnessConstraint` | No | 0–1 dials. Nudge, don't slam. |
| `negativeTags` | No | Styles to steer away from. |
| `callbackUrl` | No | HTTPS URL for a signed completion webhook. |

Full parameter reference, plus an in-browser playground you can test with your own prompt before writing any code, is on the [Suno model page](/models/suno). There's also a machine-readable version at `/models/suno/md` if you'd rather point an LLM at the docs.

# Errors you should handle

| Code | Meaning |
|---|---|
| 400 / 422 | Bad or missing parameters — check `prompt`, `title`, `style` |
| 401 | API key problem |
| 402 | Not enough credits |
| 429 | Rate limited — back off and retry |
| 500 | Upstream or internal error — the credits come back |

# Three things I'd do before shipping

**Treat generation as a queue, not a request.** Songs take minutes. Kick off the task, store the `taskId`, and let a webhook or worker finish the job. Never block a user-facing request on it.

**Log `creditsCharged` per task.** It's in the create response. Sum it per user or per feature and you have real unit economics without building a metering system.

**Keep a fallback route.** If you already call another provider, keep that key. Route primary traffic to the cheaper endpoint, fall back on failure — you capture the savings and don't bet uptime on one vendor.

# FAQ

**Is there an official Suno API?**
No. Suno doesn't publish a public API, so programmatic access goes through a provider that exposes it as an endpoint — here that's the model id `suno`.

**How much does one song cost?**
$0.1321 per generation (13.21 credits) as of 15 August 2026. Failed or empty generations are refunded automatically, so you only pay for songs you receive.

**Can I generate instrumental-only tracks?**
Yes — set `"instrumental": true` in the `input` object.

**How long does a generation take?**
Minutes, not seconds. Use the `callbackUrl` webhook or poll `GET /api/v1/task/{taskId}` instead of holding a request open.

**Can I commercially use the output?**
That depends on Suno's own terms for the model tier you use — check them before you ship, because the API provider doesn't change the underlying licence.

**What else can I call with the same key?**
The same endpoint fronts 80+ models across text, image, video and music — you switch by changing `modelId`. See the [music models](/market?m=music), the [full catalog](/market), or [the cheapest AI APIs in 2026](/blog/cheapest-ai-api).