How to Extend AI Music Clips with an API

What "extend" means in an AI music context

AI music models have a per-task duration ceiling. On Google Lyria 3 Pro (the model behind MusicAPI's Producer API), a single create call can produce up to 240 seconds of audio. Beyond that, you need to extend.

The extend_music operation takes an existing clip and continues it forward from a specified timestamp. The result is a new audio segment that picks up where you tell it and runs for the length you request. Chain multiple extends to build full-length tracks from shorter clips.

Three common motivations developers use extend for:

1. Hook-to-full-song development: generate a great 60-second hook, then extend with instructions like "build to a chorus" or "add a bridge and outro."
2. Per-section iteration: generate verse 1, extend to chorus 1, extend to verse 2, etc. Each section is a separate extend with its own instruction.
3. Reaching longer durations: chain 3-5 extends to produce 4+ minute tracks past the 240s single-task ceiling.

The extend_music endpoint at a glance

On MusicAPI's Producer API (Google Lyria 3 Pro), the endpoint is POST /api/v1/producer/create with task_type: "extend_music". The four parameters that matter:

• clip_id (required): the source clip to extend. From a previous create_music, extend_music, or other Producer response.
• starts_at (required): seconds from the start of the source where extension begins. For a 60s source, use 55-58 for a clean handoff.
• length (optional, default 60): duration of new audio in seconds. Range 1-240.
• instruction (recommended): musical direction for the extension. Clearer than relying on sound/lyrics fallback.

Single extend: hook to full song

Start with the 60-second hook, then extend forward with explicit instruction:

Step 1: generate the hook

curl -X POST https://api.musicapi.ai/api/v1/producer/create \
  -H "Authorization: Bearer $MUSICAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "task_type": "create_music",
    "sound": "energetic synth-pop with driving bass and catchy chorus melody",
    "title": "Hook",
    "length": 60
  }'

# Save the returned task_id, poll for completion, capture data[0].clip_id.

Step 2: extend to a chorus

curl -X POST https://api.musicapi.ai/api/v1/producer/create \
  -H "Authorization: Bearer $MUSICAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "task_type": "extend_music",
    "clip_id": "<hook-clip-id>",
    "starts_at": 55,
    "length": 60,
    "instruction": "Build into a soaring chorus with layered vocal harmonies, doubled bass, and a wider arrangement"
  }'

# Returns a new clip_id covering t=0 (start of extend) through t=60.
# The new clip is the continuation, not the original + continuation.

Important: the response's clip_id is for the new segment only. To play back the full song (hook + chorus continuation), you concatenate the audio_url of the original hook with the audio_url of the extend on your side.

Chaining extends past the 240-second ceiling

To produce a 3-4 minute track, chain 3-4 extends. Each call takes the previous clip's clip_id as the source. Here's a 4-minute song built in 4 calls:

# Call 1: create the hook (60s, original)
POST /api/v1/producer/create
{ "task_type": "create_music", "sound": "...", "length": 60 }
# → clip_id_1

# Call 2: extend to verse (60s)
POST /api/v1/producer/create
{ "task_type": "extend_music", "clip_id": "clip_id_1", "starts_at": 55, "length": 60,
  "instruction": "Build into the first verse with intimate vocals" }
# → clip_id_2

# Call 3: extend to chorus (60s)
POST /api/v1/producer/create
{ "task_type": "extend_music", "clip_id": "clip_id_2", "starts_at": 55, "length": 60,
  "instruction": "Burst into a powerful chorus, full arrangement, layered vocals" }
# → clip_id_3

# Call 4: extend to outro (60s)
POST /api/v1/producer/create
{ "task_type": "extend_music", "clip_id": "clip_id_3", "starts_at": 55, "length": 60,
  "instruction": "Wind down to a gentle outro, fade out the energy gradually" }
# → clip_id_4

Total cost: 12 credits × 4 calls = 48 credits = $0.24-1.08 depending on plan. Total length: ~4 minutes (each segment is ~60 seconds, with the starts_at: 55 producing a 5-second overlap that you trim on the client).

The starts_at pattern

The single most-asked question about extend is what starts_at should be. The answer depends on what you want:

Instruction patterns that work

• Name the song structure target. "Build into a chorus" or "Drop into a bridge" gives the model section-level context. "More music" doesn't.
• State the dynamic direction. "Energy increases" or "Wind down to outro" tells the model where the segment lands. Songs have shape; tell the model what shape.
• Reference instrumentation explicitly. "Add layered vocal harmonies and a doubled bass" gives more direction than "fuller arrangement."
• Match style to the source. If the source was indie folk, your extend instruction should reinforce that genre. Letting the model drift to a new genre mid-track produces muddled output.
• Reserve dramatic shifts for cover_music, not extend. Extend continues the song. If you want a genre transformation, use cover_music instead.

When chains drift

At 3+ chained extends, stylistic drift becomes visible. The model only sees the most recent clip as context, so each extend rebuilds its understanding of the song from a smaller window. Two mitigations:

1. Anchor every extend's instruction to the original style. Phrase like "Continue the indie folk song's style" rather than just "Build into a chorus."
2. Limit chain depth. 3-4 extends is the practical sweet spot. Past 5 extends, drift accumulates faster than instructions can correct it. For longer-form tracks, Suno v5 on the Sonic API has a higher per-task duration ceiling (~8 min via fewer, longer extends): see Lyria 3 Pro vs Suno v5.

Production best practices

1. Cache by (clip_id + starts_at + length + instruction + seed). Same input + same seed = same output. Don't pay twice.
2. Use webhooks for chained extends. If you're running 4 chained calls and polling each, you're waiting ~2 minutes of total latency. With webhooks, each completion triggers the next call automatically.
3. Set a max-chain-depth in your client logic. Don't let a user trigger 20 chained extends: bound it at 4 or 5.
4. Concatenate on your side. The API returns each segment as a separate audio_url. Your client stitches them. Use the starts_at overlap as a crossfade point.
5. Validate each segment before chaining. Check the previous extend succeeded (state=succeeded) before submitting the next. Failed mid-chain wastes credits: auto-refund catches it but loses time.

Pricing

12 credits per extend task on MusicAPI's Producer API. Same flat cost as create, replace, and cover. Effective per-extend cost:

• $0.18 on the $5 entry pack
• $0.13 on Starter $19/mo
• $0.09 on Growth $99/mo
• $0.06 on Pro $999/mo

A 4-minute song built via 1 create + 3 extends = 48 credits = $0.72 on Growth or $0.24 on Pro. See Lyria 3 Pro pricing for the full plan economics.

Common questions

Try it

• 75 free credits on signup covers a hook + 5 extends.
• Try in the playground: no signup.
• Producer API docs for the full reference.
• Cover music guide: the sibling operation. Cover changes style; extend continues the song.

Last updated 2026-05-22.