A speech transcription bill looks like it depends only on how long the audio is, but the real total often comes from more factors adding up: useless silence, high-bitrate files, failed retries, splitting overlap, duplicate submissions, retained storage, and manual proofreading after transcription.

This article does not quote fixed unit prices, because prices change and different models and gateways use different billing rules. What matters more is understanding the billing structure and the cost drivers. For specific unit prices, refer to on-site model pricing.

Note: OpenAI and Whisper are trademarks of their respective owners. This article is for technical explanation only and has no affiliation with OpenAI. Billing units, available regions, and limits for each model may change; refer to the official documentation and the on-site pricing page. This article contains no specific quotes.

1. The basic billing unit is audio duration

The classic whisper-1 model bills by the number of minutes of submitted audio. Newer gpt-4o-transcribe models bill by audio input and output tokens, and the pricing page usually also provides an equivalent per-minute estimate; pricing for newer models such as gpt-transcribe is still evolving.

Whether billing is by minute or by token, the basis is the length of the audio you submit, not the length of speech that is actually useful. Intro and outro segments, long silences, and breaks in the middle of a meeting can all be billed. The first principle of cost control is to trim unnecessary sound before uploading.

2. How file size and format affect the bill

The official API has a 25 MB per-file limit and supports mp3, mp4, mpeg, mpga, m4a, wav, and webm. The size limit affects cost indirectly:

  • High-bitrate wav files are large, long audio is more likely to exceed the limit, and more splitting is required.
  • The larger the file, the slower the upload, and the higher the chance of timeouts and retries.
  • Incompatible formats fail outright, wasting requests and troubleshooting time.
  • Transcoding is usually not billed by the API, but it consumes server and storage resources.

Converting everything to 16 kHz mono mp3 or wav usually shrinks the file significantly at acceptable quality. Before compressing, confirm that the business can tolerate the quality loss; for dialects and proper nouns, keep a higher bitrate.

3. Operations that quietly inflate costs

Cost item Enters the API bill? How to control it
Audio duration Yes Remove silence, trim intro and outro, submit only useful segments
Failed retries May be billed twice Cap retries and record request results
Splitting overlap Yes, overlapping audio is transcribed twice Keep overlap at 0.5–1 second and deduplicate when merging
Transcoding and storage Usually not in the API bill Set lifecycle rules and clean up promptly
Egress traffic Depends on provider and architecture Process in the same region and avoid repeated downloads
Manual proofreading Not in the API bill Sample checks, glossary replacement, tiered review

The most common waste is not the unit price but duplicated work: the same audio submitted three times because of a timeout, or an entire recording transcribed again just to obtain timestamps.

4. Retries, timeouts, and duplicate billing

A network timeout does not mean the server did not process the request. If a request was billed but the client never received the result, a retry creates a second charge. Engineering teams should do three things:

  1. Use a file hash or business order number as an idempotency key, and store successful results for reuse.
  2. Cap the maximum number of retries, for example at three, and use exponential backoff.
  3. Retry only on 429, 5xx, and timeouts; retrying errors such as 400, 401, and 413 is pointless.

Batch jobs also need sensible connection and read timeouts. Too short a timeout kills normal long audio; too long a timeout blocks the queue.

5. Long-audio splitting and concurrency strategy

Audio over 25 MB must be split. The finer the split, the more requests; the coarser the split, the more expensive a failed retry. Process it in this order:

  1. Use ffprobe to measure the duration and bitrate of each file and estimate total minutes first.
  2. Transcode uniformly to 16 kHz mono to control the size of each segment.
  3. Prefer splitting at silence, then fall back to fixed 10-minute segments.
  4. Record each segment's offset and restore the timeline when merging.
  5. Keep concurrency within the account's rate limits, and adjust after watching the 429 rate.
  6. Deduplicate after merging and sample-check the cut points.
  7. Compare the actual submitted minutes with the bill to find anomalies.

Concurrency does not change the per-unit price, but it affects the retry rate and total duration. Maxing out concurrency causes many 429 responses, and the added backoff retries usually cost more than running steadily.

6. Storage and egress are easy to overlook

Audio files, transcription results, logs, and backups all incur storage costs, and audio is the largest. A sensible tiered approach:

  • Raw audio: keep a traceable retention window after transcription, then delete it or move it to cold storage.
  • Transcribed text: store by project, encrypt sensitive content, and restrict access.
  • Request logs: do not record full audio URLs or keys; keep the necessary request IDs.
  • Backups: back up results only, not the original audio again.

If audio and transcription services are not in the same region, uploads and downloads generate egress traffic. Keeping the processing pipeline closer to storage reduces this cost.

7. How to estimate a budget

Do not multiply a guessed unit price by total duration. A more reliable formula is:

Monthly cost ≈ useful audio minutes × unit price × retry factor + storage and traffic + manual proofreading

The retry factor can be estimated from actual monitoring data; if the request success rate is 97%, leave headroom for the failed portion. The script below reads only duration and a unit price and does not hard-code prices:

import os, subprocess, json

UNIT_PRICE = float(os.environ["AUDIO_UNIT_PRICE"])  # from the pricing page, per minute
files = ["meeting-01.mp3", "meeting-02.mp3"]
total_minutes = 0.0

for path in files:
    out = subprocess.check_output([
        "ffprobe", "-v", "error", "-show_entries", "format=duration",
        "-of", "json", path,
    ])
    total_minutes += float(json.loads(out)["format"]["duration"]) / 60

estimate = total_minutes * UNIT_PRICE * 1.1  # allow for retries and overlap
print(f"Audio {total_minutes:.1f} minutes, estimated {estimate:.2f}")

The budget should also include storage, transcoding servers, manual proofreading, and development maintenance. Comparing only API unit prices tends to underestimate total cost of ownership.

8. Reconciliation and price tracking after launch

  1. Split usage by project or key so all business lines do not share one bill.
  2. Export usage once a week and compare it with the audio minutes submitted internally.
  3. Investigate projects whose difference exceeds a threshold: duplicate submissions, abnormal retries, wrong splitting parameters.
  4. Set budget alerts so you can act before usage approaches the cap.
  5. Watch for model and price updates, and compare quality and cost on real samples before switching.

Prices change and models change. Keep unit prices in configuration instead of hard-coding them; when prices change, update the configuration and rerun the estimate.

Frequently asked questions

Is Whisper API billed by minute or by token?

whisper-1 is billed by audio minute; newer gpt-4o-transcribe models bill by audio input and output tokens, and the pricing page provides an equivalent per-minute estimate. Refer to on-site model pricing and the official documentation.

Is silence billed?

Billing is usually based on the length of submitted audio, so silence may be included. Trimming silence before upload is the most direct cost-control measure.

Do failed retries cost extra?

If the server already processed the request and only the client timed out, a retry may create a second charge. Use idempotency keys to reuse successful results and cap the number of retries.

Does higher concurrency save money?

It does not change the unit price and does not necessarily reduce total cost. Excessive concurrency triggers 429 responses, and retries and queueing add both time and cost.

Why does this article not quote specific prices?

Audio model prices change frequently, and different gateways use different billing rules. Hard-coded numbers go stale easily; estimating from the on-site pricing page is more reliable.

Next steps

Register for the ZSQH AI Gateway, run a short audio clip through transcription, and build a budget after measuring real minutes. Models and the latest prices are subject to model pricing.

Related reading: