Speech Recognition (ASR)

Run the entire FunASR pipeline on a single 24GB card

Q: How much VRAM does FunASR actually need? Is an 8GB card enough?

For the SenseVoiceSmall route, far more than enough: 470MB of f16 weights for the main model plus fsmn-vad at 0.4M, ct-punc at 290M and cam++ at 7.2M means the whole pipeline is under 2GB, so 8GB handles batch transcription with room to spare. For Fun-ASR-Nano 800M served through vLLM, start at 8GB and be comfortable at 16GB; Qwen3-ASR 1.7B wants 12GB or more. On NexGPU those tiers map from RTX 3090 24GB ($0.193/GPU-hour) up to RTX 5090 32GB ($0.723/GPU-hour) — rent one for an hour, measure your real footprint, then decide what to run long-term.

Q: FunASR or Whisper — how big is the difference for Chinese?

For Chinese, FunASR wins clearly. SenseVoiceSmall hits 7.81% CER and processes 10 seconds of audio in about 70ms, which the project reports as 15x faster than Whisper-Large, and it emits emotion and audio-event labels for free. The bigger practical gap is diarization: Whisper needs pyannote bolted on, while FunASR's cam++ is a first-class pipeline component. Whisper's advantages are long-tail language breadth and ecosystem maturity. To benchmark both on your own audio, spin up one RTX 3090 24GB on NexGPU, install both stacks, and you'll have an answer for under twenty cents an hour.

Q: SenseVoiceSmall only takes 30-second segments — what about an hour-long recording?

That is exactly what fsmn-vad is for. Pass vad_model="fsmn-vad" into AutoModel and it segments long audio at speech boundaries, recognises each chunk, and merges the results — you never touch the 30-second limit in your own code. v1.4.3 also adds an optional Silero VAD adapter with configurable thresholds and millisecond-precision segments, which cuts more cleanly in noisy recordings. The parameter that actually governs throughput is batch_size_s, and NexGPU's per-second billing means you can iterate on it and shut the box down the moment you've tuned it.

Q: Can Fun-ASR-Nano run on CPU? What if I have no GPU at all?

Fun-ASR-Nano requires a GPU — the project explicitly steers CPU users to SenseVoiceSmall instead. SenseVoiceSmall does 17x realtime on CPU and has a llama.cpp path: download the GGUF weights (q8 is only 254MB) and run a standalone binary with no Python runtime at all, with optional CUDA and Vulkan backends and direct SRT output. Be honest about the gap though — 17x on CPU versus 170x on GPU is a full order of magnitude. For any real batch job, an RTX 3090 24GB on NexGPU at $0.193/GPU-hour beats waiting nine times longer.

Q: FunASR errors out or silently falls back to CPU on an RTX 5090. What's going on?

This is the most common trap right now: the official Windows CUDA prebuilds target compute capability 8.6 (Ampere), while RTX 50-series is sm120, so you either get an error or a silent CPU fallback unless you rebuild from source. The path of least resistance is Linux with PyTorch cu128 or newer. NexGPU's RTX 5090 32GB ($0.723/GPU-hour) runs Linux images, so picking a recent PyTorch environment from the 2,000+ prebuilt images sidesteps the whole problem. Unsure which image? Ask us on Telegram — bilingual support, no ticket queue.

Q: Can I use FunASR commercially? What's the licence?

The toolkit source is MIT, so commercial use is unobstructed. Model weights are licensed separately, governed per model card under the FunASR model open-source licence agreement, so Fun-ASR-Nano, SenseVoiceSmall, Paraformer and the rest each need checking before you ship. That separation is a large part of why teams self-host rather than call a cloud API — the audio never leaves machines they control. NexGPU spans 51 countries and regions with 1,175 verified rentable nodes, so you can place the deployment in whatever region your data rules require, and compute billing stops as soon as the instance does.

VAD, recognition, punctuation, speaker diarization, emotion and audio-event detection — under 2GB of weights combined. What costs money isn't VRAM, it's how many hours of audio you push through.

FunASR · self-hosted

FunASR isn't one model, it's an industrial-grade speech toolchain maintained by ModelScope, Alibaba's open-source arm. As of v1.4.3 it chains fsmn-vad endpointing, the ASR model, ct-punc punctuation restoration, cam++ speaker diarization, plus emotion and audio-event detection into a single AutoModel pipeline. The contrast with the Whisper route is concrete: Whisper needs pyannote bolted on for diarization, while FunASR's speaker model is a native component you attach with one spk_model argument.

Anyone searching for FunASR's VRAM requirement gets an answer that feels too small for this era. SenseVoiceSmall is 234M parameters, and the three files in the official GGUF repo weigh exactly 936MB (fp32), 470MB (f16) and 254MB (q8). Its companions are tiny too: fsmn-vad is 0.4M parameters, cam++ is 7.2M, and even the heaviest, ct-punc, is 290M. The whole pipeline totals under 2GB — a Tesla T4 holds it comfortably. The bottleneck was never capacity; it's throughput, concurrent streams, and how you segment long audio.

What genuinely needs a real GPU resident is the new LLM-style ASR line. Fun-ASR-Nano pairs a SenseVoice encoder with a Qwen3 decoder at 800M parameters and hits a claimed 340x realtime under vLLM at 8.20% Chinese CER; Fun-ASR-MLT-Nano is the same size across 31 languages; Qwen3-ASR at 1.7B stretches to 52 languages. Those are the ones worth planning VRAM around. On NexGPU an RTX 3090 24GB starts at $0.193/GPU-hour, metered per second — stop the instance when the transcription job finishes and compute billing stops with it.

01 —

The FunASR v1.4.3 model zoo: which one you actually want

Parameter counts, real on-disk weight sizes and what each variant is for — don't port your Whisper instincts over unchanged

Version	Parameters	VRAM	Context	Notes
Fun-ASR-Nano	800M	bf16 weights ~1.6GB / ≥ 8GB recommended under vLLM	Long audio fed in via fsmn-vad segments	Hybrid architecture: SenseVoice encoder plus a Qwen3 decoder. Chinese, English, Japanese and dialects. Official benchmark: 8.20% Chinese CER, 340x realtime with vLLM batching. GPU required — there is no supported CPU-only path.
Fun-ASR-MLT-Nano	800M	bf16 weights ~1.6GB / ≥ 8GB recommended under vLLM	Same, VAD-segmented	The multilingual sibling, covering 31 languages. Pick it for cross-border support desks, multilingual subtitling or international meeting notes; for pure Chinese work the original Nano is more accurate.
Qwen3-ASR	1.7B	bf16 weights ~3.4GB / ≥ 12GB recommended in service	52 languages	The broadest language coverage in the zoo. This is the model for a single 'throw any language at it' endpoint; the trade-off is higher per-request latency than non-autoregressive models like SenseVoice.
SenseVoiceSmall	234M	fp32 936MB / f16 470MB / q8 GGUF 254MB	≤ 30 s per segment; long audio needs VAD	The value pick. 7.81% Chinese CER — lower than Fun-ASR-Nano — at 170x realtime on GPU and still 17x realtime on CPU. Emits emotion labels and audio events (applause, laughter, coughing, sneezing) alongside text. Trained on 400,000+ hours; roughly 70ms to process 10 seconds of audio.
Paraformer-zh / Paraformer-zh-streaming	220M	fp16 weights ~440MB	Streaming chunk is configurable; ~600ms latency typical	Non-autoregressive: it emits the whole utterance in parallel and carries word-level timestamps natively. 10.18% Chinese CER, 120x realtime on GPU. For live captioning or contact-centre QA where text must appear while someone is still talking, the streaming variant is the only right answer in FunASR.
Pipeline components: fsmn-vad / ct-punc / cam++	0.4M / 290M / 7.2M	< 1GB combined at fp16	Resident alongside the main model	Endpoint detection, Chinese/English punctuation restoration and speaker clustering respectively. v1.4.3 adds an optional Silero VAD adapter with configurable thresholds and millisecond-precision segments, and improves diarization clustering when the speaker count is known.

02 —

GPU selection: don't rent an H100 for an ASR service

Choose by concurrency and total audio volume. NexGPU list rates below, metered per second, no minimum

Offline batch transcription, SenseVoiceSmall full pipeline (VAD + ASR + punctuation + speakers)
RTX 3090 24GB$0.193/GPU-hour
Ampere sm86 has full fp16 tensor cores and is the cheapest card on the fleet that runs FunASR properly — after under 2GB of weights, 24GB leaves plenty of room for batch_size_s=300 long-form batching.
Fun-ASR-Nano 800M behind vLLM, serving an OpenAI-compatible transcription API
RTX 4090 24GB$0.540/GPU-hour
Ada prefill is noticeably faster than the 3090, and setting vLLM's gpu-memory-utilization to 0.85 leaves roughly 19GB of KV cache — enough to absorb dozens of concurrent transcription requests.
Qwen3-ASR 1.7B multilingual service with the post-processing chain resident too
RTX 5090 32GB$0.723/GPU-hour
32GB fits the 1.7B model alongside punctuation and speaker models. Note Blackwell is sm120 while the official Windows prebuilds only target sm86 — on Linux use PyTorch cu128 or newer or you will silently fall back to CPU.
Ten-thousand-hour archive transcription, several models and workers in parallel
A100 PCIE 80GB$0.824/GPU-hour
80GB holds Fun-ASR-Nano, Qwen3-ASR and the whole post-processing chain on one card with batches wide open — one card behaving like a transcription cluster, which makes cost per audio-hour the lowest of the lot.

03 —

Four steps to a running FunASR on NexGPU

From instance to OpenAI-compatible endpoint over SSH or Jupyter — no quota request required

01
Launch an instance on a PyTorch or vLLM image and install funasr
At console.nexgpu.net pick an RTX 3090 24GB and choose a PyTorch or vLLM environment from the 2,000+ prebuilt images — CUDA and drivers are already in place. SSH in and one pip finishes the job. The toolkit source is MIT; model weights are licensed separately per model card.
```
pip install torch torchaudio && pip install -U funasr
```
02
Chain VAD, ASR, punctuation and speakers with AutoModel
AutoModel is the core API. Pass vad_model, punc_model and spk_model together and it handles long-audio segmentation, per-segment recognition, punctuation restoration and speaker clustering for you. batch_size_s=300 groups roughly 300 seconds of audio per batch and is the main throughput knob for long-form work.
```
from funasr import AutoModel
model = AutoModel(model="iic/SenseVoiceSmall", vad_model="fsmn-vad", punc_model="ct-punc", spk_model="cam++", device="cuda")
print(model.generate(input="audio.wav", batch_size_s=300))
```
03
Serve an OpenAI-compatible transcription endpoint with funasr-server
v1.4.x ships funasr-server, which exposes OpenAI-style speech-to-text HTTP endpoints and can run Fun-ASR-Nano on a vLLM backend. Client code needs no changes — just repoint base_url. For live use cases, switch to the WebSocket service backed by Paraformer-zh-streaming instead.
```
pip install vllm fastapi uvicorn python-multipart && funasr-server --device cuda
```
04
Batch out subtitles, timestamps and speaker labels
The CLI takes globs for batch work: --spk turns on diarization, --timestamps emits word-level timing, and --output-format accepts json or srt. Since v1.4.2 punctuation-aware sentence alignment preserves subtitle segmentation, so the SRT that comes out needs no manual re-breaking.
```
funasr *.wav --spk --timestamps --output-format srt
```

Real arithmetic: transcribing 1,000 hours of meeting audio

Say you need 1,000 hours of Chinese meeting recordings turned into punctuated, speaker-labelled text. SenseVoiceSmall is rated at 170x realtime on GPU, but end-to-end throughput drops once VAD, punctuation and speaker clustering are attached — budget conservatively at 100x realtime: 1,000 ÷ 100 = 10 GPU-hours. On an RTX 3090 24GB that is 10 × $0.193 = $1.93 of compute. The real cost is storage. 16kHz 16-bit mono WAV is 32,000 bytes per second, i.e. 115.2MB per hour, so 1,000 hours = 115.2GB. At NexGPU's median $0.414/GB-month, holding that for a full month is 115.2 × 0.414 = $47.69 — but this job only needs three days: 115.2 × 0.414 × 3 ÷ 30 = $4.77. Egress is a rounding error: 1,000 hours of transcript is roughly 30MB of UTF-8, so 0.03 × $0.0081 ≈ $0.0002. Total: $1.93 + $4.77 ≈ $6.70. One billing rule to internalise — compute billing stops the moment the instance stops, but storage keeps billing until the volume is destroyed. Delete the volume when the run finishes, or that $47.69/month keeps accruing, which is twenty times the compute cost of the entire job.

04 —

FAQ

How much VRAM does FunASR actually need? Is an 8GB card enough?

For the SenseVoiceSmall route, far more than enough: 470MB of f16 weights for the main model plus fsmn-vad at 0.4M, ct-punc at 290M and cam++ at 7.2M means the whole pipeline is under 2GB, so 8GB handles batch transcription with room to spare. For Fun-ASR-Nano 800M served through vLLM, start at 8GB and be comfortable at 16GB; Qwen3-ASR 1.7B wants 12GB or more. On NexGPU those tiers map from RTX 3090 24GB ($0.193/GPU-hour) up to RTX 5090 32GB ($0.723/GPU-hour) — rent one for an hour, measure your real footprint, then decide what to run long-term.

FunASR or Whisper — how big is the difference for Chinese?

For Chinese, FunASR wins clearly. SenseVoiceSmall hits 7.81% CER and processes 10 seconds of audio in about 70ms, which the project reports as 15x faster than Whisper-Large, and it emits emotion and audio-event labels for free. The bigger practical gap is diarization: Whisper needs pyannote bolted on, while FunASR's cam++ is a first-class pipeline component. Whisper's advantages are long-tail language breadth and ecosystem maturity. To benchmark both on your own audio, spin up one RTX 3090 24GB on NexGPU, install both stacks, and you'll have an answer for under twenty cents an hour.

SenseVoiceSmall only takes 30-second segments — what about an hour-long recording?

That is exactly what fsmn-vad is for. Pass vad_model="fsmn-vad" into AutoModel and it segments long audio at speech boundaries, recognises each chunk, and merges the results — you never touch the 30-second limit in your own code. v1.4.3 also adds an optional Silero VAD adapter with configurable thresholds and millisecond-precision segments, which cuts more cleanly in noisy recordings. The parameter that actually governs throughput is batch_size_s, and NexGPU's per-second billing means you can iterate on it and shut the box down the moment you've tuned it.

Can Fun-ASR-Nano run on CPU? What if I have no GPU at all?

Fun-ASR-Nano requires a GPU — the project explicitly steers CPU users to SenseVoiceSmall instead. SenseVoiceSmall does 17x realtime on CPU and has a llama.cpp path: download the GGUF weights (q8 is only 254MB) and run a standalone binary with no Python runtime at all, with optional CUDA and Vulkan backends and direct SRT output. Be honest about the gap though — 17x on CPU versus 170x on GPU is a full order of magnitude. For any real batch job, an RTX 3090 24GB on NexGPU at $0.193/GPU-hour beats waiting nine times longer.

FunASR errors out or silently falls back to CPU on an RTX 5090. What's going on?

This is the most common trap right now: the official Windows CUDA prebuilds target compute capability 8.6 (Ampere), while RTX 50-series is sm120, so you either get an error or a silent CPU fallback unless you rebuild from source. The path of least resistance is Linux with PyTorch cu128 or newer. NexGPU's RTX 5090 32GB ($0.723/GPU-hour) runs Linux images, so picking a recent PyTorch environment from the 2,000+ prebuilt images sidesteps the whole problem. Unsure which image? Ask us on Telegram — bilingual support, no ticket queue.

Can I use FunASR commercially? What's the licence?

The toolkit source is MIT, so commercial use is unobstructed. Model weights are licensed separately, governed per model card under the FunASR model open-source licence agreement, so Fun-ASR-Nano, SenseVoiceSmall, Paraformer and the rest each need checking before you ship. That separation is a large part of why teams self-host rather than call a cloud API — the audio never leaves machines they control. NexGPU spans 51 countries and regions with 1,175 verified rentable nodes, so you can place the deployment in whatever region your data rules require, and compute billing stops as soon as the instance does.

Start building on NexGPU

Enterprise R&D team or solo developer — either way, your first job can be running in minutes.