Transcribe long audio files: split into 10-minute parts

To transcribe a long recording, such as an hour-long podcast or lecture, split it into parts that fit the transcription API's per-request limit, transcribe each part, then add each part's start time to its word and sentence timestamps so they line up with the full recording. Sume STT 1.0 documents a 10-minute maximum per request and bills $0.01 per audio minute, so an hour of audio takes at least six requests and costs $0.60 before the agent fee.

STT 1.0 is specified in the OpenAPI document behind the Sume API reference, which the API reference docs page names as the source for exact request and response shapes, read on 2026-09-27. The split command follows the FFmpeg Formats Documentation. For one file under 10 minutes, see Speech-to-text API with word timestamps.

Why can't one request transcribe the whole file?

Because 10 minutes is the documented ceiling. What STT 1.0 does with a longer file isn't documented, so plan parts of 10 minutes or less.

How do I split a long audio file?

Split it on your machine, then put each part at a public HTTPS URL that STT 1.0 can fetch. FFmpeg's segment muxer writes “a number of separate files of nearly fixed duration”, and a list file ending in .csv records each part's start and end time in seconds. Ask for a little under 600 seconds, such as 540, to leave headroom.

A fixed-time cut can land in the middle of a word. Check the words on each side of every seam, or cut in pauses by passing your own split points with -segment_times.

If the recording is the audio track of a video already on Sume, run one audio detach per part with a range of 600 seconds or less; sample_rate: 16000 with channels: "mono" is what the docs call the STT shape. Timeline audio split cuts one Sume-hosted audio file into up to 20 ranges in a single job.

ffmpeg -i episode.mp3 -codec copy -map 0 -f segment -segment_time 540 \
  -reset_timestamps 1 -segment_list parts.csv part%03d.mp3

How do I transcribe each part?

Send each part as its own STT 1.0 job with duration_seconds set to that part's length, so the usage reservation matches it. Keep language_code the same for every part, or omit it for auto-detect.

• Derive the Idempotency-Key from the file and the part number. A retry with the same key and body returns the original job instead of billing a second one.
• You can submit every part at once. In current code each STT job takes a generation concurrency slot (which calls take a slot); jobs past your workspace's limit wait as queued, and a submit past the queue answers 429 queue_full.
• Poll GET /v1/jobs/:id/status, then read GET /v1/jobs/:id/result, which answers 409 job_not_completed until the job is done.

curl -X POST https://api.sume.com/v1/stt-1.0/transcribe \
  -H "Authorization: Bearer $SUME_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: episode-42-part-002" \
  -d '{
    "audio_url": "https://example.com/audio/part002.mp3",
    "language_code": "en",
    "duration_seconds": 540,
    "segmentation": { "mode": "sentence" }
  }'

How do I merge the parts into one timestamped transcript?

Shift every time, then join the parts in order. Each result's words[].start and end, and each segments[] start and end, are seconds from the start of that part's audio, not of the whole recording. Add the part's start time: the second column of parts.csv, or the start of the range you cut on Sume.

Sentence segments are gapless within one part, and their index restarts in each part, so renumber after the join. If a seam fell mid-sentence, the last segment of one part and the first of the next can be two halves of one sentence.

// parts: [{ offset, result }] in recording order; offset = part start, in seconds
const shift = (offset) => (t) => ({ ...t, start: t.start + offset, end: t.end + offset });

const words = parts.flatMap(({ offset, result }) => result.words.map(shift(offset)));
const segments = parts
  .flatMap(({ offset, result }) => (result.segments ?? []).map(shift(offset)))
  .map((segment, index) => ({ ...segment, index }));
const text = parts.map(({ result }) => result.text.trim()).join(" ");

How much does it cost to transcribe an hour of audio?

$0.60 at the $0.01 per audio minute STT 1.0 rate on API pricing, plus a 5.5% agent fee by default. Splitting doesn't change the per-minute rate. Sume reserves the estimate at submit, and if the balance can't cover it the submit returns 402 insufficient_credits and no job starts. For many files at once, see Batch transcription API.