Modal sells GPU and CPU seconds for apps you deploy. Their public Whisper example runs OpenAI Whisper Large V3 with dynamic batching on an A10-class GPU and bills the hardware clock — not a published dollars-per-audio-minute SKU. The pricing page (checked November 2, 2026) lists Nvidia A10 at $0.000306/sec (~$1.10/hr), L4 at $0.000222/sec (~$0.80/hr), and T4 at $0.000164/sec (~$0.59/hr), among other GPUs.
The LecSync Realtime Speech API is a managed WebSocket for live meeting and lecture captions: preview and final text, translation between any two of 60 languages, a speaker and audio-aligned timestamps on every final segment, and running minutes. It costs $0.006 per audio minute ($0.36 per hour) with those features included.
Figures below were checked on November 2, 2026 against Modal’s pricing page, GPU guide, Whisper batching example, Modal’s llms.txt, and the LecSync developers page. Modal does not publish a Whisper $/audio-minute rate, so any $/min or 1,000-hour conversion below is labeled Estimated with the RTF assumption stated.
What is Modal Whisper vs a realtime caption API?
Modal Whisper here means a self-serve GPU app: you deploy Whisper (the docs example uses openai/whisper-large-v3 with @modal.batched on gpu="a10g") and pay Modal’s public GPU $/sec while containers run. A realtime caption API such as LecSync keeps one managed socket open for live bilingual captions, speakers and minutes while people talk, billing accepted audio duration. Modal is infrastructure for ASR you operate — not a packaged live bilingual caption product.
The short answer
If you want control of Whisper Large V3 on rented GPUs — pick A10/L4/T4 from a public rate card, batch files for throughput, fine-tune or swap models in your own image — Modal fits. You write the app; Modal meters GPU seconds. Starter plans show $30/month free credits plus pay-per-second compute.
If you need live bilingual captions + speakers + digest on one flat minute bill, LecSync is the closer product. A Modal Whisper container is not a managed live-caption WebSocket with any-to-any translation, speakers and minutes packaged into $0.006 per audio minute.
How each path works
LecSync. Your server calls POST https://api.lecsync.com/v1/realtime/connect with the audio format, a language pair and the features you want, then streams 16 kHz mono PCM. Preview text arrives while someone is still talking; a final segment settles once the sentence confirms. Translations share the segment ID. With speakers: true, each final carries a speaker and startMs/endMs on the recording clock. With digest: true, minutes arrive section by section. The first word shows up about 0.28 seconds after speech starts; translation adds roughly 88 ms. Seven gateway regions (dal, jp3, kc, nj, ru2, ru3, uk) keep audio near the capture point; backlog is capped at 2 seconds.
Modal Whisper (self-serve). Deploy a Modal Function or class with a GPU (T4, L4, A10, A100, H100, and others listed in the GPU guide). The official batched Whisper example loads Whisper Large V3 from Hugging Face, runs on gpu="a10g", and uses dynamic batching (max_batch_size up to 64 in the sample) to raise throughput — the write-up cites about a 2.8× gain on A10G for batched chunks/samples versus unbatched inference. You map over dataset or file audio; cold starts, concurrency and your code own the latency story. Modal also publishes other audio examples (fine-tune Whisper, Kyutai STT streaming), but none of those replace a managed any-to-any caption socket with speakers and digest on a flat audio-minute bill.
Pricing: published GPU seconds vs audio minutes
| Path | Published figure (Nov 2, 2026) | What you actually buy |
|---|---|---|
| LecSync Realtime Speech API | $0.006 / audio minute all-in | Accepted audio duration; STT + MT + speakers + digest |
| Modal Nvidia A10 | $0.000306 / sec (~$1.10 / hr) | GPU seconds while your container runs |
| Modal Nvidia L4 | $0.000222 / sec (~$0.80 / hr) | GPU seconds |
| Modal Nvidia T4 | $0.000164 / sec (~$0.59 / hr) | GPU seconds |
| Modal Whisper $/audio-min | Not published | You convert from GPU seconds × RTF |
Estimated audio-minute conversions (assumptions stated): Modal publishes no Whisper $/audio-minute. Any $/audio-min or 1,000-hour figure is Estimated from GPU-seconds × real-time factor (RTF):
- Batch faster than realtime on A10 (example RTF 0.1): Est. ~$0.00184 / audio-min; 1,000 audio hours → ~100 GPU hours → Est. ~$110 at ~$1.10/hr list — before cold starts, retries, CPU, egress or idle time you leave running.
- Near-realtime coverage on A10 (example RTF 1.0): Est. ~$0.0184 / audio-min; 1,000 audio hours → Est. ~$1,102.
- L4 / T4 list math follows the same pattern at ~$0.80/hr and ~$0.59/hr; lower list rates still buy same-language ASR you assemble, not live MT + speakers + digest.
LecSync stays $0.006/min whether translation, speakers and digest are on or off → 1,000 audio hours = $360.
Nearby GPU-metered Whisper posts (different vendors): Replicate openai/whisper, Hugging Face Inference Endpoints Whisper. Self-host without a cloud GPU invoice: Whisper.cpp.
Side-by-side facts (checked November 2, 2026)
| LecSync Realtime Speech API | Modal Whisper (self-serve GPU) | |
|---|---|---|
| Primary job | Live meeting/lecture captions + MT | Deploy Whisper (or other ASR) on Modal GPUs |
| Price model | $0.006/audio-min flat, all features | Public GPU $/sec (A10/L4/T4…); no Whisper $/audio-min |
| Delivery | Managed WebSocket, preview→final | Your Function/class; example is batched file/dataset ASR |
| Live any-to-any text MT | 60 languages, same socket | Build yourself (Whisper translate → English only upstream) |
| Speakers on live stream | Every final (speakers: true) | Not packaged; add diarization in your app |
| Live minutes / digest | digest: true | Build yourself after transcripts return |
| Languages | 60, auto-detected | Whatever Whisper checkpoint / pipeline you load |
| Latency story | ~0.28 s first word; +~88 ms MT | Cold start + your batch/wait_ms tuning; example cites ~2.8× batch throughput on A10G |
| Regions | 7 gateways; 2 s backlog cap | Modal-managed GPU capacity for your app |
| Model control | Managed stack | Full: swap models, fine-tune, batching, GPU type |
What 1,000 hours cost (Estimated where labeled)
| Workload | LecSync | Modal Whisper app |
|---|---|---|
| Same-language file / batch transcripts | Live API is not the cheapest file path | Estimated from GPU seconds × RTF; often cheap when GPU work is short |
| Continuous live caption coverage | $360 for 1,000 audio hours | DIY streaming stack on GPUs you size; not the docs’ batch example |
| Translated live captions (arbitrary pair) | $360 | Whisper English-only translate + separate MT you operate |
| Speakers + timestamps during live session | Included | Separate pipeline in your Modal app |
| Live minutes | Included | Post-process with your own summarizer |
| Predictable all-in $/audio-min for captions + MT + speakers | Yes ($0.006) | No published audio-minute SKU |
For flat-vs-add-on vendor math, see what 1,000 hours cost once translation, speakers and summaries are added. For stitching STT + MT yourself, see built-in translation vs a DIY pipeline.
When Modal Whisper wins
- Self-serve Whisper Large V3 on a public A10/L4/T4 rate card you can quote in a design doc.
- High-throughput batch or dataset jobs where dynamic batching (Modal’s example ~2.8× on A10G) keeps GPU seconds short.
- Custom images — fine-tune Whisper, pin revisions, mix Kyutai or other ASR in the same workspace.
- GPU-second budgeting with Starter $30/month credits and scale-to-zero containers when idle.
- Same-language transcripts only, when you will own MT, speakers and minutes as separate services.
When LecSync fits better
- Translated live captions on one socket — any pair of 60 languages, each translation tied to its segment.
- Speakers and recording-aligned timestamps during the live stream — meeting client with speakers and timestamps.
- Live minutes while the session runs (
digest: true) — live digest vs post-call summarization. - Predictable $0.006/audio-minute billing with no Estimated RTF math for the caption stack.
- Classroom / mixed-language lecture feeds that must keep captions current as the speaker switches languages.
Category winners
| Category | Winner | Why |
|---|---|---|
| Cheap self-serve Whisper batch on public GPU $/sec | Modal | A10/L4/T4 list rates; batch RTF can beat $0.006/min for same-language ASR |
| Published $/audio-min for live captions | LecSync | Flat $0.006 all-in |
| Live any-to-any captions + speakers + digest | LecSync | One WebSocket, one minute bill |
| Transparent public GPU list rate | Modal | e.g. A10 $0.000306/sec on pricing |
| Managed first-word latency for live captions | LecSync | Public ~0.28 s / +~88 ms MT |
| Full control of Whisper weights and batching | Modal | Your image, your @modal.batched tuning |
FAQ
Does Modal publish a Whisper price per audio minute?
No. Modal bills GPU and CPU seconds. The pricing page lists Nvidia A10 at $0.000306/sec (~$1.10/hr), L4 at $0.000222/sec (~$0.80/hr), and T4 at $0.000164/sec (~$0.59/hr). The Whisper docs example is an app you run on those GPUs. Any $/audio-minute number is Estimated from GPU-seconds and an RTF assumption.
How does A10 ~$1.10/hr compare to LecSync’s $0.006 per audio minute?
They meter different things. LecSync charges accepted audio minutes. Modal charges GPU seconds for the containers you run. At an example RTF of 0.1 on A10, Est. effective cost can land near $0.00184/audio-min — still same-language ASR without live MT, speakers or digest. At RTF 1.0, Est. ~$0.0184/audio-min. Label both Estimated.
Is Modal’s Whisper example a live caption WebSocket?
No. The batched Whisper example maps over dataset/file audio with dynamic batching for throughput. That is a strong pattern for batch ASR. It is not a managed microphone WebSocket with preview→final bilingual captions, speakers and digest for meetings or lectures.
Does a Modal Whisper app include speaker labels and live minutes?
Not out of the box. You load Whisper (or another model) and return whatever your pipeline emits. Managed live speaker labels like LecSync’s speakers: true and sectioned digest minutes are product features on LecSync’s socket — on Modal you add diarization and summarization yourself.
When should a live-caption product still use Modal?
Use Modal when the heavy work is batch or custom Whisper billed as GPU seconds, or when you need to fine-tune and host your own ASR stack. For a managed realtime speech API at $0.006 per audio minute with translation, speakers and digest on one socket, start from the LecSync developers page.
Final verdict
Pick Modal for self-serve Whisper on a clear public GPU rate card and batch throughput you control. Pick LecSync when the product is live bilingual captions with speakers and minutes at $0.006 per audio minute ($360 per 1,000 hours) without Estimated RTF math. Try the API on the developers page.