Scoring an Indie Game with the Suno V6 API

Tidewatch is a fictional adventure game. Every piece of music in this article was generated through the Suno V6 API.

Game music is one of the hardest jobs you can give an AI music model. A pop song only has to sound good from start to finish. A game score has to work in pieces: an exploration theme that can loop for ten minutes, a tension layer that can take over when an enemy appears, a combat layer at the same tempo and key so the switch is not jarring, short stingers for victory and defeat, and a boss track long enough for a difficult fight. Small indie teams usually cannot afford a composer for all of that, so the question is a practical one: can an API produce game-ready material, and how much manual work is still needed?

To answer it, we invented a small hand-drawn adventure game called Tidewatch, set in a drowned lighthouse town, and tried to score it entirely with the Suno V6 API. We made 15 requests. For each one we recorded the generation time and the cost reported by the API, and we measured the results instead of just listening to them: tempo with an onset analysis, key with a chroma estimate, loop joins with a level check, stems with a null test, and vocals with a speech-recognition check. This article goes through every step, including the measurements that did not support our first impressions.

You can play the most important results directly in the article, and a three-minute walkthrough video at the end puts them together with the charts.

The setup

Suno V6 works asynchronously. You send a POST request, receive a task ID, and poll the task until it reports completed or failed. A normal generation returns two different takes. Editing operations, such as crop, extend, concat, fade-out, cover and stem separation, refer to an earlier result by its task ID and an audio index, so a whole soundtrack can be built as a chain of tasks without downloading and re-uploading audio in between.

import time, requests

BASE = "https://api.apimart.ai/v1/music"

H = {"Authorization": "Bearer YOUR_KEY"}

def task(action, body):

url = f"{BASE}/generations/{action}" if action else f"{BASE}/generations"

tid = requests.post(url, headers=H, json=body).json()["data"][0]["task_id"]

while True:

d = requests.get(f"{BASE}/tasks/{tid}", headers=H).json()["data"]

if d["status"] in ("completed", "failed"):

return d # d["cost"], d["result"]["music"]

time.sleep(6)

explore = task("", {"custom": True, "instrumental": True, "version": "v6",

"title": "Tidewatch - Explore", "style": STYLE, "duration": 90})

loop = task("crop", {"task_id": explore["id"], "audio_index": 1,

"start_s": 24.0, "end_s": 43.2})

Every request in this test finished in 15 to 98 seconds. Regular generations took 36 to 43 seconds for two 90- to 120-second tracks, the sound-effect requests took 16 to 29 seconds, and full stem separation took 98 seconds.

Test 1: three intensity layers in the same key and tempo

Adaptive game music usually switches between intensity levels. The switch only sounds natural if all levels share the same tempo and key, so the next layer can start on the next bar. We used one shared description and changed only the layer-specific part:

Shared: instrumental video game soundtrack for a hand-drawn adventure game set in a drowned lighthouse town, D minor, 100 bpm,

Explore: calm exploration layer, plucked harp, soft marimba, warm pads, light shaker, gentle and curious

Tension: tension layer, low string ostinato, ticking clock percussion, muted brass swells, uneasy

Combat: combat layer, driving taiko drums, aggressive staccato strings, brass stabs, energetic

(custom true, instrumental true, version v6, duration 90)

The three layers, with length, generation time and our tempo and key estimates.

Each request cost $0.05 and returned two takes of 88.7 to 89.8 seconds, very close to the requested 90. The descriptions Suno attached to the results repeated the brief back to us, for example "calm 100 BPM exploration in D minor", which is useful when you are cataloguing hundreds of cues.

Explore layer, take 1.

Tension layer, take 1.

Combat layer, take 2.

Test 2: did it keep the tempo and the key?

Listening is not a reliable way to check tempo and key across many cues, so we measured them. For tempo we used an onset-strength autocorrelation, a standard simple beat-tracking method. For key we built a chroma profile, which adds up how much energy falls on each of the twelve pitch classes, and compared it with the Krumhansl key profiles. Both methods are deliberately simple. They are good at finding the tonal centre and the main pulse, and weaker at telling major from minor and at handling busy rhythms.

The results were mostly encouraging. Both explore and both tension takes measured 99.4 beats per minute, within the resolution of our method of the requested 100. Every one of the eight layer and boss takes had D as its tonal centre. The boss track, which we asked for at 140 beats per minute, measured 143.6 on one take and 71.8, exactly half of that, on the other, which is the classic half-tempo ambiguity of simple beat trackers rather than a real difference.

The combat layer is where we have to be honest. Our estimator read 143.6 and 136.0 beats per minute for the two combat takes, not 100. A value near 103 appeared as the second-strongest candidate on both takes, and taiko patterns with dense subdivisions are exactly the case where this method struggles. We cannot confirm from our measurement that the combat layer is at 100. In a real project we would check it in a digital audio workstation against a click before wiring it into the game. The major-or-minor result was similarly unreliable: the estimate flipped between D major and D minor for takes that are clearly in the same key, so we only trust the tonic.

Test 3: making seamless loops

Exploration music in a game often loops for a long time, so the loop point must be invisible. We tried two approaches. First, Suno's sound-effects endpoint, which has a loop mode with tempo and key:

ambient harbor loop: gentle waves, distant foghorn, soft wind chimes (type loop, bpm 100, key Dm)

hand percussion groove loop with shakers and frame drum (type loop, bpm 100, key Dm)

Second, the crop operation on the explore layer. At 100 beats per minute, eight bars of 4/4 last exactly 19.2 seconds, so we cropped from 24.0 to 43.2 seconds.

Each loop repeated three times. The number on the right is the level step at the join.

We repeated each loop three times and measured the level of the first and last 100 milliseconds. The loop lengths were promising: the loop requests returned 19.1 to 19.3 seconds (eight bars at 100 beats per minute) for three takes and 9.73 seconds (four bars) for the fourth. The joins were mixed. The ambient loops started almost from silence and ended loud, leaving steps of 18 to 28 decibels at the join, which you would hear as a gap followed by a swell. The other percussion take had the opposite problem, starting loud and ending quiet, with a 22-decibel step. Only one take was nearly perfect, with a step of 1.1 decibels. The cropped explore loop came back at 19.21 seconds with a 4.4-decibel step, quite usable, but we would still add a few milliseconds of crossfade in the game engine. The lesson: generated loops are the right length, but always measure or listen to the join.

Percussion loop, the take with a 1.1 dB join. Set your player to loop to hear it repeat.

The sound-effects requests cost $0.0096 for two takes, and the crop cost $0.008, so making loops is almost free. The real cost is checking them.

Test 4: stems for vertical layering

Many games do not switch tracks at all. They add or remove instruments on top of a single piece, which is called vertical layering. For that you need stems. We ran full stem separation on the combat layer.

Twelve stems from the combat layer, with integrated loudness.

Stem separation cost $0.24 and took 98 seconds. It returned twelve instrument groups, each one twice in two near-identical copies (within 0.2 LU of each other). The strings stem was the loudest at −19.0 LUFS, followed by brass at −21.6 and drums at −24.9, which matches what the brief asked for: driving drums, aggressive strings and brass stabs. The two vocal stems were at −62.4 and −66.2 LUFS, effectively silence, which is what you want from an instrumental.

For a game engine, the drums, strings and brass stems are already a useful three-level system: drums alone for alert, drums plus strings for danger, and everything for combat. But there is one caveat. When we mixed all twelve stems back together, the result was −13.3 LUFS, 1.6 LU louder than the original −14.9 LUFS, and a phase-inverted null test against the original left a residual of −17.4 LUFS. The stems are separations of the finished mix, not the original multitracks, so they do not add back to exactly the same song. That is fine for layering, as long as you balance the stems by ear in the engine instead of assuming they are already balanced.

Test 5: one melody, two intensities, using cover

Separate layers generated from text share a key and tempo, but not a melody. We tried a different approach: we used the cover operation to rearrange the explore layer as combat music, asking it to keep the melody.

Tags: instrumental video game combat music, same melody, D minor, 100 bpm, driving taiko drums, aggressive staccato strings, brass stabs

(coverSong of explore, audio_index 1, instrumental true, version v6)

The request cost $0.05 and took 36 seconds. Both takes kept D as the tonal centre. They were also much longer than the source, at 129.9 and 144.8 seconds against 89.5. We compared chroma profiles to see whether the cover stayed closer to the explore layer than an independent combat layer did. The cover scored 0.981 against the explore layer, compared with 0.963 and 0.950 for the two independent combat takes. That is a small difference, and pitch-class profiles mostly reflect the key rather than the melody, so we do not claim it proves the melody was kept. For a game, the length change matters more: plan to crop covers back to the bar length of your other layers.

Test 6: a long boss track with extend, concat and fade-out

Boss fights can last several minutes. We generated a two-minute boss track and then made it longer:

instrumental epic boss battle music for an adventure game, D minor, 140 bpm, choir pads without words, pounding drums, distorted cello, heroic brass

(custom true, instrumental true, version v6, duration 120)

extend: continue_at 100, tags "... final phase, more intense"

concat: join the extension to the original

fadeOut: duration_s 6

The original boss track and the final 219.6-second version, with the seam at 100 seconds.

The original boss takes were 118.8 and 118.9 seconds long. The extend request returned only the new part, a 119.6-second continuation, which is easy to misunderstand if you expect a complete song back. The concat operation then joined the first 100 seconds of the original and the continuation into one 219.6-second file for $0.004, and the fade-out cost $0.008. The "final phase" is measurably bigger: the section after the seam is 2.3 decibels louder on average than the first 100 seconds, which is exactly what a second boss phase should feel like. The seam at 100 seconds is visible only as a change in density, not as a gap.

The Keeper, the complete 219.6-second boss track.

Every step in this test, from layers and loops to stems and the boss chain, was made through one Suno music API key, so the whole soundtrack can be regenerated from a single script when the game's design changes.

Test 7: victory and defeat stingers

Stingers are the short musical cues that play when you win or lose. We used the sound-effects endpoint in one-shot mode:

short triumphant victory fanfare stinger, brass and bells, bright major ending (type one-shot)

short game over stinger, descending low strings and a muffled bell, sad (type one-shot)

Two victory and two game-over stingers.

Each request took 16 seconds and cost $0.0096 for two takes. The victory stingers were 4.4 and 5.9 seconds long, and our estimate placed both in C major. The game-over stingers were 7.3 and 7.6 seconds, both in C minor. So the mood was exactly right, but neither matched our game's key of D. Because a stinger often plays straight after the music, a key change can sound abrupt. The fix is simple: the sound-effects endpoint accepts a key parameter, and we should have set it to D minor for the stingers as we did for the loops.

Victory stinger, take 1.

Test 8: did "instrumental" really mean no vocals?

Unwanted vocals are a common complaint about AI music. We checked our instrumentals with Whisper speech recognition, and the first result looked alarming: on the explore layer Whisper returned "Thank you very much. Thank you." and on a combat take it returned the word "Music" over and over.

What Whisper reported, and what the isolated vocal stems showed.

Before blaming Suno, we investigated. "Thank you" and repeated filler words are well-known Whisper hallucinations on audio with no speech, and Whisper's own segment data gave most of them a high probability of being non-speech. To be sure, we separated the lead vocal from the explore layer ($0.10, 29 seconds). The vocal stem measured −66.0 LUFS, which is silence, and the vocal stems of the combat layer were −62.4 and −66.2 LUFS. In other words, there were no vocals at all. The words came from the speech recognizer, not from the music. If you automate vocal checks, measure a vocal stem instead of trusting a transcript of an instrumental.

How we would wire this into a game engine

Generated music is only half the work; the other half is playing it back well. Engines and audio middleware such as Unity's audio system, FMOD and Wwise all support the two classic techniques, and the measurements above tell you how to set them up. For horizontal re-sequencing, where the game switches from explore to tension to combat, schedule each switch on the next bar line. At 100 beats per minute in 4/4, one bar lasts 2.4 seconds, so the longest a player waits for the music to react is 2.4 seconds, and you can halve that by switching on the next half bar. Because all three layers shared the tonic D, a bar-line switch will not produce a key clash. For the combat layer, whose tempo we could not confirm, set the transition point by ear in the middleware instead of trusting the number.

For vertical layering, load the drums, strings and brass stems of the combat layer as three synchronised tracks that start together and loop together, and drive their volumes from a single "danger" parameter. Since the stems sum to slightly more than the original mix, leave about 2 decibels of headroom on the music bus. For loops, store the bar count with every file, add a 10 to 30 millisecond crossfade at the loop point, and reject any loop whose join step is more than a few decibels, which the simple level check from Test 3 can do automatically in a build script. Finally, keep stingers on a separate bus so they can duck the music for a moment instead of fighting it.

The walkthrough video

We edited the main layers, loops, the boss track and the charts into the video below, with short excerpts of the real audio.

Walkthrough: scoring Tidewatch with the Suno V6 API (about 3 minutes).

What the soundtrack cost

A complete starter soundtrack, with three adaptive layers, a loop, stems, a 3.5-minute boss track and four stingers, cost 70 cents. Stem separation was the largest single cost. For comparison, a single minute of commissioned game music typically costs far more than this whole test, although of course a composer also brings ideas, revisions and responsibility that an API does not.

Checklist for game developers

1. Put key and tempo in every prompt, including stingers. Our layers followed D minor at 100 beats per minute, but the stingers, without a key, came back in C.
2. Measure tempo, but know the limits. Simple beat trackers handled calm layers well and failed on taiko-heavy combat music. Confirm busy cues against a click.
3. Crop loops to whole bars. At 100 beats per minute, eight bars are 19.2 seconds. The crop endpoint returned 19.21 seconds.
4. Check every loop join. Steps ranged from 1.1 to 28 decibels. Add a short crossfade in the engine.
5. Use stems for vertical layering, and balance them by ear. The sum of the stems was 1.6 LU louder than the original mix.
6. Remember that extend returns only the new part. Use concat to build the full track, then fade it out.
7. Crop covers back to length. Our combat cover was 40 to 55 seconds longer than the source.
8. Do not trust speech recognition on instrumentals. Check a separated vocal stem instead.

The bottom line

For 70 cents and about half an hour of scripted generation, the Suno V6 API gave our fictional game a usable starter score: layers in a shared key, correctly sized loops, stems for vertical mixing, a long two-phase boss track and stingers with the right mood. It is not a replacement for a composer on a commercial game, and it still needs someone to check tempos, loop joins and keys. But for prototypes, game jams and small teams that need placeholder or even final music fast, it changes what is possible. If you want to build a similar pipeline, or combine music with image and video models under one key, you can find them all on APIMart.