Run Local Audio Transcription with EchoTranscribe and Whisper

Sending a recording to a hosted transcription service is convenient, but it also creates a data-handling decision. Meeting audio, interviews, research notes, and draft content may be easier to process when the files stay on the computer that owns them.

This tutorial walks through the documented development path for EchoTranscribe, an MIT-licensed desktop application by Fernando Paladini. It combines a Tauri desktop shell, a React and TypeScript frontend, and a local FastAPI backend that loads Whisper models through faster-whisper.

The goal is not to claim that local transcription is automatically more accurate or faster. The useful outcome is a reproducible local workflow: start the backend, open the desktop app, choose a model, transcribe supported audio, inspect timestamps, and export TXT, SRT, or JSON.

TL;DR

Use the stable v0.1.1 release, install the frontend dependencies, start the backend, and then run the Tauri development app in a second terminal.

git clone --branch v0.1.1 https://github.com/paladini/echo-transcribe.git
cd echo-transcribe
npm install

In the first terminal, start the Python backend:

cd src-tauri/backend
python main.py

In the second terminal, from the repository root, start Tauri:

npm run tauri dev

The backend documents its API at http://localhost:8000/docs, and the Tauri window should open the frontend automatically.

Prerequisites

The v0.1.1 README lists these prerequisites:

• Node.js 18 or newer
• Python 3.8 or newer
• Rust for Tauri compilation
• Microsoft Visual Studio C++ Build Tools on Windows
• The Linux system packages documented in the README when developing on Ubuntu or Debian

The project also has macOS setup guidance using Homebrew. Tauri compilation adds platform-specific requirements, so a successful Python installation alone is not enough to build the desktop application.

The backend requirements pin FastAPI 0.104.1, Uvicorn 0.24.0, faster-whisper 0.9.0, Pydantic 2.5.0, and supporting packages. PyTorch and torchaudio are specified as version 2.0.0 or newer. Read the repository's current dependency files before installing if you are working from main instead of the stable tag.

Start the local backend

The README provides a startup script for each platform, but the manual path makes the process easier to inspect. From the repository root, run:

cd src-tauri/backend
python main.py

The backend creates model and temporary directories below ~/.echo-transcribe. It searches ports 8000 through 8004 and writes the selected port to backend_port.txt. When port 8000 is available, the documented API address is http://127.0.0.1:8000.

Before launching the desktop shell, check the backend's health endpoint:

curl http://localhost:8000/health

A healthy response includes status set to healthy. You can also open the generated OpenAPI documentation at http://localhost:8000/docs to inspect the available routes.

The first transcription may take longer because the selected Whisper model is downloaded when it is not already present. The source stores models under the .echo-transcribe/models directory in your home folder.

Launch the Tauri desktop app

Keep the backend terminal running. Open another terminal at the repository root and run the exact command documented for Tauri development:

npm run tauri dev

The Tauri configuration uses http://localhost:1420 as the development URL and starts the Vite frontend with npm run dev. The desktop window is configured with a 1200 by 800 initial size and can be resized.

The application is not a remote client. Its frontend is paired with the backend running on your machine, and the backend's CORS configuration allows the local Vite origin and tauri://localhost. That local arrangement is part of the privacy boundary, but it is not authentication.

Transcribe a file

In the app, select one audio file or a batch. The README documents MP3, WAV, FLAC, M4A, OGG, and WebM input, with a maximum of 10 files selected at once for batch transcription.

Choose one of the models exposed by the backend:

• tiny: 39 MB, faster with lower expected accuracy
• base: 74 MB, a balance between speed and precision
• small: 244 MB, better quality with medium speed
• medium: 769 MB, higher quality with slower processing

These sizes are the values in the tagged source's model metadata, not a benchmark for your machine. Runtime depends on the audio, model, dependency versions, and whether the environment can use an available accelerator.

Leave automatic language detection enabled for a first test, or choose a language manually. The backend first validates the extension and model name. It then writes the upload to a temporary file, loads the selected Whisper model, transcribes with word timestamps enabled, and schedules cleanup of the temporary file.

The result can be reviewed in the interface and exported as TXT, SRT, or JSON. Word-level timestamps are included in the backend response when the transcription model returns them.

Verify the path without transcribing a large recording

Use a short audio file that you are allowed to process. Verify the workflow in this order:

1. Confirm that /health returns a healthy status.
2. Open /models and inspect the four model entries.
3. Start with the tiny or base model to reduce the initial download and wait time.
4. Transcribe a short file in one of the documented formats.
5. Confirm that text and timestamps appear in the result.
6. Export one result as TXT, SRT, or JSON and open the exported file.

The backend also exposes POST /transcribe and POST /transcribe-batch. The interactive Swagger page at /docs is the safest place to inspect the current multipart field names instead of guessing at a curl command. The single-file route accepts an uploaded file, a model, an optional language, and the auto_detect_language flag.

Why the local architecture works

The project separates three responsibilities:

1. Tauri packages the desktop experience and connects the frontend to the local application.
2. React, TypeScript, and Vite provide the interface and development server.
3. FastAPI handles uploads, model loading, transcription, language detection, timestamps, and cleanup.

This separation keeps model execution out of the browser UI. It also makes the backend inspectable through OpenAPI while keeping the default network path on loopback. The model cache avoids downloading the same model for every request, and the temporary directory gives the backend a controlled place to write uploaded audio during processing.

Failure modes and security boundaries

The desktop window cannot load the backend. Check that the Python process is still running and that port 8000 is available. If the backend selected another port, inspect backend_port.txt and the terminal log.

The first request appears stuck. Model loading and download happen before transcription. Check the network connection and backend logs. Do not use a long recording as the first test.

The file is rejected. Confirm that its extension is one of MP3, WAV, FLAC, M4A, OGG, or WebM. The backend validates the suffix, not the contents of every possible container.

The build fails on a platform dependency. Install the platform prerequisites listed by the README, including Rust and the required Linux packages or Windows C++ Build Tools.

You want to expose the API to another machine. Stop and design that boundary first. The current backend allows broad methods and headers for its two local origins, and the repository does not document user authentication, quotas, or a production reverse proxy. Local execution limits where the default app sends data, but it does not turn an unauthenticated API into a safe public service.

You process someone else's recording. Local execution does not replace consent, retention, copyright, or organizational data-handling requirements. Only transcribe audio you are authorized to process.

FAQ

Does EchoTranscribe require a cloud API key?

The documented backend loads Whisper models locally through faster-whisper and downloads missing models to the local model directory. The tutorial does not require a hosted transcription key.

Can I use it without a GPU?

The repository documents model choices and local execution, but it does not promise a particular hardware configuration or processing speed. Start with tiny or base and check the backend logs on your machine.

Is main the same as the release?

No. This tutorial uses the stable v0.1.1 tag. The repository's default branch can change, so pin the tag when you need the commands and model list described here.

Is it ready to expose as a shared service?

That is outside the documented guarantee. Add authentication, request limits, storage controls, logging decisions, and a deliberate network boundary before considering shared access.

Takeaway

EchoTranscribe is a useful pattern for local AI desktop tooling: a Tauri shell, an inspectable FastAPI service, a persistent model directory, and explicit export formats. Pin v0.1.1, verify the health endpoint, test with a short authorized recording, and treat the lack of authentication as a real deployment boundary.

Which local transcription feature would you verify next: speaker separation, stronger export controls, or authenticated access for a small team?

AI assistance disclosure

AI assistance was used to organize this tutorial and review its wording. The release, commands, versions, routes, model names, file paths, limitations, and security notes were checked against the public v0.1.1 repository sources linked above. No performance benchmark or personal usage claim is implied.