What is the HeartMuLa Transcribe API?

It is a lyrics transcription API: you send the URL of an audio file and it returns the words sung in that recording as text on the task. The request has exactly one field, audio_url, and the schema accepts nothing else. It is tuned for vocals over music rather than for plain speech, handles multiple languages without being told which one to expect, and is billed per transcription instead of per minute of audio.

How do I extract lyrics from an audio file with an API?

Host the audio at a URL that returns the audio bytes, POST that URL as audio_url, then poll the task it returns or handle the callback you registered. When the task reaches a terminal state, the lyrics are in its result as text. There is no upload body to build, no file to download afterwards and no second call to make — the whole integration is one request and one read.

Does the audio file have to be publicly accessible?

No. It has to be fetchable, which is not the same thing: a signed link with an expiry works while it is still valid. What fails is a URL that answers with HTML — a player page, a share page or a landing page — because the endpoint needs the audio itself. That failure is reported as invalid material rather than as a poor transcription, so it is easy to tell the two apart.

Can I transcribe several tracks in one request?

One request carries one audio_url and produces one transcript, so a batch is a loop over a worklist rather than a single larger call. Stitching several tracks into one file does reduce the number of charges, but the transcript comes back as one continuous block of text with nothing marking where one track ends and the next begins, which usually costs more to untangle than it saves.

What happens if my client retries the same request?

Send an Idempotency-Key and the retry lands on the original task instead of creating a second one. The key is honoured for 24 hours, which covers the realistic window for a dropped connection or a worker restart. Without a key, a retry is a new request and settles as one, so the key is the difference between one charge and two for the same track.

How long do you keep the transcript and the audio?

The transcript lives on the task and is erased on the same schedule as prompt text, so the durable copy is the one you write into your own store. Audio uploaded to SpicyAPI storage is deleted after one day. Because this endpoint produces no media asset, nothing from it enters the 14-day media retention window that applies to image and video output elsewhere in the catalog.

When does a request fail rather than return a short transcript?

Failures come from the material, not from the content. A URL that cannot be downloaded, or one that answers with a web page instead of audio, is rejected as invalid material. A track the model can hear but that has little to transcribe — an instrumental, for instance — is not a failure at all: it reaches a successful terminal state and settles like any other accepted request, which is why screening for vocals before a large batch is worth the effort.

Who owns the lyrics this returns?

Not us, and the answer is not automatic. Lyrics are usually protected separately from the sound recording, so holding a copy of a track does not by itself give you the right to publish its words. The rights to the source audio and to the transcript are the caller's responsibility, and the API cannot see whether they are in order — that check belongs in your workflow, before the text goes anywhere public.

Who makes HeartMuLa Transcribe and when was it released?

HeartMuLa builds it, and it arrived on 8 September 2026. It is a single-endpoint family: one task, speech to text, reached as heartmula/transcribe/speech-to-text. Unlike the image and video families in this catalog, it produces no media asset at all, which makes it the one place here where a finished task hands you text instead of a file.

HeartMuLa Transcribe API

heartmula/transcribe/speech-to-text

HeartMuLa Transcribe is a multilingual speech-to-text endpoint tuned for sung vocals: send one audio URL and get the lyrics back as text. There are no options, and no line timings, confidence values or speaker labels are returned.

From $0.05/request

Run model View API

Output

Ready for a new run

Your result will appear here.

Configure the inputs, review the estimate, then run the model.

Introduction

It transcribes the sung lyrics in an audio file and returns them as text on the task. It is tuned for vocals over music rather than for plain speech.

HeartMuLa Transcribe extracts sung lyrics from an audio file and returns them as text. One audio field, no options, multilingual, billed per transcription rather than per minute.

Key features & highlights

Tuned for the part general speech models lose

A sung line arrives compressed, doubled, drenched in reverb and competing with instruments in its own frequency range. That is the case a general speech model was never trained on, and where it tends to hand back fragments. This one is tuned for exactly that. The trade runs both ways: for an interview or a podcast, with no mix to fight, a general speech-to-text model is the better tool.

Text on the task, no asset to fetch

No file is written for you to fetch. The run ends on the task itself, with the transcript sitting in the result: no download step, no bucket to write into, and nothing from it entering the 14-day media retention. Read the text off the finished task and send it straight to wherever your lyrics already live.

A back catalog is a multiplication, a clip pile is not

Duration never enters the price, so a six-minute track costs what a twenty-second hook costs. That makes a backlog easy to budget — track count times one number — while a folder of short fragments is the relatively expensive shape. Worth planning for: a piece that turns out to be instrumental comes back nearly empty and still counts as a successful, billed run, so screen those out before you queue them.

Request parameters

Request parameters for HeartMuLa Transcribe · Transcribe Lyrics
Parameter	Required	Description
`audio_url`	Yes	A URL that resolves directly to an audio file. Pages that return HTML fail as an invalid asset. at least 1 characters

Pricing

$0.05 / transcription

Billed per transcription, not per minute: a thin transcript from an instrumental track is still charged.

Use cases

Turn speech into usable text

It transcribes the sung lyrics in an audio file and returns them as text on the task. It is tuned for vocals over music rather than for plain speech. Use this mode to transcribe an audio or video source. Provide a clear recording where possible, then review names, timestamps and any passages with low confidence.

Uncensored audio products

SpicyAPI applies no content filter, so lyrics with strong language come back transcribed rather than refused or bowdlerised. You are still responsible for the rights to the audio you send.

Music catalog metadata

Generate lyric text across a catalog to improve search, display and tagging. Per-run pricing makes the cost of a backlog a simple multiplication instead of a function of total runtime.

Subtitles for music-backed video

Pull the sung lines out of a track so they can be timed into captions for short-form video, where the vocal sits over a dense mix.

Explore key use-case tutorials

Prompt guide & pro tips

Send a direct URL to the audio file

The field takes a URL, not an upload body. It should point at the audio itself — a stream page or a share link that returns HTML will fail as an invalid asset, not as a bad transcription.

Expect text on the task, not a file

The transcript is returned as text on the task result. There is no media asset to fetch, and nothing is stored in media retention for this endpoint.

Check the result before iterating

One audio URL in, lyric text out, nothing to configure: no language hint, no timestamps, no speaker labels, no confidence values and no choice of output shape. The model is tuned for sung vocals over music; heavily layered mixes, whispered or screamed vocals and very low-bitrate sources degrade the result, and instrumental audio returns little or nothing. The URL must resolve directly to an audio file — a page that returns HTML fails as an invalid asset. This endpoint produces no media asset, so nothing from it appears in the 14-day media retention.

API quick start

# Generate the idempotency key once; reuse it when retrying after a lost response.
export SPICY_IDEMPOTENCY_KEY="${SPICY_IDEMPOTENCY_KEY:-$(uuidgen)}"
curl -X POST https://api.spicyapi.ai/api/v1/jobs/createTask \
  -H "Authorization: Bearer $SPICY_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $SPICY_IDEMPOTENCY_KEY" \
  -d '{
  "model": "heartmula/transcribe/speech-to-text",
  "input": {
    "audio_url": "https://example.com/reference.mp3"
  }
}'

# Copy data.taskId from the response into TASK_ID, then poll the status.
TASK_ID="TASK_ID_FROM_RESPONSE"
curl "https://api.spicyapi.ai/api/v1/jobs/recordInfo?taskId=$TASK_ID" \
  -H "Authorization: Bearer $SPICY_API_KEY"

See the API reference for authentication, the complete schema, polling, and error handling.

Related models and next tasks

Missing the model you need?

Tell us what to add and where you would use it. Requests go to the people who decide what gets onboarded next.

Lyrics pulled out of a finished mix, handed back as text

HeartMuLa Transcribe takes one field — an audio URL — and returns the words sung in that recording as text on the task. There is no language setting, no timestamp option and no speaker toggle, because those fields do not exist in the schema. It is the only family in this catalog that finishes a task with text instead of a media file, so nothing is written to media storage and there is no download step to build. Billing is per transcription rather than per minute, which makes a six-minute track and a twenty-second hook cost exactly the same.

Open the playground

Request fields: One: audio_url, a URL that resolves to audio
Output: Lyric text on the task result — no file, no asset URL
Billing: Per transcription, independent of audio length
Languages: Multilingual; the detected language is not reported
Task ceiling: 3,600 seconds from submission to a terminal state
Retention: No media asset written; uploaded audio deleted after 1 day

Shape: One required field, and the schema refuses the restaudio_url is the entire request body: a non-empty URI string that has to resolve directly to the audio. Every other key fails validation rather than being quietly dropped, so a run that returns a transcript is a run that used exactly what you sent. There is nothing to tune between calls and nothing to keep in sync as the integration grows.
Output: Text on the task, not a file in a bucketEvery other family here ends by writing a file for you to fetch. This one ends on the task itself, with the transcript in the result. No download step, nothing entering the 14-day media window, and one branch in your client that reads a text field where the others walk an asset list.
Target: Tuned for a voice fighting a mixA sung line arrives compressed, doubled, drenched in reverb and competing with instruments in its own frequency range — the case general speech models were not trained on, and where they tend to hand back fragments. That is what this model is tuned for. For an interview or a podcast, with no mix to fight, a general speech-to-text model is the better tool.

What the HeartMuLa Transcribe API does well

A request you can write from memory
One key, one string value. There is no parameter sheet to maintain, no combination of settings that can silently change what the model is asked to do, and no migration to plan when the integration grows. The closed schema means a typo in a key name comes back as an invalid request immediately, rather than as a transcript produced with a setting you thought you had applied.
Lyric text arrives on the task itself
The result carries the transcript directly, so there is no signed URL to fetch, no object storage to write into and no cleanup job to schedule for downloaded files. A pipeline that already handles media tasks needs one extra branch: when this endpoint finishes, read the text field instead of walking an asset list, and send it straight to wherever your lyrics already live.
Duration never enters the bill
Charging is per accepted request, so audio length, sample rate and how much text actually comes back all leave the amount alone. Budgeting a backlog becomes a multiplication — track count times the per-run price — instead of a function of total runtime. The flip side is worth planning around: a pile of very short clips is comparatively expensive per minute of audio processed.
Multilingual without a language field
The model handles multiple languages on its own and there is no field to declare one, which removes a whole class of setup work from a mixed-language catalog: no detection pass in front of the call, no per-language routing table, no wrong-language retries. It also does not report which language it found, so if you need that label, it has to come from your own metadata.
Every line comes back as sung
SpicyAPI adds no content filter of its own, so profanity and uncensored lyrics are transcribed rather than masked or bleeped. For rights review, moderation queues and uncensored audio products, that matters: a transcript with holes in it cannot answer the question those workflows were built to ask. The rights to the audio and to the transcript remain yours to hold.
Asynchronous, with a deliberately wide ceiling
Submitting returns a task straight away; the transcript is read back by polling it or by handling the callback you registered. The ceiling is 3,600 seconds from creation to a terminal state, set that wide because queue time alone regularly passes five minutes. A batch of a few hundred tracks therefore goes out from one worker and is collected as results land.

Who HeartMuLa Transcribe is for

Music catalog and metadata teams
Making a back catalog searchable by what it says
Lyric text turns a shelf of audio files into something that can be searched, tagged, matched and displayed. Per-run pricing is what makes a long tail affordable here: the cost of the run is the track count, not the total runtime, so the ten-minute album closer is no more expensive than the interlude before it.
Short-form video and captioning
Getting the words before the timing
Captions over a music bed need the lines first and the timing second. This endpoint hands you the text; a forced-alignment pass against the same audio supplies the timings, because the output carries no line times, no confidence values and no segmentation. That split is worth designing for up front rather than discovering at the caption step.
Trust, safety and rights review
Reading what a track actually says before it ships
A reviewer deciding on a content-rating label or a rights claim needs the words, not a summary and not a redacted version. Because no platform filter is applied, the transcript reflects the recording — which is the only form in which it is useful for that decision. What the transcript does not do is tell you who holds the rights; that check stays yours.
Uncensored audio products
A transcription step that does not refuse the material
Catalogs that a general provider would bounce are transcribed here as recorded. That keeps search, tagging and accessibility features working on the same content the rest of the product is built around, instead of leaving a section of the library with no text at all. Responsibility for the source material and its rights stays with the caller.

How to call the HeartMuLa Transcribe API

Point audio_url at the file, not at a page about it
The URL has to answer with the audio bytes themselves. A signed link with an expiry is fine while it is still valid. A player page, a share link or anything else that answers with HTML fails as an invalid asset before a single line is transcribed. If you are not sure which one you have, fetch the URL yourself once and look at what comes back.
Send the one field with an Idempotency-Key
The body carries audio_url and nothing else. Keep the task id you get back, and send an Idempotency-Key with the request: the key is honoured for 24 hours, so a retry after a dropped connection lands on the same task rather than creating a second, separately billed one.
Poll or take the callback, with timeouts near the ceiling
The endpoint is asynchronous. Poll with a growing interval, or register a callback URL and drop the loop entirely. Leave room up to the 3,600-second ceiling: queue time regularly runs past five minutes, and a client timeout of a minute or two makes a perfectly healthy run look dead.
Read the text off the task and copy it somewhere of your own
The transcript arrives as text on the result, so there is nothing to download and nothing appears in media storage. It is erased on the same schedule as prompt text, which means your store is the durable copy, not ours. Write it next to the track id at the moment the task reaches a terminal state.
Screen the batch before you run it
An instrumental returns little or nothing, and that run still reached a successful terminal state, so it is charged like any other. A vocal-presence check in front of a large batch pays for itself quickly, since a six-second clip and a six-minute track cost the same. Keep the audio short enough to be one work: several tracks stitched into one file come back as one unbroken block of text.

HeartMuLa Transcribe worked examples

A single track from public storage
The minimum viable call: one key, one URL that answers with audio. Nothing else is accepted, and nothing else is needed. The response is a task record; the lyrics arrive in that task's result once it reaches a terminal state.
```
{"audio_url": "https://files.example.com/masters/track-07.mp3"}
```
A private file behind a signed link
Material that is not public works as long as the link itself resolves to the audio while it is valid. Give the signature enough life to cover queue time, which regularly runs past five minutes, rather than the seconds a direct download would need.
```
{"audio_url": "https://storage.example.com/takes/session-04.wav?X-Amz-Expires=3600&X-Amz-Signature=2f9c1a"}
```
A back catalog run over a worklist
Because a request is one field, a batch is a loop over a list of URLs with an Idempotency-Key per row. Each row settles on its own, so a single failed row is retried without rerunning the set, and the cost of the whole run is the row count times the per-transcription price rather than the total runtime of the catalog.