rishikanthc/Scriberr: Self-Hosted AI Audio Transcription with Privacy

rishikanthc/Scriberr: Self-Hosted AI Audio Transcription with Privacy

Developers, researchers, and privacy-conscious teams increasingly need to convert speech to text without shipping sensitive audio to cloud providers. Subscription costs add up—$100 to $240 per year for consumer devices like the Plaud Note—and the privacy trade-offs are unacceptable for many use cases. rishikanthc/Scriberr addresses this directly: an open-source, fully offline audio transcription application designed for self-hosters who refuse to compromise on data sovereignty.

With rishikanthc/Scriberr, you run state-of-the-art speech recognition models locally, keep everything on your own hardware, and pay nothing beyond your existing infrastructure costs. The project has accumulated 2,839 GitHub stars and 221 forks, with an MIT license and Go as its primary language. This article breaks down what Scriberr offers, how to deploy it, and where it fits in the broader transcription tooling landscape.

What is rishikanthc/Scriberr?

Scriberr is a self-hosted audio and video transcription application built by Rishikanth Chandrasekaran, an ML/AI researcher with over a decade of programming experience. The project emerged from a specific frustration: consumer voice recorders that lock transcription behind cloud services and recurring subscriptions. Chandrasekaran purchased a Plaud Note, appreciated the hardware, but rejected the $100–$240/year cloud transcription model on both privacy and cost grounds.

The result is a Go-based application (last commit dated 2026-06-01) that leverages multiple ML backends: NVIDIA Parakeet, Canary, and the widely-deployed OpenAI Whisper models. Scriberr delivers word-level timing, speaker diarization, and LLM-powered transcript analysis—all without network egress for your audio data.

The project is currently in a maintenance period. Chandrasekaran was affected by eBay layoffs (approximately 800 roles impacted) and has paused active development to focus on employment. However, the project is explicitly not abandoned—the maintainer remains open to community contributions and plans to return. This context matters for production adoption decisions: the codebase is stable and functional, but feature velocity depends on community involvement for now.

Scriberr's relevance is timely. Regulatory pressure on data processing (GDPR, HIPAA-adjacent concerns, corporate data residency policies) makes local-first tools increasingly attractive. The project's MIT license removes commercial friction, and its Docker^{↗ Bright Coding Blog}-first deployment model fits standard DevOps^{↗ Bright Coding Blog} workflows.

Key Features

Local Model Execution: Scriberr runs transcription models entirely on your hardware. Supported engines include Whisper (the familiar default), NVIDIA Parakeet, and Canary. This eliminates cloud API latency, ongoing per-minute costs, and data exposure risks.

Speaker Diarization: The application automatically detects distinct speakers and labels utterances by speaker. This uses PyAnnote and NVIDIA NeMo models, with configuration required post-installation via the Configuration page.

LLM Integration for Transcript Analysis: Scriberr connects to Ollama or any OpenAI API-compatible provider for post-transcription workflows. Users can generate summaries, ask questions about content, or conduct conversational exploration of transcripts within the application interface.

Workflow Automation Support: A Folder Watcher automatically processes new files dropped into monitored directories. Combined with extensive REST APIs, this enables integration with automation platforms like n8n without custom scripting.

Built-in Recording and Annotation: The application includes an audio recorder for immediate capture and integrated note-taking with timestamped highlights. Users can annotate transcripts while listening, creating structured output from raw audio.

Progressive Web App (PWA): Scriberr installs as a PWA on desktop and mobile, providing native-app-like experience without platform store dependencies. The interface supports dark mode and is explicitly designed for responsiveness across screen sizes.

Dual Deployment Paths: Homebrew installation for macOS/Linux users seeking simplicity, and Docker (CPU or CUDA-optimized) for containerized deployments with GPU acceleration.

Use Cases

Private Meeting Documentation: Legal, medical, and financial professionals often cannot legally or ethically upload client conversations to third-party services. Scriberr keeps transcription local, with speaker labels and searchable transcripts replacing manual note-taking.

Research Interview Processing: Academic researchers conducting sensitive interviews (human subjects research, whistleblower accounts, political fieldwork) gain verbatim transcripts with speaker identification without institutional review board complications around cloud data processing.

Personal Knowledge Management: The Plaud Note-inspired origin story reflects a genuine use case: capturing ideas, conversations, and readings for later retrieval. The LLM integration enables semantic search and summarization across a growing personal audio archive.

Automated Content Pipeline: The Folder Watcher and API enable hands-off processing. A podcast producer, for example, could drop raw recordings into a watched folder and automatically receive transcripts, summaries, and highlight clips suitable for show notes or social media^{↗ Bright Coding Blog} promotion.

On-Premises Enterprise Deployment: Organizations with strict data residency requirements—government contractors, defense-adjacent work, certain EU entities—can deploy Scriberr without vendor security reviews or data processing agreements.

Installation & Setup

Scriberr offers three installation paths: Homebrew for simplicity, Docker for standard deployments, and Docker with CUDA for GPU-accelerated transcription.

Homebrew (macOS and Linux)

The fastest path for individual developers:

# Add the Scriberr tap
brew tap rishikanthc/scriberr

# Install Scriberr (automatically installs UV dependency)
brew install scriberr

# Start the server
scriberr

Navigate to http://localhost:8080 after startup. The UV dependency mentioned is a Python^{↗ Bright Coding Blog} package installer, required for managing the Python ML environments Scriberr orchestrates.

Docker (CPU)

Create docker-compose.yml:

services:
  scriberr:
    image: ghcr.io/rishikanthc/scriberr:v1.2.0
    ports:
      - "8080:8080"
    volumes:
      - scriberr_data:/app/data        # Application data: DB, uploads, transcripts
      - env_data:/app/whisperx-env      # Python environments and downloaded models
    environment:
      - PUID=${PUID:-1000}
      - PGID=${PGID:-1000}
      - APP_ENV=production             # Required; do not change
      # - ALLOWED_ORIGINS=https://your-domain.com  # Production CORS setting
      # - SECURE_COOKIES=false         # Uncomment ONLY for HTTP (non-SSL) access
    restart: unless-stopped

volumes:
  scriberr_data: {}
  env_data: {}

Launch with:

docker compose up -d

Docker with NVIDIA GPU (CUDA)

Requires NVIDIA Container Toolkit pre-installed. Create docker-compose.cuda.yml:

services:
  scriberr:
    image: ghcr.io/rishikanthc/scriberr-cuda:v1.2.0
    ports:
      - "8080:8080"
    volumes:
      - scriberr_data:/app/data
      - env_data:/app/whisperx-env
    restart: unless-stopped
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities:
                - gpu
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
      - NVIDIA_DRIVER_CAPABILITIES=compute,utility
      - PUID=${PUID:-1000}
      - PGID=${PGID:-1000}
      - APP_ENV=production
      # - ALLOWED_ORIGINS=https://your-domain.com
      # - SECURE_COOKIES=false

volumes:
  scriberr_data: {}
  env_data: {}

Launch with:

docker compose -f docker-compose.cuda.yml up -d

Critical first-run behavior: Initial startup takes several minutes as Scriberr initializes Python environments and downloads ML models (Whisper, PyAnnote, NVIDIA NeMo). Subsequent starts are fast. Monitor logs for the msg="Scriberr is ready" url=http://0.0.0.0:8080 confirmation.

GPU compatibility note: RTX 50-series (Blackwell, sm_120) requires a separate image:

docker compose -f docker-compose.blackwell.yml up -d

The standard CUDA image fails on Blackwell due to PyTorch CUDA version constraints.

Real Code Examples

Environment Configuration

For Homebrew or manual deployments, create a .env file in the binary's directory:

# Server settings
HOST=localhost
PORT=8080
APP_ENV=production

# Paths
DATABASE_PATH=/var/lib/scriberr/data/scriberr.db
UPLOAD_DIR=/var/lib/scriberr/data/uploads

# Security
JWT_SECRET=your-super-secret-key-change-this

Docker users typically configure via docker-compose.yml environment variables instead. The JWT_SECRET auto-generates if omitted, but explicit configuration enables stateless container restarts without session invalidation.

Volume Migration (v1.1.0 to v1.2.0)

Upgraders must split data from model environments:

volumes:
  - /path/to/existing/data:/app/data        # Contains scriberr.db, jwt_secret, transcripts/, uploads/
  - /new/empty/folder:/app/whisperx-env      # Must be fresh; delete any old whisperx-env first

The separation prevents Python environment corruption across application updates. The README emphasizes this as CRITICAL—old environments cause compatibility errors.

Permissions Fix for SQLite Errors

When encountering SQLITE_CANTOPEN (misleadingly labeled "out of memory"):

# For named volumes
sudo chown -R 1000:1000 /var/lib/docker/volumes/scriberr_scriberr_data/_data

# For bind mounts
sudo chown -R 1000:1000 ./scriberr_data
sudo chown -R 1000:1000 ./env_data

Match the UID/GID to your PUID/PGID values (default 1000). This resolves the temporary file creation failure underlying the SQLite error.

Advanced Usage & Best Practices

Secure Cookies and Reverse Proxies: The most common post-installation issue is "Unable to load audio stream" caused by SECURE_COOKIES=true (default in production) blocking HTTP requests. The robust solution is terminating TLS at a reverse proxy (Nginx, Caddy, Traefik) rather than disabling cookie security. If you must use HTTP internally, set SECURE_COOKIES=false explicitly.

Model Selection Strategy: Whisper models offer broad compatibility and proven quality. NVIDIA Parakeet and Canary may provide superior accuracy for specific domains (English conversational, meeting transcription) but require compatible hardware and larger downloads. Evaluate on representative samples before committing to a model for batch processing.

Diarization Configuration: Speaker identification requires explicit setup post-installation. Visit the Configuration page rather than expecting automatic operation. This involves model downloads and potentially Hugging Face authentication tokens for gated models.

Backup Strategy: The SQLite database and uploaded files reside in /app/data (or your bind mount). Include this path in standard backup routines. The /app/whisperx-env path contains reproducible model downloads—backup optional, though re-downloading costs time.

Community Contribution Opportunity: Given the maintainer's temporary unavailability, production users should assess their capacity to contribute patches or fork for critical fixes. The MIT license permits either approach without legal friction.

Comparison with Alternatives

Whisper API offers lowest friction for occasional use but fails on privacy and ongoing cost. faster-whisper is a library, not an application—requires building UI, API, and workflow integrations from scratch. Otter.ai and similar SaaS tools compete on collaboration features but sacrifice data control.

Scriberr's niche is the complete self-hosted application: not merely a model wrapper, but a usable system with UI, API, automation hooks, and LLM integration. The trade-off is operational responsibility—you maintain the deployment, handle upgrades, and currently face uncertain feature velocity.

FAQ

What hardware is required for GPU acceleration? NVIDIA GPUs from GTX 10-series (Pascal) through RTX 40-series use the standard CUDA image. RTX 50-series requires the Blackwell-specific image due to PyTorch compatibility.

Does Scriberr work without a GPU? Yes. The CPU deployment path functions on any Docker-capable system, though transcription speed decreases significantly for longer files.

What languages does it support? The README does not specify language coverage explicitly. Whisper models support multiple languages; Parakeet and Canary are primarily English-optimized. Verify specific language needs against model documentation.

Is the project actively maintained? Development is temporarily paused due to the maintainer's employment situation. The project is explicitly not abandoned, and community contributions are welcomed.

Can I use cloud LLMs with Scriberr? Yes. The OpenAI API integration accepts any compatible endpoint, including OpenAI's services, Azure OpenAI, or self-hosted alternatives via base URL configuration.

What database does it use? SQLite, with configurable path via DATABASE_PATH environment variable.

Is commercial use permitted? Yes. The MIT license imposes no commercial restrictions.

Conclusion

rishikanthc/Scriberr fills a genuine gap for teams and individuals who need capable audio transcription without cloud dependency. Its combination of local ML execution, speaker diarization, LLM integration, and practical workflow features (Folder Watcher, PWA, REST API) distinguishes it from both raw libraries and subscription SaaS products.

The project is best suited for: privacy-sensitive environments, cost-conscious high-volume users, self-hosting enthusiasts with existing infrastructure, and organizations with data residency requirements. The current maintenance pause is a material consideration—evaluate whether the existing feature set meets your needs, or whether you can contribute to sustain development.

For installation, documentation, and source code, visit https://github.com/rishikanthc/Scriberr. The project website and API reference provide additional guidance for deployment and integration.

This article was prepared based on the rishikanthc/Scriberr README and repository metadata as of the last commit (2026-06-01). For the latest status, consult the GitHub repository directly.