“Salt on My Shoes” by June Harbor, a fictional indie artist. Lyrics, vocals, edits and master all came from one API pipeline.
Most articles about AI music stop at the moment a song appears. For anyone who actually releases music, or builds tools for people who do, that moment is the start of the work, not the end. A song needs lyrics that make sense, a structure that follows the plan, a voice that stays consistent from one release to the next, fixes to individual sections, a version at the right tempo, and a master that meets streaming loudness targets.
So we treated the Suno V6 API as a production pipeline and tested each stage in order. We invented an indie folk-pop artist called June Harbor and set out to make her debut single, from a one-sentence idea to a mastered file. At each step we measured the result instead of describing how it sounded: speech recognition to check lyrics and structure, isolated vocal stems to find the instrumental break and compare voices, chroma analysis to check that the key survived a tempo change, and EBU R128 loudness measurements for the master. We recorded the time and the API-reported cost of every task.
The whole pipeline cost one dollar. Some stages worked better than we expected and one did not do what we asked. Here is everything we found.
The pipeline at a glance
Every Suno operation is asynchronous: submit a request, receive a task ID, poll until the status is completed, and read the result. Operations that work on an existing song refer to it by the original task ID plus an audio index (1 or 2), because every generation returns two takes. That makes it easy to chain steps without storing intermediate files.
import requests, time
BASE = “https://api.apimart.ai/v1/music”
H = {“Authorization”: “Bearer YOUR_KEY”}
def call(action, body):
url = f”{BASE}/generations/{action}” if action else f”{BASE}/generations”
task = requests.post(url, headers=H, json=body).json()[“data”][0][“task_id”]
while True:
d = requests.get(f”{BASE}/tasks/{task}”, headers=H).json()[“data”]
if d[“status”] in (“completed”, “failed”):
return task, d
time.sleep(5)
_, lyr = call(“lyrics”, {“prompt”: “a quiet indie folk-pop song about …”})
song_id, song = call(“”, {“custom”: True, “version”: “v6”, “title”: “Salt on My Shoes”,
“prompt”: edited_lyrics, “style”: STYLE, “vocal_gender”: “female”})
_, vox = call(“stems”, {“task_id”: song_id, “audio_index”: 1, “stem_type”: “lead_vocal”})
Our pipeline had eight stages: lyrics, editing, generation, structure check, persona, section replacement, tempo change and mastering. The sections below follow that order.
Test 1: the lyrics endpoint
We gave the lyrics endpoint three one-sentence themes and nothing else:
a quiet indie folk-pop song about a lighthouse keeper’s daughter who leaves her small coastal town for the city, bittersweet but hopeful
a dreamy indie pop song about walking home through an empty city at 4am after a night out, nostalgic and warm
an upbeat indie rock song about finding old unsent letters in a drawer and deciding to finally send them
Three themes in, three titled songs out, for less than one cent each.
Each request returned in 9 to 15 seconds and cost $0.008. Each result was a complete song of about 340 to 400 words, with section tags (verse, pre-chorus, chorus, bridge, final chorus), a title and a detailed style description. The titles were good: “Salt on My Shoes”, “Fourth Avenue Glow” and “Drawer Full of Postcards”. The lyrics used concrete images rather than clichés: gulls over a breakwater, a bakery on Third Street, a seashell note, a deli gate rattling shut.
They were not flawless. The lighthouse song opened with “She packed her coat in June” and then switched to “Mama kissed my hair” a few lines later, changing from third person to first person in the same verse. A pre-chorus line, “Folded in my coat lining”, broke the rhyme scheme that the rest of the song followed. The 4 a.m. song contained the odd phrase “like a sweet piece of punchline wine”. These are the kinds of mistakes a human editor catches in a minute, and they are exactly why we treat the lyrics endpoint as a first draft.
Test 2: editing the lyrics before generation
We chose “Salt on My Shoes” and made three edits. We fixed the point of view (“I packed my coat in June”), repaired the broken rhyme (“Kept the seashell note I wrote / Folded in its frame”, which now rhymes with “lantern flame”), and added two structural tags that were not in the draft: an [Instrumental] section before the bridge and a one-line [Outro]. Then we generated the song in custom mode, where the prompt is used as the exact lyrics:
Style: indie folk-pop, fingerpicked acoustic guitar, brushed drums, upright bass, airy harmonies, light pedal steel, warm intimate female vocal, 96 bpm
(custom true, version v6, vocal_gender female, edited lyrics with [Verse 1] [Pre-Chorus] [Chorus] [Verse 2] [Pre-Chorus] [Chorus] [Instrumental] [Bridge] [Chorus] [Outro])
The request took 56 seconds and cost $0.05. It returned two takes of 227.8 and 216.8 seconds. Our tempo estimate for take 1 was 97 BPM against the requested 96. The style suggestions from the lyrics endpoint had mentioned pedal steel, airy harmonies and a coastal mood, and we kept most of them in the style prompt, so the two endpoints worked well together.
“Salt on My Shoes”, take 1 after remastering and our final −14 LUFS master.
Take 2 of the same request, unprocessed.
Test 3: did it follow the structure tags?
Structure tags are only useful if the model follows them. We checked in two ways. First, we transcribed both takes with Whisper, which returns a timestamp for each phrase, and matched the first line of every section to the transcript. Second, because Whisper sometimes stretches a timestamp across silence, we extracted the isolated lead vocal with the stems endpoint and looked for stretches where the vocal stem was quiet. That gave us an objective map of where the singing actually stopped.
Section map of both takes, measured from timestamps and the isolated vocal.
Both takes followed the written structure exactly. Every section was present and in the right order: verse, pre-chorus, chorus, second verse, pre-chorus, chorus, instrumental, bridge, final chorus, outro. The [Instrumental] tag produced a real break with no lead vocal: 14 seconds in take 1 (142 to 156 seconds) and 11 seconds in take 2 (146 to 157 seconds). Both takes also added something we had not written: a 9 to 10 second instrumental introduction before the first line. That is a sensible musical choice, but if you need the vocal to start immediately, for example in a short advert, add an explicit instruction or trim the intro afterwards.
The transcription also showed that the lyrics were sung as written. The only real mishearing in the first minute was Whisper hearing “gulls” as “girls”, and the edited lines, including the repaired rhyme, came through clearly. Using timestamps and vocal stems together turned out to be a reliable, fully automatic way to check structure, and it cost only the price of one stem extraction ($0.10).
Test 4: a persona for a consistent voice
An artist needs to sound like the same person on every release. Suno’s persona feature creates a reusable voice from an existing song. We created one from the first 10 to 75 seconds of take 1:
persona: task_id = single, audio_index 1, name “June Harbor”,
describe “warm, intimate female indie folk voice with a soft breathy tone”,
styles “indie folk-pop”, vocal_start_s 10, vocal_end_s 75
Persona creation took 22 seconds and cost $0.004, and returned a persona ID. We then used the other two lyric drafts to make two new songs in different styles, an upbeat indie rock song and a dreamy synth-pop song, each generated twice: once with the persona and once without, with only vocal_gender: “female”. One practical note: the persona request still needs a version field, so send “version”: “v6” together with persona_id.
Judging whether two voices are “the same” by ear is subjective, so we measured it. We extracted the lead vocal from every song and compared three features with the original vocal: the median pitch, the spectral centroid (brightness) and the average energy profile across 40 frequency bands, which captures timbre. The timbre distance is the difference between those profiles; lower means more similar.
Lower bars are closer to the original voice. Teal: persona songs. Orange: same songs without the persona.
On timbre and brightness, the persona songs were closer to the original in both pairs. Their timbre distances were 0.56 and 0.71, against 0.81 and 0.79 for the same songs without the persona. Their brightness was 2,185 and 1,980 Hz, against 1,904 Hz for the original, while the control songs were brighter at 2,394 and 2,262 Hz. Pitch was mixed. For the indie rock song, the persona version sat at 296 Hz, close to the original 302 Hz, while the control version was much higher at 327 Hz. For the synth-pop song, the persona version was at 291 Hz and the control at 308 Hz, so the control happened to be slightly closer.
We want to be careful about how much this proves. Take 2 of the original song, sung from the same request, had a timbre distance of 1.05, larger than any of the new songs. That tells us our measure is strongly affected by the arrangement and the performance, not only by the voice. With two songs per group, the result is a consistent indication that the persona pulls the voice towards the original, not a proof that it is identical. For a real artist, we would combine a persona with a fixed style description and a final human listening check.
“Drawer Full of Postcards” with the June Harbor persona.
The same lyrics and style without the persona.
Every stage so far, from lyrics to persona, ran through the same Suno AI music generation API, which exposes generation, lyrics, persona, stems and editing operations behind one key and returns the real cost of each task, so the cost table at the end of this article came straight from our logs.
Test 5: replacing a section
Songwriters often want to rewrite one verse without regenerating the whole song. The section-replacement operation (replaceMusic) takes a time range and new lyrics for that range. We asked it to replace the second verse, from 75 to 96 seconds, with four new lines:
start_s 75, end_s 96
infill_lyrics:
The subway hums a lullaby
I never learned to sleep
But the corner store man knows my name
And the coffee here is cheap
tags: indie folk-pop, fingerpicked acoustic guitar, warm intimate female vocal
The requested lines and what speech recognition heard in the replaced section.
The request took 36 seconds and cost $0.05. It returned two clips of about 25 seconds, slightly longer than the 21-second window, rather than a complete song. We spliced each clip back into the original with short crossfades, and musically the result was seamless: the tempo, key and arrangement matched, and the join was hard to find in the waveform.
The words were the problem. When we transcribed the spliced songs, neither version contained our new lines. One version had phrases such as “Is that nothing back from after what I forgave”, the other was mostly unintelligible, and both ended with “you can sing”, a phrase from the original verse. In our test, the replacement kept the music and the song’s continuity but did not sing the requested lyrics. Until you have confirmed otherwise on your own material, treat section replacement as a way to change the musical texture of a passage, and always transcribe the result before you accept it. If the words matter, regenerating the whole song with edited lyrics is the reliable route, and at five cents it is not expensive.
Test 6: changing the tempo without changing the key
A faster version is useful for radio edits, short videos and workout playlists. The adjustSpeed operation changes the speed and can keep the pitch. We requested a speed of 1.1 with keep_pitch: true.
Length, tempo and key before and after the speed change.
It took 36 seconds and cost $0.024. The numbers matched the request almost perfectly. The length went from 227.8 to 207.1 seconds, a ratio of exactly 1.100. Our tempo estimate went from 97 to 106.5 BPM, a ratio of 1.098. To check the key, we compared the chroma profile of both versions, which measures how much energy falls on each of the twelve musical notes. The best match was at zero semitones of shift, with a correlation of 0.999, so the key was unchanged. That is the result you want from a time-stretch: faster, same song, same key.
The single at speed 1.1 with pitch preserved.
Test 7: remastering
We ran Suno’s remaster operation at normal intensity on take 1. It took 70 seconds, cost $0.05 and returned two remastered versions, which we measured with ffmpeg’s EBU R128 analysis.
Loudness measurements from generation to release master.
The generated take was already loud, at −13.5 LUFS, and its true peak was +0.2 dBFS, slightly above full scale. That matters, because a peak above zero can distort when a streaming service converts the file to its own format. The remaster tightened the dynamics, reducing the loudness range from 8.3 to 7.4 LU, and kept the integrated loudness almost the same (−13.8 and −13.9 LUFS). The true peak, however, was still at +0.1 and 0.0 dBFS. In short, the remaster polished the sound but did not deliver a file ready for streaming.
Test 8: the release master and the radio edit
For the final step we left the API and used ffmpeg, because a release master has precise technical targets. We ran a two-pass loudness normalisation on remaster version 1, targeting −14 LUFS integrated loudness and a −1 dBTP true-peak ceiling, which is a common recommendation for streaming platforms. The result measured −13.9 LUFS with a true peak of −0.8 dBFS: on target for loudness, and below full scale with a safety margin. To respect the peak limit, the normaliser had to compress the loudest moments, so the loudness range fell to 5.7 LU. That is a reasonable trade for a folk-pop single, but it is worth knowing that peak safety costs some dynamics.
We also made a radio edit locally: we removed the bridge from 156 to 175 seconds with a one-second crossfade, added a three-second fade-in and an eight-second fade-out, and ended with a 207.8-second version. The API also offers operations for removing sections, cropping and fading, but for final delivery files we prefer to do these last edits ourselves, where we control the crossfade length and the exact cut points.
Radio edit: bridge removed, 3-second fade-in, 8-second fade-out.
How we would wire this into an app
If we were turning this pipeline into a product for independent artists, the order would stay the same, but each stage would get an automatic gate. Lyrics would go to a human editor or a language model for a consistency check before generation. After generation, a structure check would compare Whisper timestamps and the vocal stem with the requested sections and flag any missing part. A persona would be created once per artist and reused for every release. Any section replacement would be transcribed and rejected if the new lines were not found. Finally, every delivery file would pass a loudness and true-peak check before it could be downloaded. Each of those gates is cheap and fast, and together they turn a creative model into something a team can rely on.
The walkthrough video
The video below walks through the pipeline and plays short excerpts at each stage.
Walkthrough: making June Harbor’s debut single with the Suno V6 API (about 2.5 minutes).
What the whole single cost
API-reported cost of every step.
The full pipeline cost $1.00. More than half of that, $0.60, went on six lead-vocal extractions, which we used only for measurement: two to map the structure and four to compare voices. A production pipeline that skipped the persona test would cost about 25 cents for lyrics, a song, a structure check, a tempo version and a remaster. Generating music was the cheapest part of the process. The time-consuming part was checking each result, which is also the part most worth automating.
A checklist for automated songwriting pipelines
- Treat generated lyrics as a first draft. Ours had a point-of-view switch and a broken rhyme that took a minute to fix.
- Use structure tags. Both takes followed our sections exactly, including an [Instrumental] break of 11 to 14 seconds.
- Expect an intro you did not write. Both takes added 9 to 10 seconds before the first line.
- Check structure automatically. Whisper timestamps plus a lead-vocal stem map every section for ten cents.
- Use a persona for continuity, then listen. It moved brightness and timbre towards the original voice in both new songs; pitch was closer in one of the two.
- Transcribe every section replacement. Ours kept the music seamless but did not sing the new lines.
- Trust the speed control. A 1.1 request gave a 1.100 length ratio and no change of key.
- Master to a target yourself. The remaster still peaked at 0 dBFS; a two-pass normalisation gave −13.9 LUFS at −0.8 dBTP.
The bottom line
For one dollar, the Suno V6 API took June Harbor from a one-sentence idea to a structured, consistent-sounding, speed-adjustable single, and every stage produced results we could measure and verify automatically. Lyrics need a human edit, section replacement needs checking, and the final master is best done with your own tools. Everything else, from structure to persona to tempo, behaved like a dependable production component. If you are building music tools or simply want to run this pipeline yourself, you can use Suno alongside other audio, image and video models on the APIMart platform.
