GLM-ASR-Nano-2512: Run 1.5B Speech-to-Text Locally

Last updated October 2026 — refreshed for current Transformers / vLLM versions, the now-published Z.AI hosted price, and current Artificial Analysis Speech-to-Text leaderboard figures.

GLM-ASR-Nano-2512 is Z.AI's (formerly Zhipu) open-source 1.5B-parameter automatic speech recognition (ASR) model, released in December 2025 and now shipping as a first-class architecture in tagged Transformers releases (glmasr is in the library as of v5.18.0) and serveable in vLLM 0.14.1 or newer. This guide gives you the exact, verified commands to install and run it locally, the real 2026 benchmark numbers, and an honest comparison against Whisper Large v3 / v3-turbo, NVIDIA Canary-Qwen 2.5B, Qwen3-ASR, Mistral Voxtral, ElevenLabs Scribe v2, and Google Gemini 3 Pro audio.

What changed in 2026GLM-ASR-Nano-2512 is now an official Hugging Face Transformers architecture (GlmAsr) and has an officially supported vLLM recipe. You no longer have to patch in custom modeling code — and as of October 2026 you no longer have to install Transformers from git either: the glmasr module ships in tagged releases (v5.18.0 is current), so pip install "transformers>=5.18" is enough.The model card publishes Open ASR Leaderboard numbers directly: 7.03 mean WER across the 8-dataset suite at RTFx 145.28 on a single H100. That puts it ahead of Whisper Large v3 (7.4) and Whisper Large v3 Turbo (7.75), behind NVIDIA Canary-Qwen 2.5B (5.63) and IBM Granite Speech 3.3 8B (5.85).The hosted API glm-asr-2512 on api.z.ai caps at 25 MB / 30 seconds per request — useful for short transcription, but for long files the local route is the practical option. Z.AI now publishes the price: GLM-ASR-2512 is $0.03 per million tokens, which Z.AI equates to roughly $0.0024 per minute of audio, on its public pricing page. An earlier version of this guide deliberately omitted a $0.03/Mtok figure because it could not be verified on a public page — it can be now, and it checks out.The license is MIT on Hugging Face (Apache-2.0 in the GitHub repo for the inference scripts) — both permit commercial use, fine-tuning, and redistribution.An MLX 4-bit conversion (mlx-community/GLM-ASR-Nano-2512-4bit) lets you run the model on Apple Silicon at roughly 1.2 GB of unified memory.Real competition on the open-source side now includes Qwen3-ASR (52 languages, 0.6B/1.7B variants), NVIDIA Canary-Qwen 2.5B (top of the Open ASR Leaderboard mean when this guide was written; Artificial Analysis separately measures it at 4.3% AA-WER on its own harness), Mistral Voxtral Small (2.8% AA-WER, AA's most accurate open-weights entry), and Moonshine (27 MB, edge-class).

Want the full picture? Read our continuously-updated Self-Hosting LLMs Complete Guide (2026) — hardware, ollama and vllm, cost-per-token, and when to self-host.

TL;DR

Why GLM-ASR-Nano matters in 2026

The 2026 ASR landscape splits cleanly into three tiers:

• Top-of-leaderboard: per Artificial Analysis's Speech-to-Text leaderboard (captured October 2026), StepAudio 3 ASR and Alibaba's Fun-Realtime-ASR-preview lead at 1.7% AA-WER, followed by Microsoft's MAI-Transcribe-2 at 2.0%, ElevenLabs Scribe v2 at 2.2%, Grok Voice Transcribe 2.0 at 2.3%, Google's Gemini 3.5 Transcribe at 2.6%, and Mistral Voxtral Small at 2.8% — which AA flags as the most accurate open-weights model on its harness. Note that AA's AA-WER is its own three-dataset benchmark and is not interchangeable with the Open ASR Leaderboard mean used further down this page; compare within one metric, never across.
• Open weights, big-model: NVIDIA Canary-Qwen 2.5B (5.63 mean WER), IBM Granite Speech 3.3 8B (5.85). Top of the Open ASR Leaderboard, but 2.5B–8B parameters and not as cheap to serve.
• Open weights, small-model: GLM-ASR-Nano-2512 (1.5B), Whisper Large v3 (1.5B), Whisper Large v3 Turbo, Qwen3-ASR-0.6B/1.7B, Moonshine (27 MB). This is where local inference, batch processing, and edge deployment actually live.

GLM-ASR-Nano sits at the high end of the small-model tier: it ties Whisper Large v3 on parameter count but beats it on the public Open ASR Leaderboard average and pulls ahead on Chinese and Cantonese. If you have to run ASR on your own GPU — for compliance, latency, or cost reasons — and your audio is multilingual, this is still the most defensible default open model at the 1.5B size in late 2026 — with one honest qualifier: if English accuracy is all you care about and you can afford the extra parameters, Artificial Analysis rates Mistral's Voxtral Small (2.8% AA-WER) as the most accurate open-weights option on its harness. GLM-ASR-Nano's case is size, MIT licensing, and Cantonese and dialect coverage, not a clean sweep on English. For an end-to-end agent stack that includes local LLM inference alongside ASR, see our OpenClaw + Ollama setup guide for running local AI agents.

What changed vs the original release notes

The original launch description in late 2025 framed GLM-ASR-Nano as a Llama-based two-stage system with a separate vocoder. That description was lifted from the GLM-TTS companion paper and was misapplied to the ASR model. As of April 2026 the correct picture is:

• GLM-ASR-Nano is a seq2seq audio-conditioned LM, exposed as AutoModelForSeq2SeqLM (or the new GlmAsr class in Transformers main).
• There is no vocoder stage in the ASR model — that is GLM-TTS, a separate release.
• vLLM and SGLang serving are now first-class.

Benchmark numbers you can cite

From the official model card and the Hugging Face Open ASR Leaderboard (BF16, single H100, RTFx 145.28):

Z.AI also reports an internal 4.10 average error rate and 0.0717 CER on its hosted-API evaluation suite, which leans heavier on Mandarin and Cantonese sets (Wenet Meeting, Aishell-1). Those numbers are not directly comparable to the Open ASR Leaderboard mean — different datasets, different metric mix — so cite each in its own context.

Head-to-head against the 2026 field

The models at the top of Artificial Analysis's Speech-to-Text leaderboard (StepAudio 3 ASR and Fun-Realtime-ASR-preview at 1.7% AA-WER, MAI-Transcribe-2 at 2.0%, ElevenLabs Scribe v2 at 2.2%, Gemini 3.5 Transcribe at 2.6%, Voxtral Small at 2.8% — all captured October 2026) are scored on AA's own three-dataset AA-WER metric, not the Open ASR Leaderboard mean in the table above. The two numbers are not interchangeable, so do not read “2.2 beats 7.03” off the page. Most of that list is also hosted and per-minute billed, which makes them poor substitutes if your reason for going local is privacy, cost-at-scale, or air-gap compliance. Voxtral Small is the exception worth evaluating: open weights and AA's most accurate open entry.

Install and run GLM-ASR-Nano locally

Prerequisites

• Linux or macOS, Python 3.10+ (3.11 recommended).
• NVIDIA GPU with ~6 GB free VRAM at BF16, or Apple Silicon with the MLX build, or a recent CPU (slow but works).
• ffmpeg for audio decoding.
• Hugging Face account if you want to push fine-tunes back, otherwise anonymous download is fine.

Option A — Transformers on a CUDA box

The model card still tells you to install Transformers from source, because it has not been updated since April 2026. That is no longer necessary — the glmasr architecture is in tagged releases (v5.18.0 as of October 2026), so PyPI is enough:

python -m venv .venv && source .venv/bin/activate
pip install --upgrade pip
pip install "transformers>=5.18"   # glmasr ships in tagged releases now
pip install torch --index-url https://download.pytorch.org/whl/cu124
pip install datasets soundfile accelerate
sudo apt-get install -y ffmpeg   # or: brew install ffmpeg

Minimal inference script — taken straight from the model card and adapted for a local file:

from transformers import AutoModelForSeq2SeqLM, AutoProcessor

model_id = "zai-org/GLM-ASR-Nano-2512"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForSeq2SeqLM.from_pretrained(
    model_id, dtype="auto", device_map="auto"
)

# audio_path can be a local .wav/.mp3/.flac or an https URL
audio_path = "examples/example_en.wav"
inputs = processor.apply_transcription_request(audio_path)
inputs = inputs.to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, do_sample=False, max_new_tokens=500)
text = processor.batch_decode(
    outputs[:, inputs.input_ids.shape[1]:],
    skip_special_tokens=True,
)
print(text[0])

Option B — vLLM server (recommended for throughput)

Z.AI publishes an official vLLM recipe at docs.vllm.ai/projects/recipes/en/latest/GLM/GLM-ASR.html. Requirements: vllm>=0.14.1 (v0.31.0 is current as of October 2026) and transformers>=5.18.

uv pip install -U "transformers>=5.18"
uv pip install -U "vllm[audio]" --torch-backend auto

vllm serve zai-org/GLM-ASR-Nano-2512

Then transcribe via the standard OpenAI-compatible endpoint:

curl http://localhost:8000/v1/audio/transcriptions \
  -H "Content-Type: multipart/form-data" \
  -F model=zai-org/GLM-ASR-Nano-2512 \
  -F file=@meeting.wav \
  -F max_tokens=500

Option C — Apple Silicon (MLX 4-bit)

For M-series Macs, the community MLX 4-bit conversion fits in roughly 1.2 GB of unified memory:

pip install mlx mlx-lm
huggingface-cli download mlx-community/GLM-ASR-Nano-2512-4bit
# then load with mlx-lm's audio entrypoint per the repo README

Option D — Hosted Z.AI API

If you only need short clips and don't want to manage GPUs:

curl --request POST \
  --url https://api.z.ai/api/paas/v4/audio/transcriptions \
  --header "Authorization: Bearer $ZAI_API_KEY" \
  --header "Content-Type: multipart/form-data" \
  --form model=glm-asr-2512 \
  --form stream=false \
  --form file=@clip.mp3

Hard limits: 25 MB per file, 30 seconds of audio per request. For meeting-length transcription, chunk locally or run the open-weights version on your own box.

How to choose: decision tree

• You have proprietary or regulated audio that cannot leave your infra → run GLM-ASR-Nano-2512 locally via vLLM, or Whisper Large v3 if you specifically need translation.
• You need the absolute lowest WER and English-heavy audio → Mistral Voxtral Small (open weights, 2.8% AA-WER — AA's most accurate open model) or, if hosted is acceptable, StepAudio 3 ASR / Fun-Realtime-ASR-preview at 1.7%, MAI-Transcribe-2 at 2.0%, or ElevenLabs Scribe v2 at 2.2%.
• You need Cantonese, Mandarin, Sichuanese, Min Nan, or Wu → GLM-ASR-Nano-2512 is the strongest open option in 2026.
• You need real-time, sub-second latency on edge / CPU-only → Moonshine, or Whisper Large v3 Turbo with whisper.cpp.
• You only have an M1/M2/M3 Mac → mlx-community/GLM-ASR-Nano-2512-4bit or whisper.cpp via MacWhisper for a GUI.
• You want translation (speech in language A → text in English) → stick with Whisper Large v3 multilingual; GLM-ASR-Nano is transcription-only, and Whisper Turbo dropped translation as well.

Performance tuning on your own GPU

• Batch size: GLM-ASR-Nano supports batched inference natively. On an H100 the model card reports RTFx 145.28; on a 24 GB RTX 4090 expect roughly 60–90× real-time at batch=4.
• Precision: BF16 is the documented default. FP16 works on Ampere; INT8 / 4-bit quantization works via bitsandbytes or the MLX build with a small accuracy hit (~0.3–0.6 absolute WER on LibriSpeech other in our internal smoke tests; verify on your audio).
• Long-form audio: chunk into 30 s windows with a 1–2 s overlap and merge by timestamp. The model itself is trained on segment-level inputs.
• VAD: pair with Silero VAD or WebRTC VAD before sending audio in; it reduces hallucinated tokens on silent regions.

Common pitfalls and troubleshooting

• KeyError: 'glm_asr' when loading the model: your Transformers is too old. The architecture landed in the 5.x line; pip install -U "transformers>=5.18" fixes it. Installing from git main was required in early 2026 and no longer is.
• vLLM rejects the model: confirm vllm>=0.14.1 and that you installed the audio extras: pip install -U "vllm[audio]".
• Garbled output on long audio: you exceeded the model's segment length. Chunk to ≤30 s windows. Hosted API enforces this; the local model degrades silently above ~40 s.
• Cantonese transcribed as Mandarin: pass an explicit language hint via the processor's transcription request — relying on auto-detect is unreliable for the Yue/Mandarin pair on short clips.
• Out-of-memory on a 12 GB card at batch=4: drop to batch=1 or load with load_in_8bit=True; BF16 + KV cache for batched decoding is the dominant cost.
• Slow on CPU: this is expected. CPU inference is ~0.3× real-time. Use whisper.cpp's GGML port for CPU; the GLM-ASR GGML port is still not upstream as of October 2026.
• License confusion: the Hugging Face card says MIT, the GitHub repo says Apache-2.0. Both are permissive and commercially compatible — use whichever covers the artifact you're consuming.

What was removed and why

• The "two-stage Llama + vocoder" architecture description from the original post: that wording came from the GLM-TTS paper (arXiv 2512.14291) and does not describe the ASR model. GLM-ASR-Nano is a seq2seq audio-conditioned LM, not a TTS pipeline.
• The “$0.03/Mtok” pricing claim — restored, October 2026. This was cut in April 2026 because Z.AI did not publish a public price for the hosted ASR endpoint and citing an unverifiable number would have been fabrication. Z.AI's public pricing page now lists GLM-ASR-2512 at $0.03 / MTok, equated to approximately $0.0024 per minute of audio, so the figure is back in with a source behind it.
• "Beats GPT-4 / Whisper on every benchmark"-style claims: replaced with the actual Open ASR Leaderboard table, which shows GLM-ASR-Nano ahead of Whisper Large v3 / Turbo but behind Canary-Qwen 2.5B and Granite Speech 3.3 8B.

Where this fits in a real engineering stack

If you're shipping a product feature on top of GLM-ASR-Nano — voice notes, meeting transcription, voice-driven agents, Cantonese-language customer-service routing — the integration work is small but the decisions around chunking, VAD, language-hinting, and long-audio reconciliation are where most teams burn weeks. Codersera's bench of vetted remote developers includes ML engineers who have built exactly these pipelines. Related practical guides: OpenClaw + Ollama for local agents and our broader engineering blog.

FAQ

Is GLM-ASR-Nano-2512 actually better than Whisper Large v3?

On the public Open ASR Leaderboard mean (7.03 vs ~7.4) and on Mandarin/Cantonese benchmarks, yes. For pure English on noisy real-world audio, the gap is small and either is defensible. For translation (audio in → English text), Whisper still wins because GLM-ASR-Nano is transcription-only.

How much VRAM do I need?

~6 GB at BF16, batch=1. A 12 GB consumer card (RTX 3060 12 GB, RTX 4070) handles batch=4 comfortably. The MLX 4-bit build needs about 1.2 GB of unified memory on Apple Silicon.

Can I use it commercially?

Yes. The Hugging Face model is MIT-licensed; the GitHub inference code is Apache-2.0. Both permit commercial use, modification, and redistribution.

Does it support streaming / real-time transcription?

The released artifact is segment-based (≤30 s chunks). Real-time use means chunking on the client side with a VAD; there is no first-class streaming API as of October 2026. For sub-second-latency live transcription, look at Whisper Large v3 Turbo via whisper.cpp or Moonshine.

Can I fine-tune it on domain data?

Yes. The model exposes the standard Transformers AutoModelForSeq2SeqLM interface, so PEFT/LoRA fine-tuning works out of the box. Z.AI's GitHub repo includes example training scripts, and the MIT license permits redistribution of fine-tunes.

How is this different from GLM-4-Voice?

GLM-4-Voice (October 2024) is an end-to-end speech-to-speech LLM — it takes audio in and produces audio out, suitable for voice agents. GLM-ASR-Nano-2512 (December 2025) is transcription-only: audio in, text out. They are complementary, not competitors.

Should I use the hosted Z.AI API or run locally?

Hosted is fine for short clips (≤30 s, ≤25 MB) where you want zero ops. Run locally if you have long-form audio, regulated data, or want to fine-tune. The vllm serve route gives you an OpenAI-compatible endpoint your existing clients can hit unchanged.

Which languages actually work well?

The model card lists 17 languages with WER ≤ 20%. The strongest tier is Mandarin, Cantonese, English. Solid second tier: Sichuanese, Min Nan, Wu, French, German, Japanese, Korean, Spanish, Arabic. For other languages benchmark on a small sample of your own audio before committing.

References & further reading

• Z.AI — GLM-ASR-Nano-2512 model card on Hugging Face
• zai-org/GLM-ASR — official GitHub repository
• Z.AI Developer Docs — glm-asr-2512 hosted API reference
• vLLM Recipes — GLM-ASR usage guide
• Hugging Face Open ASR Leaderboard
• Artificial Analysis — Speech-to-Text providers leaderboard
• OpenAI Whisper Large v3 Turbo model card
• Northflank — Best open-source speech-to-text models in 2026 (benchmarks)
• r/LocalLLaMA — ongoing community discussion of local ASR setups
• mlx-community/GLM-ASR-Nano-2512-4bit — Apple Silicon build