---
title: "Transcribe audio over 25 MB with an API - split and stitch"
description: "How to transcribe recordings over a speech-to-text API file limit: shrink the file, split at silences with ffmpeg, send chunks in parallel and stitch the text."
url: https://broadrouter.com/blog/transcribe-long-audio-files-api/
lang: en
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

# Transcribe long audio over 25 MB: split, send and stitch

By the BroadNet Inference team · 6 min read · Published 2026-11-15

Most transcription APIs reject one file over about 25 MB. Convert the recording to 16 kHz mono first: that alone fits about 13 minutes of WAV or 54 minutes of 64 kbit/s MP3 into BroadNet's 26,214,400-byte limit. For longer audio, split at silences with ffmpeg, transcribe the chunks in parallel and join the text in order.

## Key takeaways

-   The limit is bytes, not minutes. 16 kHz mono WAV is 32,000 bytes a second, so 26,214,400 bytes is about 13.6 minutes; 64 kbit/s MP3 is about 54 minutes.
-   Split by time at a silence, never at a byte offset. A byte cut breaks the audio frames, and a mid-word cut loses words.
-   Keep chunks well under the limit, such as 10 minutes of WAV, so one noisy file never returns 413.
-   Send chunks in parallel up to the key's limit: 4 requests in flight and 30 a minute on a BroadNet pay-as-you-go key.
-   Splitting does not change the audio length you pay for. One hour of Arabic costs $0.25 on BroadNet Transcribe Arabic.

**On this page**

1.  Why does a long recording fail?
2.  Step 1: how do you shrink the file?
3.  Step 2: how do you split audio without cutting words?
4.  What does the full script look like?
5.  How many chunks can you send at once?
6.  Do you need overlap between chunks?
7.  Can the next chunk use the previous chunk’s text as context?
8.  What does a long file cost?
9.  What mistakes should you avoid?
10.  When is chunking the wrong tool?
11.  Where BroadNet Inference fits

Most speech-to-text APIs take one file of about 25 MB per request. BroadNet Inference takes WAV or MP3 up to 26,214,400 bytes. A long meeting, lecture or podcast blows past that, and the request fails with 413. The fix has four steps: shrink the file, split it at silences, send the pieces in parallel, and stitch the text back together.

## Why does a long recording fail?

The limit is on bytes, not on minutes. How many minutes fit depends on the format:

| Format | Bytes per second | Fits in 26,214,400 bytes |
| --- | --- | --- |
| WAV, 44.1 kHz stereo, 16-bit | 176,400 | About 2.5 minutes |
| WAV, 16 kHz mono, 16-bit | 32,000 | About 13.6 minutes |
| MP3, 64 kbit/s | 8,000 | About 54 minutes |
| MP3, 32 kbit/s | 4,000 | About 109 minutes |

These are simple sums: bytes per second times seconds. A phone or laptop recording is often 44.1 or 48 kHz stereo, which fills the limit in a few minutes. Speech does not need that. Converting to 16 kHz mono first is the biggest single win.

When a file is still too large, the API rejects it outright. On BroadNet the response is 413, “the request exceeds the endpoint byte or text limit”, and nothing is transcribed. See the [error code guide](https://broadrouter.com/guides/errors-and-retries/).

## Step 1: how do you shrink the file?

Convert to 16 kHz mono before anything else. One ffmpeg command does it:

```bash
ffmpeg -i meeting.m4a -ac 1 -ar 16000 meeting.wav
```

For BroadNet, the output must be WAV (`audio/wav`) or MP3 (`audio/mpeg`). Formats such as `.m4a`, `.ogg` and `.webm` need converting anyway, so do the resampling in the same step.

Should you pick WAV or MP3? WAV is lossless, so nothing is lost, but it fills the limit in about 13 minutes. MP3 fits four times more audio per request at 64 kbit/s, but it is lossy. If you use MP3, run a short test: transcribe the same five minutes as WAV and as MP3 and compare the text. The [sample rate](https://broadrouter.com/glossary/sample-rate/) entry explains why 16 kHz is enough for speech.

## Step 2: how do you split audio without cutting words?

Split by time, never by bytes. A cut at a byte offset can land in the middle of an audio frame, and the file will not decode. A cut at a fixed time can land in the middle of a word. OpenAI’s own guide warns against splitting mid-sentence because it “can remove context and reduce accuracy”.

The reliable method is to cut inside a silence near your target length. To get ready-made commands for your file size and duration, use the free [audio splitter command builder](https://broadrouter.com/tools/audio-splitter-ffmpeg/). By hand, it works like this:

1.  Run ffmpeg’s [silencedetect](https://ffmpeg.org/ffmpeg-filters.html) filter to list the silent gaps.
2.  Walk through the recording. When a chunk reaches about 10 minutes, cut at the next silence.
3.  Cut each chunk with ffmpeg, from one cut point to the next.

Ten minutes of 16 kHz mono WAV is 19.2 MB, which leaves room under the limit. If a speaker talks for a long time without a pause, the script below cuts at the hard maximum instead.

ffmpeg’s [segment muxer](https://ffmpeg.org/ffmpeg-formats.html) can also split a file into pieces “of nearly fixed duration” with one command. It is quick, but it does not look for silence, so use it only when a lost word at each boundary is acceptable, or add overlap (below).

## What does the full script look like?

This Python script converts, splits at silences, sends up to four chunks at once and joins the text. It uses the OpenAI SDK pointed at BroadNet Inference.

```python
# pip install openai
import os, re, subprocess, tempfile
from concurrent.futures import ThreadPoolExecutor
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
TARGET, HARD_MAX = 600, 750   # seconds: aim for 10 min, never above 12.5 min

def run(*args):
    return subprocess.run(args, capture_output=True, text=True, check=True)

def silences(path):
    """Midpoints (in seconds) of silent gaps of 0.5 s or more."""
    out = run("ffmpeg", "-i", path, "-af", "silencedetect=noise=-35dB:d=0.5",
              "-f", "null", "-").stderr
    starts = [float(x) for x in re.findall(r"silence_start: ([\d.]+)", out)]
    ends = [float(x) for x in re.findall(r"silence_end: ([\d.]+)", out)]
    return [(s + e) / 2 for s, e in zip(starts, ends)]

def duration(path):
    return float(run("ffprobe", "-v", "error", "-show_entries", "format=duration",
                     "-of", "csv=p=0", path).stdout)

def cut_points(path):
    total, gaps, cuts, last = duration(path), silences(path), [0.0], 0.0
    while total - last > HARD_MAX:
        ok = [g for g in gaps if last + TARGET <= g <= last + HARD_MAX]
        last = ok[0] if ok else last + HARD_MAX   # no silence: hard cut
        cuts.append(last)
    return cuts + [total]

def transcribe(chunk):
    with open(chunk, "rb") as f:
        return client.audio.transcriptions.create(
            model="broadnet/cohere-transcribe-arabic", file=f, language="ar").text

def transcribe_long(src):
    with tempfile.TemporaryDirectory() as tmp:
        wav = os.path.join(tmp, "full.wav")
        run("ffmpeg", "-y", "-i", src, "-ac", "1", "-ar", "16000", wav)
        cuts, chunks = cut_points(wav), []
        for i, (a, b) in enumerate(zip(cuts, cuts[1:])):
            out = os.path.join(tmp, f"part{i:03d}.wav")
            run("ffmpeg", "-y", "-i", wav, "-ss", str(a), "-to", str(b), out)
            chunks.append(out)
        with ThreadPoolExecutor(max_workers=4) as pool:   # map() keeps order
            return "\n".join(pool.map(transcribe, chunks))

print(transcribe_long("meeting.m4a"))
```

Notes on the script:

-   **Language.** BroadNet’s docs say to always send `language`; without it, Arabic “can otherwise be transliterated into Latin letters”. Use `broadnet/cohere-transcribe` with the right language code for English, French or any of its other [supported languages](https://broadrouter.com/blog/multilingual-speech-to-text-api/).
-   **Thresholds.** `-35dB` and `0.5` seconds suit a quiet room. Noisy rooms need a higher noise value, such as `-30dB`. Print the cut points once and check them.
-   **Order.** `pool.map` returns results in input order, so the text joins in the right sequence even though chunks finish at different times.

## How many chunks can you send at once?

As many as your key allows. A BroadNet pay-as-you-go key allows 4 requests in flight and 30 requests a minute, which is why the script uses four workers. A fifth request at the same time gets 429. Retry 429 and 5xx responses with exponential backoff; do not retry 413, because the same file will fail again. [How to handle 429 errors](https://broadrouter.com/blog/handle-llm-api-429-rate-limits/) has a retry helper you can wrap around `transcribe()`.

With four workers, a two-hour recording in 10-minute chunks becomes 12 requests in three waves. Total time is roughly three chunk round-trips, not twelve.

## Do you need overlap between chunks?

Not if you cut inside silences: there is no speech at the boundary to lose. Overlap is for fixed-time cuts. Start each chunk a second or two before the previous one ended, then remove the repeated words when you join the text. The usual way is to compare the last few words of one chunk with the first few of the next and drop the match.

Overlap costs a little. Two seconds per 10-minute chunk adds about 0.3% to the audio you pay for.

## Can the next chunk use the previous chunk’s text as context?

Some APIs allow it. OpenAI lists “carrying context from a previous chunk of a longer recording” as a use of its `prompt` parameter. BroadNet’s API reference lists only `model`, `language` and `file` for transcription, and returns JSON with a `text` field. So on BroadNet, treat each chunk as independent, and fix names and terms afterwards. One cheap fix is to send the joined transcript to a chat model with a list of correct spellings for people, products and places.

## What does a long file cost?

Speech to text bills per audio minute, so splitting does not change the total. At BroadNet’s published rates:

| Audio | BroadNet Transcribe Arabic | BroadNet Transcribe (14 languages) |
| --- | --- | --- |
| Price per minute | $0.0042 | $0.002 |
| One hour | $0.25 | $0.12 |
| 1,000 hours | $252.00 | $120.00 |

The pricing page lists a price per audio minute and says nothing about a per-file minimum or rounding. Check your usage page after the first batch to confirm the total matches the audio length. Both transcription models are available on the free starting credit of $5, which covers about 1,190 minutes of Arabic. To price your own volume, use the [speech-to-text cost calculator](https://broadrouter.com/tools/speech-to-text-cost-calculator/); to compare providers, see the [speech-to-text API price dataset](https://broadrouter.com/data/speech-to-text-api-prices/).

## What mistakes should you avoid?

-   **Sending the original file.** A 48 kHz stereo WAV is six times bigger than it needs to be.
-   **Cutting at byte offsets.** The chunk will not decode, or the first second will be noise.
-   **Chunks right at the limit.** A 25.9 MB chunk passes today and fails when a recording is a little louder. Leave headroom.
-   **Unbounded parallelism.** Firing 50 chunks at once gets most of them a 429. Cap workers at the key’s in-flight limit.
-   **Forgetting the language.** Each chunk is a separate request, so each one needs `language`.

## When is chunking the wrong tool?

If you need speaker labels or word timestamps, chunking a plain-text API will not give them to you. BroadNet’s transcription response is text only. Providers that return [diarization](https://broadrouter.com/glossary/diarization/) and [timestamps](https://broadrouter.com/glossary/timestamps-asr/) also handle long files more directly; the [Arabic speech-to-text buyer’s guide](https://broadrouter.com/blog/arabic-speech-to-text-api-buyers-guide/) compares them. For stereo call recordings, split by channel instead of by time: the [call center pipeline](https://broadrouter.com/blog/transcribe-call-center-recordings/) shows how.

## Where BroadNet Inference fits

BroadNet Transcribe Arabic is priced at $0.0042 a minute, and BroadNet reports it #2 of 37 (its September 2026 figure; the live board listed it #4 of 39 on 15 November 2026) on the [Open Universal Arabic ASR Leaderboard](https://huggingface.co/spaces/elmresearchcenter/open_universal_arabic_asr_leaderboard). Audio and transcripts are not retained after the request. It suits batch transcription of long Arabic recordings once you split them as above. It does not suit you if you need timestamps, speaker labels or live streaming in the same API. The [Arabic speech-to-text guide](https://broadrouter.com/guides/arabic-speech-to-text-api/) covers the first request; this post covers the files that are too big for one.

Free tools for this

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[All free tools](https://broadrouter.com/tools/)

## Terms in this article

[Speech-to-text](https://broadrouter.com/glossary/speech-to-text/)

Speech-to-text, also called automatic speech recognition (ASR), is technology that converts spoken audio into written text. A speech-to-text API accepts an audio file or stream and returns a transcript, usually priced per minute of audio. Accuracy is measured with word error rate and varies with accent, dialect and recording quality.

[WAV](https://broadrouter.com/glossary/wav/)

WAV (Waveform Audio File Format, or WAVE) is an audio container built on Microsoft and IBM's RIFF format. It usually holds uncompressed linear PCM samples, so its size is predictable: sample rate times bytes per sample times channels, per second.

[Pay-as-you-go](https://broadrouter.com/glossary/pay-as-you-go/)

Pay-as-you-go is a pricing model in which you pay only for what you use, metered per unit such as tokens, requests or audio minutes, with no subscription or minimum commitment. Most LLM APIs bill this way, from a prepaid balance or a periodic invoice.

[Speaker diarization](https://broadrouter.com/glossary/diarization/)

Speaker diarization is the task of dividing an audio recording into segments by speaker, answering "who spoke when". It labels each stretch of speech with an anonymous speaker ID such as SPEAKER\_00, and is usually combined with a transcript to show which person said each line.

[Tool calling](https://broadrouter.com/glossary/tool-calling/)

Tool calling, also called function calling, is an LLM API feature in which the model returns a structured request to run a function the developer has defined, with JSON arguments. The application runs the function and sends the result back; the model never runs code itself.

[Concurrency](https://broadrouter.com/glossary/concurrency/)

Concurrency is the number of requests a client has in flight at the same time. LLM APIs often cap it per key or plan, separately from requests per minute, because each open request holds GPU capacity until its response has finished.

[Exponential backoff](https://broadrouter.com/glossary/exponential-backoff/)

Exponential backoff is a retry strategy in which a client waits longer after each failed attempt, typically doubling the delay up to a cap, before trying again. Adding random jitter to each wait spreads out retries from many clients so they do not hit the server at the same moment.

[Rate limit](https://broadrouter.com/glossary/rate-limit/)

A rate limit is a cap an API places on how much a client can use it in a time window, such as requests per minute or tokens per minute. Requests over the limit are refused, usually with HTTP 429 Too Many Requests, until usage falls back under it.

## Questions

### How do I transcribe an audio file larger than 25 MB?

First convert it to 16 kHz mono, which often brings it under the limit. If it is still too big, split it into chunks of about 10 minutes at silent points with ffmpeg, transcribe each chunk with the same language setting, and join the texts in order.

### How many minutes of audio fit in 25 MB?

It depends on the format. 16 kHz mono 16-bit WAV uses 32,000 bytes a second, so 26,214,400 bytes holds about 13.6 minutes. MP3 at 64 kbit/s holds about 54 minutes. Stereo or 44.1 kHz WAV holds much less.

### What happens if I upload a file over the limit?

The request is rejected. BroadNet Inference returns 413, which its docs define as a request that exceeds the endpoint byte or text limit. Nothing is transcribed, so split and resend.

### Do I lose words at the chunk boundaries?

You can, if you cut at a fixed time in the middle of speech. Cut inside a silence instead. If you must cut at a fixed time, overlap chunks by a second or two and remove the repeated words when you join them.

### Does splitting a file cost more?

You pay for audio minutes, so the total length is the same. BroadNet's pricing page lists a price per audio minute and does not mention a per-file minimum or rounding; check the usage page after your first batch to confirm.

### Can I send the previous chunk's text as context?

Some APIs take a prompt for that; OpenAI lists carrying context from a previous chunk as a use of its prompt parameter. BroadNet's docs list only model, language and file, so do not rely on a prompt there.

## Keep reading

-   [How to transcribe call center recordings: an Arabic-ready pipeline](https://broadrouter.com/blog/transcribe-call-center-recordings/)
-   [Multilingual speech-to-text API: 14 languages, one endpoint](https://broadrouter.com/blog/multilingual-speech-to-text-api/)
-   [Arabic speech-to-text API: how to choose one in 2026](https://broadrouter.com/blog/arabic-speech-to-text-api-buyers-guide/)
-   [Whisper API alternative: when to switch, and how to test one](https://broadrouter.com/blog/whisper-api-alternative/)
-   [Speech-to-text API pricing compared: price per minute in 2026](https://broadrouter.com/blog/speech-to-text-api-pricing-compared/)
-   [Arabic subtitles (SRT) from a speech-to-text API: what you need](https://broadrouter.com/blog/arabic-subtitles-srt-api/)
-   [Record audio in the browser and send it to a speech-to-text API](https://broadrouter.com/blog/record-browser-audio-transcription-api/)
-   [Translate Arabic audio to English text with an API: a tested pipeline](https://broadrouter.com/blog/translate-arabic-audio-to-english/)
-   [A private endpoint starts with a clear workload](https://broadrouter.com/blog/private-endpoint-planning/)
-   [Before fine-tuning: define the problem to solve](https://broadrouter.com/blog/fine-tuning-readiness/)
-   [Guide: Arabic speech-to-text API, step by step](https://broadrouter.com/guides/arabic-speech-to-text-api/)
-   [Guide: Transcribe WhatsApp voice notes to text with an API](https://broadrouter.com/guides/transcribe-whatsapp-voice-notes/)
-   [Guide: BroadNet Inference error codes and when to retry](https://broadrouter.com/guides/errors-and-retries/)

Try it on your real workload. New accounts start with $5 of credit for Gemma and transcription. DeepSeek, GLM and Qwen3.8 need a top-up.

[Get started](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-transcribe-long-audio-files-api&utm_content=page-cta) ·

**Sources**

-   [BroadNet Inference API reference: WAV or MP3 up to 26,214,400 bytes, language field, 413 and 429 errors, pay-as-you-go limits (checked 2026-11-15)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-transcribe-long-audio-files-api&utm_content=sources)
-   [BroadNet Inference pricing page, transcription price per audio minute (checked 2026-11-15)](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-transcribe-long-audio-files-api&utm_content=sources)
-   [OpenAI speech to text guide: 25 MB file limit, split into chunks, avoid splitting mid-sentence (checked 2026-11-15)](https://developers.openai.com/api/docs/guides/speech-to-text)
-   [FFmpeg formats documentation, segment muxer (checked 2026-11-15)](https://ffmpeg.org/ffmpeg-formats.html)
-   [Open Universal Arabic ASR Leaderboard on Hugging Face (BroadNet's reported rank; checked by BroadRouter 2026-11-15)](https://huggingface.co/spaces/elmresearchcenter/open_universal_arabic_asr_leaderboard)
-   [FFmpeg filters documentation, silencedetect (checked 2026-11-15)](https://ffmpeg.org/ffmpeg-filters.html)
