How to Generate AI Cover Songs with an API

What "cover music" means in an API context

In streaming services, a "cover" is a re-recording of an existing song by a different artist. In the AI music API world, the term has the same spirit but a more precise mechanic: you give the API a source clip and a natural-language description of the target style, and it returns a fresh audio track that keeps the source's structural skeleton (sections, rough melody, song length) but re-renders the sound according to your instruction.

Three common motivations developers ship cover features for:

1. Genre crossover: turn an indie pop track into a synthwave reimagining, or a rock anthem into an orchestral arrangement.
2. Stylistic shifts: same song, slower tempo, acoustic arrangement. Same song, more aggressive production. Same song, lofi beats backing.
3. User-driven remixing: let users on your platform remix tracks they like by entering a one-line prompt. The cover endpoint is the engine.

The cover_music endpoint at a glance

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

• clip_id (required): the source clip to cover. From a previous create_music, extend_music, or replace_music response.
• instruction (required): natural-language description of the target style. Treat this like a music director's brief.
• strength (0-1, defaults to 0.5): how far the cover diverges from the source.
• title (optional): output track title.

For source clips uploaded via POST /api/v1/producer/upload (your own audio), swap task_type to "cover_upload_music". Same endpoint, same response shape, same pricing.

The strength parameter, explained

Strength is the single lever that controls how aggressive the cover is. Use this rough mapping:

A practical strategy: when shipping a user-facing cover feature, expose strength as a UI slider with three labeled stops: "Subtle" (0.3), "Balanced" (0.5), "Bold" (0.8). Most users will pick Balanced. Power users get the slider.

Worked example: cover a clip three ways

Same source clip, three different strength values, three different outputs. This is a complete flow you can run today on 75 free credits.

Step 1: generate a source clip

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": "upbeat synth-pop, driving bass, catchy chorus",
    "title": "Source Clip",
    "length": 60
  }'

# Save the returned task_id, then poll for the finished clip.
# Once done, you'll get back data[0].clip_id: that's your source.

Step 2: cover at low strength (acoustic reinterpretation)

curl -X POST https://api.musicapi.ai/api/v1/producer/create \
  -H "Authorization: Bearer $MUSICAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "task_type": "cover_music",
    "clip_id": "<source-clip-id>",
    "instruction": "Acoustic version. Same melody, slower tempo, replace synths with acoustic guitar and warm vocals. Keep the structure intact.",
    "strength": 0.3,
    "title": "Cover: Acoustic"
  }'

At strength 0.3 the result keeps the source's chord progression, melody, and song structure. Only the timbre and tempo shift.

Step 3: cover at mid strength (genre shift)

curl -X POST https://api.musicapi.ai/api/v1/producer/create \
  -H "Authorization: Bearer $MUSICAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "task_type": "cover_music",
    "clip_id": "<source-clip-id>",
    "instruction": "Indie folk reimagining with fingerpicked acoustic guitar, banjo, and intimate vocal harmonies",
    "strength": 0.6,
    "title": "Cover: Indie Folk"
  }'

Step 4: cover at high strength (dramatic transformation)

curl -X POST https://api.musicapi.ai/api/v1/producer/create \
  -H "Authorization: Bearer $MUSICAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "task_type": "cover_music",
    "clip_id": "<source-clip-id>",
    "instruction": "Heavy synthwave 80s reinterpretation, gated reverb drums, dark analog pads, cinematic atmosphere",
    "strength": 0.85,
    "title": "Cover: Synthwave"
  }'

At strength 0.85 the cover diverges enough that side-by-side listeners might recognize the relationship but won't mistake it for the same song. This is where covers stop being "variations" and start being "reimagined."

Prompt patterns that work

A few non-obvious patterns from production developers shipping cover features:

• Name the era for genre crossover. "Synthwave 80s" is stronger than "synthwave." "Bossa nova 60s" beats "bossa nova." Models lean into era-specific production cues when you name them.
• State what to keep, not just what to change. "Keep the vocal melody" or "Preserve the chord progression" in the instruction does more work than you'd expect. Pairs well with a mid-strength value.
• Specify instrumentation explicitly. "Replace electric guitar with acoustic guitar" outperforms "more acoustic." Concrete instrument names beat genre adjectives.
• Match strength to ambition. If your prompt asks for a dramatic shift, pair it with strength 0.7+. If your prompt asks for a subtle remaster, drop to 0.3. Mismatched prompt-and-strength produces confused output.
• Specify what to drop. "Remove the lead synth" or "Strip back the percussion" gives the model permission to leave space in the arrangement.

Production best practices

1. Always use clip_ids your user owns. Either AI-generated clip_ids from your own MusicAPI generations, or audio your user uploaded via /api/v1/producer/upload. Don't cover commercial tracks you don't have rights to.
2. Expose strength as a 3-stop slider in your UI. "Subtle / Balanced / Bold" covers 95% of user intent. The full 0-1 range is power-user territory.
3. Wire webhooks for production. Polling is fine in development. For production volume, register a webhook on each cover submission to get delivered notifications and free your client process.
4. Cache covers by (clip_id + instruction + strength + seed). Same input produces the same output when seed is fixed. Don't pay twice for the same render.
5. Use seed for reproducible A/B tests. When tuning prompt patterns, hold seed constant so generation randomness doesn't confuse the signal.
6. Show the source clip alongside the cover in your UI. Users grok "cover" faster when they can A/B listen. Reduces support questions about "why does this sound different."

Commercial use and licensing

All cover output via MusicAPI ships with full commercial rights. You own the generated track and can use it in:

• Apps, games, and software
• Marketing videos, ads, social content
• Podcasts, intros, transitions, chapter beds
• Music products, mood compilations, sync libraries
• Resale or licensing to your own customers (if your terms allow)

The only caveat: if your source clip_id came from a clip you uploaded that was itself a copyrighted commercial recording (a Suno download, a Spotify export, etc.), the original copyright travels to derivative output. Use sources you legally own or original AI-generated clips. The cover doesn't launder copyright; it inherits it.

Pricing

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

• $0.18 on the $5 entry pack (~22 covers for $5)
• $0.13 on the $19 Starter monthly
• $0.09 on the $99 Growth monthly
• $0.06 on the $999 Pro monthly (best public rate)

Failed upstream covers are auto-refunded, so retrying is free. See the full Lyria 3 Pro pricing breakdown for plan-by-plan economics.

Common questions

Try it

• Sign up for 75 free credits: covers 6 cover tasks at $0 cost.
• Try in the playground: no signup required.
• Producer API docs for the full reference, schemas, and operation matrix.
• Lyria 3 Pro overview for context on the model behind cover_music.

Last updated 2026-05-22. cover_music was restored on Producer API on 2026-05-20 after a brief gap during the April migration to Google Lyria 3 Pro.