AI-powered voice-to-text and translation, right where you type.
Press a shortcut, speak, and the transcript is automatically pasted wherever your cursor is. Need it in another language? Voca translates it on the fly with xAI Grok 4.1 Fast — with a Developer tone that understands your technical jargon.
Stop paying $8/month for transcription apps. Deepgram gives every new account $200 in free credits — that's essentially a lifetime of personal use. And since Voca is fully open-source, your audio never leaves your machine for any third party. You own your data.
- Free forever (practically) — $200 free Deepgram credits covers hundreds of hours of transcription. No subscriptions, no hidden fees.
- Private by design — 100% open-source. Audio is processed through your own API keys. No data collection, no analytics, no third-party servers storing your recordings.
- Blazing fast & accurate — Powered by Deepgram Nova-3, one of the best speech-to-text models available. Supports 35+ languages with automatic language detection.
- Instant translation — Speak in one language, get the translation in another. Powered by xAI Grok 4.1 Fast.
- AI-powered corrections — Developer tone fixes misheard technical jargon (e.g. "reakt" → React, "nahbar" → navbar) and keeps terms like API, middleware, deploy in English.
- Numeric & Planning add-ons — Convert spoken numbers to digits ("two point five" → 2.5) and dictated steps into clean numbered lists.
- Noise suppression — Toggle built-in noise suppression to filter out fans, AC, and traffic. Keep it off in quiet rooms for unaltered voice quality.
- Privacy mode — Enable to keep only the latest transcript. Turning it on deletes all existing transcripts. Audio files are never stored — they're deleted immediately after processing.
- One-shortcut workflow — Press a key, speak, done. The transcript (or translation) lands right where your cursor was.
- macOS & Windows — Works on both platforms out of the box.
Press Right ⌘ (Mac) or Right ⊞ (Win)
↓
Recording overlay appears
(previous app stays focused)
↓
Press shortcut again to stop
↓
Audio → Deepgram Nova-3 / Groq Whisper
↓
Translation enabled? → xAI Grok 4.1 Fast
↓
Transcript (or translation) auto-pasted into your app
- Trigger — Hit the global shortcut from anywhere. A small floating overlay confirms recording has started.
- Speak — Talk naturally. The overlay shows a live waveform and timer.
- Stop — Press the shortcut again (or click the stop button on the overlay).
- Done — The transcript is copied to your clipboard and automatically pasted into whatever app you were using.
All transcripts are also saved locally in MongoDB so you can search and revisit them later.
| Layer | Technology |
|---|---|
| Desktop | Electron 31 + electron-vite |
| Frontend | React 18, Tailwind CSS, Zustand, TanStack Query |
| Backend | Express.js, Mongoose, Multer, express-rate-limit |
| Auth | Google OAuth 2.0, JWT (access + refresh tokens) |
| Billing | Paddle v2 (inline checkout, webhooks) |
| STT | Deepgram Nova-3, Groq Whisper Large v3 Turbo |
| Translation | xAI Grok 4.1 Fast (via Vercel AI SDK) |
| i18n | react-i18next (app, 12 languages), i18next-http-middleware (backend) |
| Database | MongoDB |
| Language | TypeScript (monorepo with pnpm) |
voca/
├── packages/
│ ├── shared/ # TypeScript types, Zod schemas & language constants
│ ├── backend/ # Express API server (port 3100)
│ │ ├── controllers/ # Request handling & response mapping
│ │ ├── services/ # Deepgram, Groq, xAI, auth & billing services
│ │ ├── middleware/ # Auth, billing, rate limiting, multer, error handling
│ │ ├── models/ # Mongoose schemas (Transcript, User)
│ │ └── uploads/ # Ephemeral audio processing (purged on startup)
│ ├── app/ # Electron + React application
│ │ ├── electron/
│ │ │ ├── main/ # App lifecycle, shortcuts, overlay, voca:// protocol
│ │ │ └── preload/ # Secure IPC bridge
│ │ └── src/
│ │ ├── pages/ # Dashboard, History, Settings, Billing & Welcome views
│ │ ├── components/
│ │ ├── hooks/ # useRecorder, useGlobalShortcut, useRecordingOverlay
│ │ ├── stores/ # Zustand stores (auth, navigation, recording state)
│ │ ├── i18n/ # 12-language UI translations (react-i18next)
│ │ └── services/# API calls via Axios
│ └── web/ # Landing page at usevoca.dev (Vite + React SPA)
├── assets/ # Logo and static assets
├── .env.example
├── pnpm-workspace.yaml
└── tsconfig.base.json
- Node.js 18+
- pnpm 8+
- MongoDB running locally (or a remote URI)
- API Key — at least one of:
- Google OAuth — Google Cloud Console — create OAuth 2.0 credentials for authentication
- Translation (optional) — xAI Console — Grok API key for translation
# Clone the repository
git clone https://github.com/emircansahin/voca.git
cd voca
# Install dependencies
pnpm install
# Configure environment
cp .env.example packages/backend/.envEdit packages/backend/.env with your keys:
PORT=3100
MONGODB_URI=mongodb://localhost:27017/voca
GROQ_API_KEY=your_groq_api_key_here
DEEPGRAM_API_KEY=your_deepgram_api_key_here
XAI_API_KEY=your_xai_api_key_here # optional, for translation
JWT_SECRET=your_jwt_secret_min_32_chars_here
GOOGLE_CLIENT_ID=your_google_client_id_here
GOOGLE_CLIENT_SECRET=your_google_client_secret_here
CORS_ORIGIN=http://localhost:5173 # comma-separated origins
PADDLE_API_KEY=your_paddle_api_key_here # Paddle Billing
PADDLE_CLIENT_TOKEN=your_paddle_client_token_here
PADDLE_WEBHOOK_SECRET=your_paddle_webhook_secret_here
PADDLE_PRICE_PRO=pri_xxxxx # Paddle price ID for Pro plan
PADDLE_PRICE_MAX=pri_xxxxx # Paddle price ID for Max plan
PADDLE_SANDBOX=true # true for sandbox, false for productionBefore launching the app on macOS, you need to grant Accessibility permission so the app can register global shortcuts and simulate paste. Run:
# This opens System Settings → Privacy & Security → Accessibility
open "x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility"Add your terminal (or the Electron app) to the allowed list. The app also has a built-in Setup screen that guides you through Microphone and Accessibility permissions on first launch.
# Start both backend & app
pnpm dev
# Or start individually
pnpm dev:backend # Express API on port 3100
pnpm dev:app # Electron apppnpm buildVoca supports 35+ languages with automatic detection. Some highlights:
English, Turkish, German, French, Spanish, Portuguese, Japanese, Korean, Chinese, Arabic, Russian, Italian, Dutch, Polish, Hindi, Swedish, Norwegian, Danish, Finnish, Czech, Thai, Vietnamese, and more.
Deepgram's Nova-3 model excels at multilingual detection — it can identify and transcribe the language automatically without any manual selection.
| Provider | Model | Speed | Cost | Best For |
|---|---|---|---|---|
| Deepgram | Nova-3 | Very Fast | $0.0077/min | Accuracy, multilingual, smart formatting |
| Groq | Whisper Large v3 Turbo | Fast | $0.111/hr | Budget-friendly alternative |
You can switch between providers in the app at any time.
Voca can automatically translate your transcriptions using xAI Grok 4.1 Fast. Enable it in Settings, pick a target language, and choose a tone:
| Tone | What it does |
|---|---|
| Developer (default) | Keeps technical terms in English (component, API, deploy, middleware). Fixes misheard jargon from STT (e.g. "nahbar" → navbar, "reakt" → React). |
| Personal | General-purpose translation with natural phrasing. |
Two optional formatting checkboxes are available when translation is enabled:
| Option | What it does |
|---|---|
| Numeric | Converts spoken numbers to digits ("two point five" → 2.5, "one hundred fifty" → 150). |
| Planning | Formats numbered lists with line breaks (dictate "first … second …" and get a clean 1. 2. 3. list). |
These options work even when the source and target language are the same — useful for reformatting speech without translating.
When translation is active, the shortcut-paste workflow sends the translated text directly. In History, you can toggle between original and translated text on each card. Token usage (input/output/cached) is displayed per transcript.
Translation is fully optional — it requires a free Google AI Studio API key and can be toggled on/off at any time.
| Feature | Pro ($3/mo) | Max ($10/mo) |
|---|---|---|
| Monthly free credits | $3 | $10 |
| Groq & Deepgram transcription | Yes | Yes |
| AI-enhanced tone & translation | Yes | Yes |
| Numeric & Planning add-ons | Yes | Yes |
| Max audio upload | 10 MB | 25 MB |
Both plans include all AI features — tone-aware translation (Developer / Personal), Numeric formatting (spoken numbers → digits), and Planning mode (dictated lists → clean numbered output). Credits are deducted based on real API usage (STT + translation + 25% markup), so light users get months of value from a single plan.
- Zero audio retention — Audio files are deleted immediately after transcription. The server never stores recordings on disk beyond the processing window. On startup, the uploads directory is purged to catch any leftovers.
- Privacy mode — Optional setting that keeps only the most recent transcript. Enabling it deletes all existing transcripts. Each new transcription automatically removes the previous one.
- Authentication — Google OAuth 2.0 with JWT access tokens (15min) and refresh tokens (7 days)
- Rate Limiting — IP-based limits: 60 req/min global, 10 req/min for auth and transcription endpoints
- Input Validation — Zod schemas for all inputs,
LANGUAGE_CODESenum for language fields, magic bytes verification for audio uploads - CORS — Configurable via
CORS_ORIGINenv var, not hardcoded - Billing Protection — Credit deduction before transcript creation, atomic MongoDB operations
- AI-powered translation with tone support (Developer / Personal)
- Click-to-copy on transcript cards
- Relative timestamps ("20 minutes ago" instead of "22 Feb ...")
- Cancel button on recording overlay (discard and re-record)
- Rewrite recording overlay with React
- Numeric & Planning formatting options for translation
- Google OAuth authentication with deep link callback
- Credit-based billing system (Pro / Max plans)
- Rate limiting and CORS hardening
- Verify Windows build and end-to-end functionality
- Multi-language UI (12 languages) with localized content
- Audio-reactive waveform visualization (bars respond to microphone input levels)
Contributions are welcome! Here's how to get started:
- Fork the repository
- Clone your fork
git clone https://github.com/<your-username>/voca.git cd voca
- Install dependencies
pnpm install cp .env.example packages/backend/.env # add your API keys - Create a branch for your change
git checkout -b feat/my-feature
- Run the app in dev mode
pnpm dev
- Commit your changes, then push and open a Pull Request
A few things to keep in mind:
- Check the Roadmap for ideas on what to work on
- Open an issue first if you're planning a large change
- Keep PRs focused — one feature or fix per PR
MIT