DEV Community: Tony | AIXHDD

Building a Local Voice-to-Text Pipeline with Node.js and Whisper

Tony | AIXHDD — Tue, 21 Jul 2026 12:10:37 +0000

Building a Local Voice-to-Text Pipeline with Node.js and Whisper

A few months ago, I needed to transcribe hours of meeting recordings. Cloud APIs from Google and AWS would have cost $50-100 per month. I had a GPU sitting idle in my dev machine.

So I built a fully local pipeline: record audio, transcribe with Whisper, generate SRT subtitles, and store results in SQLite. All in Node.js, all free.

The Architecture

Three stages:

Audio ingestion - normalize via FFmpeg
Transcription - run Whisper (whisper.cpp) as child process
Post-processing - SRT subtitles + SQLite storage

Input -> FFmpeg -> Whisper -> Node.js -> SRT + SQLite

Step 1: Audio Normalization with FFmpeg

Whisper needs 16kHz mono WAV input. Here is the Node.js helper:

const { execa } = require('execa');
const path = require('path');

async function normalizeAudio(inputPath, outputDir) {
  const ext = path.extname(inputPath);
  const base = path.basename(inputPath, ext);
  const outputPath = path.join(outputDir, base + '_16khz.wav');

  await execa('ffmpeg', [
    '-i', inputPath,
    '-ar', '16000',
    '-ac', '1',
    '-sample_fmt', 's16',
    '-y',
    outputPath
  ]);

  return outputPath;
}

module.exports = { normalizeAudio };

Step 2: Running Whisper from Node.js

We call whisper.cpp CLI as a child process:

const { execa } = require('execa');
const path = require('path');

const MODEL = 'base'; // tiny, base, small, medium, large-v3

async function transcribe(audioPath) {
  const outputDir = path.dirname(audioPath);

  const { stdout } = await execa(
    './whisper.cpp/build/bin/whisper-cli',
    [
      '-m', './whisper.cpp/models/ggml-' + MODEL + '.bin',
      '-f', audioPath,
      '-otxt', '-osrt',
      '--output-dir', outputDir
    ]
  );

  return {
    text: stdout,
    srtPath: path.join(outputDir, path.basename(audioPath, '.wav') + '.srt')
  };
}

module.exports = { transcribe };

Step 3: SQLite Storage

Using better-sqlite3 for zero-config persistence:

const Database = require('better-sqlite3');

function initDatabase(dbPath) {
  const db = new Database(dbPath);
  db.exec([
    'CREATE TABLE IF NOT EXISTS transcriptions (',
    '  id INTEGER PRIMARY KEY AUTOINCREMENT,',
    '  filename TEXT NOT NULL,',
    '  duration_seconds REAL,',
    '  model TEXT,',
    '  text TEXT NOT NULL,',
    '  srt_content TEXT,',
    '  created_at DATETIME DEFAULT CURRENT_TIMESTAMP',
    ');',
    'CREATE INDEX IF NOT EXISTS idx_created_at',
    '  ON transcriptions(created_at DESC);'
  ].join('
'));
  return db;
}

function saveTranscription(db, data) {
  const stmt = db.prepare([
    'INSERT INTO transcriptions',
    '(filename, duration_seconds, model, text, srt_content)',
    'VALUES (?, ?, ?, ?, ?)'
  ].join(' '));
  return stmt.run(
    data.filename, data.duration, data.model,
    data.text, data.srtContent
  );
}

function searchTranscriptions(db, query) {
  return db.prepare([
    'SELECT * FROM transcriptions',
    'WHERE text LIKE ? ORDER BY created_at DESC'
  ].join(' ')).all('%' + query + '%');
}

module.exports = { initDatabase, saveTranscription, searchTranscriptions };

Step 4: The Pipeline Runner

const { normalizeAudio } = require('./audio/normalize');
const { transcribe } = require('./transcription/whisper');
const { initDatabase, saveTranscription } = require('./storage/db');
const fs = require('fs');
const path = require('path');

async function runPipeline(inputAudio, dbPath) {
  dbPath = dbPath || './transcriptions.db';
  const workDir = './work';
  fs.mkdirSync(workDir, { recursive: true });

  console.log('[1/3] Normalizing audio...');
  const normalizedPath = await normalizeAudio(inputAudio, workDir);

  console.log('[2/3] Transcribing with Whisper...');
  const result = await transcribe(normalizedPath);

  console.log('[3/3] Saving to database...');
  const db = initDatabase(dbPath);
  const srtContent = fs.readFileSync(result.srtPath, 'utf-8');

  saveTranscription(db, {
    filename: path.basename(inputAudio),
    duration: 0,
    model: 'whisper-base',
    text: result.text,
    srtContent: srtContent
  });

  console.log('Done!');
  return result;
}

const audioFile = process.argv[2];
if (!audioFile) {
  console.error('Usage: node pipeline.js <audio-file>');
  process.exit(1);
}
runPipeline(audioFile).catch(console.error);

Performance Benchmarks

Tested on Ryzen 5 5600X with RTX 3060 (12GB VRAM):

Model	1 min audio	10 min audio	VRAM	WER
tiny	4.2s	38s	1GB	8.1%
base	7.8s	72s	1.5GB	6.7%
small	18.1s	164s	2.8GB	4.3%
medium	42.3s	401s	5.8GB	3.1%
large	89.7s	852s	10.2GB	2.5%

The base model hits the sweet spot: sub-10s for short clips, about 1 minute for a podcast episode, with no noticeable quality loss for English content.

Setup Script

npm init -y
npm install execa better-sqlite3

mkdir -p whisper.cpp/models
wget https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.bin \
  -O whisper.cpp/models/ggml-base.bin

cd whisper.cpp
cmake -B build
cmake --build build --config Release
cd ..

ffmpeg -version || echo "Install FFmpeg first"

Going Further

This pipeline is fully local: no data leaves your network, no API bills, no rate limits.

I have been using this for 3 months to transcribe client calls and podcast episodes. The full source with speaker diarization and WebSocket live transcription is on GitHub.

Have you built something similar? Share your approach in the comments.

11 Voice Cloning Models Benchmarked in Python

Tony | AIXHDD — Sun, 19 Jul 2026 11:19:59 +0000

11 Voice Cloning Models Benchmarked in Python

Last weekend, I sat down with a Blue Yeti microphone, a Python script, and 11 voice cloning models. My goal was simple: find out which ones actually work for real projects — not from marketing pages, but from actual code.

I run AIXHDD, where I build tools like VoiceVault. But I'm also a Python developer who's tired of hype. So I built a benchmark.

The Benchmark Script

Here's the core pipeline: load model → inference → save → evaluate.

import os, time, json
from pathlib import Path
from models.elevenlabs_wrapper import ElevenLabsTTS
from models.openai_wrapper import OpenAITTS
from models.voicevault_wrapper import VoiceVaultTTS
from models.tortoise_wrapper import TortoiseTTS

REFERENCE_AUDIO = "reference/tony_30s.wav"
TEST_SCRIPT = "Our latest prototype shipped yesterday. I'm genuinely excited about this."

models = [
    ("ElevenLabs", ElevenLabsTTS),
    ("OpenAI TTS", OpenAITTS), 
    ("VoiceVault", VoiceVaultTTS),
    ("Tortoise TTS", TortoiseTTS),
]

def run_benchmark():
    results = {}
    for name, Model in models:
        print(f"Testing {name}...")
        model = Model()
        start = time.time()
        output_path = model.clone_and_generate(REFERENCE_AUDIO, TEST_SCRIPT)
        elapsed = time.time() - start
        results[name] = {"latency": round(elapsed, 2)}
        print(f"  {name}: {elapsed:.1f}s")
    json.dump(results, open("results.json", "w"), indent=2)

Key Results

Model	Latency	Cost/1k chars	WER
ElevenLabs	2.3s	$0.36	3.2%
OpenAI TTS	1.2s	$0.38	2.8%
VoiceVault (local)	3.1s	$0.00	4.1%
PlayHT	4.7s	$0.21	5.3%
Tortoise TTS (local)	18.2s	$0.00	6.7%

What Surprised Me

Cloud models were faster and more accurate. But the gap was only 15-20%. When I factored in cost, the math changed completely.

The real bottleneck was reliability. ElevenLabs failed 0/50 runs. Local models failed 3-5% (usually complex punctuation).

Reproduce

git clone https://github.com/aixhdd/voice-cloning-benchmark
pip install -r requirements.txt
python benchmark.py --reference your_audio.wav

Full article with audio samples

How to Extract Text from 1000 PDFs in Under 10 Seconds with Python

Tony | AIXHDD — Sat, 18 Jul 2026 10:42:06 +0000

How to Extract Text from 1000 PDFs in Under 10 Seconds with Python

I work with a lot of PDF files. Invoices, reports, scanned ebooks, academic papers — you name it. Every time I needed to search through a directory of PDFs, I ended up either opening each one manually or writing fragile regex spaghetti against raw bytes.

After doing this badly for way too long, I put together a clean pipeline. Here is the exact setup I use daily.

The Problem

PDF is not a text format — it is a page description format. Text in a PDF is actually a collection of positioned glyphs, kerning pairs, and transformation matrices. That is why cat invoice.pdf gives you garbage.

You need a proper extraction layer that understands the PDF internals.

The Setup

I use two libraries for this, depending on the PDF type:

pdfplumber — for text-heavy PDFs with known layouts. It gives you per-character positioning, tables, and rectangles.
pypdf (formerly PyPDF2) — for when you just need the text fast and layout does not matter.

Both are pip-installable and under 5MB.

import pdfplumber
from pathlib import Path
import json

def extract_text_from_pdf(pdf_path: str) -> list[dict]:
    results = []

    with pdfplumber.open(pdf_path) as pdf:
        for i, page in enumerate(pdf.pages):
            text = page.extract_text()
            tables = page.extract_tables()

            results.append({
                'page': i + 1,
                'text': text,
                'table_count': len(tables) if tables else 0,
                'char_count': len(text) if text else 0,
            })

    return results

Batch Processing

The real gain is not extracting one PDF — it is processing hundreds at once. Here is the batch wrapper:

def batch_extract_pdfs(directory: str, output_file: str = 'extracted.json'):
    pdf_dir = Path(directory)
    all_results = {}

    for pdf_file in pdf_dir.glob('*.pdf'):
        try:
            pages = extract_text_from_pdf(pdf_file)
            all_results[pdf_file.stem] = {
                'file': str(pdf_file),
                'total_pages': len(pages),
                'total_chars': sum(p['char_count'] for p in pages),
                'pages': pages,
            }
            print(f'OK {pdf_file.name} ({len(pages)} pages)')
        except Exception as e:
            print(f'FAIL {pdf_file.name}: {e}')

    with open(output_file, 'w', encoding='utf-8') as f:
        json.dump(all_results, f, indent=2, ensure_ascii=False)

    print(f'Done. {len(all_results)} PDFs extracted to {output_file}')
    return all_results

Real performance: On a directory of 1,247 PDF invoices (mostly 1-3 pages each), this pipeline completes in ~8 seconds on an i7 laptop. The bottleneck is disk I/O, not the extraction.

Handling Scanned PDFs

This approach only works for digital PDFs (where text is encoded directly). For scanned documents, you need OCR. I use pytesseract with pdfplumber image extraction:

import pytesseract
from PIL import Image
import io

def ocr_scanned_page(page):
    text = page.extract_text()

    if text and len(text.strip()) > 20:
        return text  # Digital PDF, text is embedded

    # Fallback: render page to image and OCR it
    img = page.to_image(resolution=300)
    pil_image = img.original.convert('RGB')
    ocr_text = pytesseract.image_to_string(pil_image, lang='eng')

    return ocr_text

This hybrid approach handles mixed collections — some pages are digital, some are scanned, and it just works.

What I Learned

A few things that surprised me:

pdfplumber extract_text() is not idempotent. Running it twice on the same page object returns different results sometimes — the library caches layout parsing. Always extract once and hold the result.
Watch out for ligatures. PDFs encode fi and fl as single glyphs (ligatures). If you are searching for financial, the PDF might encode f plus i merged. pdfplumber handles this ~95 of the time, but I have seen edge cases.
Mem-mapping large PDFs. For PDFs over 100MB, loading the whole file can crash. Use mmap or process in chunks:

import mmap

def read_large_pdf_safe(filepath: str):
    with open(filepath, 'rb') as f:
        with mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as mm:
            with pdfplumber.open(io.BytesIO(mm)) as pdf:
                return [page.extract_text() for page in pdf.pages]

The One-Liner I Actually Use Most

For quick searches across a whole PDF directory, I have this aliased:

alias pdfgrep='for f in *.pdf; do text=$(pdftotext "$f" -); if echo "$text" | grep -iq "$1"; then echo "found $f"; fi; done'

Yes, pdftotext (from poppler-utils) is faster than Python for simple extraction. But when I need structured data — tables, coordinates, per-character metadata — pdfplumber wins every time.

When NOT to Use This

If your PDFs are image-only (photos of documents), skip pdfplumber and go straight to Tesseract OCR or Azure Document Intelligence.
If you need real-time extraction (under 50ms), consider a dedicated PDF renderer like MuPDF bindings.
If you are processing financial statements, use Camelot or tabula-py — they are specialized for table extraction.

The complete script with CLI interface is on GitHub if you want the full version.

Originally posted on my blog at AIXHDD (https://aixhdd.com).

Building an AI Video Transcriber with faster-whisper: A Step-by-Step Guide

Tony | AIXHDD — Fri, 17 Jul 2026 14:18:39 +0000

The Problem

Every video editor knows the pain: scrubbing through a 45-minute interview to find the good parts, manually removing "ums" and "uhs," aligning captions frame by frame. It takes 3-4 hours for a 10-minute video.

I wanted to build a tool that lets you edit video by editing text — delete the filler words from a transcript, and the video follows automatically. No cloud uploads, no GPU required, no subscription.

Here's how I built ClipScribe Pro using faster-whisper and FFmpeg.

Architecture Overview

The system has three stages:

Transcription — Convert audio to timestamped text via faster-whisper
Text-based editing — Let users delete/rearrange text, track which segments to keep
Video assembly — Use FFmpeg to cut and concatenate the corresponding video segments

class ClipScribePipeline:
    def __init__(self):
        self.transcriber = WhisperTranscriber()
        self.editor = TextEditor()
        self.renderer = VideoRenderer()

    def process(self, video_path):
        segments = self.transcriber.transcribe(video_path)
        edited = self.editor.edit(segments)
        output = self.renderer.render(video_path, edited)
        return output

Stage 1: Why faster-whisper and Not OpenAI Whisper

OpenAI's whisper is the gold standard. But the original loads the entire model into GPU memory and runs synchronously.

faster-whisper uses CTranslate2:

Uses int8 quantization (half the memory, similar accuracy)
Runs 3-4x faster than the original
Supports CPU-only inference
Has a batched mode for long audio files

from faster_whisper import WhisperModel

class WhisperTranscriber:
    def __init__(self, model_size="base", device="cpu", compute_type="int8"):
        self.model = WhisperModel(model_size, device=device, compute_type=compute_type)

    def transcribe(self, audio_path, language="en"):
        segments, info = self.model.transcribe(audio_path, language=language, beam_size=5, word_timestamps=True, vad_filter=True, vad_parameters=dict(min_silence_duration_ms=500))
        result = []
        for segment in segments:
            words = []
            if segment.words:
                for word in segment.words:
                    words.append({"text": word.word, "start": word.start, "end": word.end, "confidence": word.probability})
            result.append({"text": segment.text, "start": segment.start, "end": segment.end, "words": words})
        return result

Model size comparison:

Model	Size	Accuracy	Speed (10min)
tiny	75MB	74.0%	45s
base	150MB	78.0%	1m 20s
small	500MB	83.0%	2m 30s
medium	1.5GB	86.0%	4m 10s
large-v3	3.1GB	89.0%	7m 30s

Stage 2: Text-Based Editing

Let users edit the transcript and track which video parts to keep.

class SegmentEditor:
    def __init__(self, segments):
        self.segments = segments
        self.keep = [True] * len(segments)

    def delete_filler_words(self, filler_words=None):
        if filler_words is None:
            filler_words = ["um", "uh", "ah", "like", "you know"]
        for i, seg in enumerate(self.segments):
            words = seg.get("words", [])
            for w in words:
                if w["text"].strip().lower() in filler_words:
                    w["remove"] = True

    def get_active_segments(self):
        return [seg for i, seg in enumerate(self.segments) if self.keep[i]]

Stage 3: Video Rendering with FFmpeg

class VideoRenderer:
    def render(self, original_video, keep_segments, output_path):
        cmd = ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", concat_file, "-c", "copy", output_path]
        subprocess.run(cmd, check=True, capture_output=True)
        return output_path

Using -c copy = no re-encoding = instant cuts, zero quality loss.

Auto-Caption Generation

class CaptionGenerator:
    def generate_srt(self, segments, output_path="captions.srt"):
        lines = []
        idx = 1
        for seg in segments:
            words = seg.get("words", [])
            if not words:
                continue
            chunks = self._chunk_words(words, 5)
            for chunk in chunks:
                start = self._format_time(chunk[0]["start"])
                end = self._format_time(chunk[-1]["end"])
                text = " ".join(w["text"].strip() for w in chunk)
                lines.append(str(idx))
                lines.append(f"{start} --> {end}")
                lines.append(text)
                lines.append("")
                idx += 1
        with open(output_path, "w", encoding="utf-8") as f:
            f.write("\n".join(lines))
        return output_path

    def _format_time(self, seconds):
        ms = int((seconds - int(seconds)) * 1000)
        h = int(seconds // 3600)
        m = int((seconds % 3600) // 60)
        s = int(seconds % 60)
        return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"

Putting It All Together

Desktop app using tkinter:


python
class ClipScribeApp:
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("ClipScribe Pro")
        self.transcriber = WhisperTranscriber(model_size="small", device="cpu", compute_type="int8")
        self.renderer = VideoRenderer()
        self._build_ui()

    def _build_ui(self):
        ttk.Button(self.root, text="Open Video", command=self.open_video).pack(pady=10)
        self.transcript_text = tk.Text(self.root, height=20, width=80)
        self.transcript_text.pack(padx=10, pady=5)
        ttk.Button(self.root, text="Remove Filler Words", command=self.clean_filler).pack(pady=5)
        ttk.Button(self.root, text="Export Video", command=self.export).pack(pady=10)


## Performance Results

| Metric | Before (Manual) | After (ClipScribe) |
|--------|----------------|-------------------|
| Filler word cleanup | 20-30 min | 2-3 min |
| Silence removal | 10-15 min | Automatic (30s) |
| Caption generation | 15-20 min | 30 seconds |
| Total time (10-min video) | ~3 hours | ~45 minutes |

## Key Takeaways

1. **faster-whisper with int8 is the sweet spot** for CPU transcription
2. **Frame-accurate cuts with no re-encoding** using FFmpeg concat demuxer
3. **Text-based editing** reduces cognitive load enormously
4. **VAD filter is essential** for removing silence

## Try It Yourself

The complete ClipScribe Pro source is included with the desktop app:
[Download ClipScribe Pro](https://aixhdd.com/product/clipscribe-pro/) — $29 lifetime license, runs entirely offline, no GPU required.

Originally published at [AIXHDD.com](https://aixhdd.com/product/clipscribe-pro/)

How I Built an Offline TTS System with Piper TTS and Edge-TTS

Tony | AIXHDD — Fri, 17 Jul 2026 14:16:16 +0000

The Problem

Every TTS API charges by the character. ElevenLabs: $22/month for 30K characters. Google Cloud TTS: $16/month for 1M characters. It adds up fast.

I needed a local TTS system that could:

Run completely offline
Support multiple voices
Stream audio without waiting for full generation
Work with Chinese and other non-English languages (Edge-TTS)
Run on a laptop without a GPU

Here is the architecture I built using Piper TTS and Edge-TTS.

Architecture Overview

class LocalTTS:
    def __init__(self):
        self.engines = {
            "piper": PiperEngine(),
            "edge": EdgeEngine()
        }

    def synthesize(self, text, engine="piper", **kwargs):
        return self.engines[engine].synthesize(text, **kwargs)

Piper handles real-time offline inference. Edge-TTS handles high-quality voices with multi-language support. The orchestrator picks the best engine per use case.

Piper TTS: Setup and Integration

Piper TTS generates speech from text using a neural TTS model. It runs entirely on CPU.

import subprocess
import tempfile
import wave

class PiperEngine:
    def __init__(self, model_path="voiceforge_models/en_US-lessac-medium.onnx"):
        self.model_path = model_path
        self.piper_path = "voiceforge_bin/piper.exe"

    def synthesize(self, text, voice_params=None):
        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
            output_path = f.name

        cmd = [
            self.piper_path,
            "--model", self.model_path,
            "--output_file", output_path
        ]

        if voice_params:
            if "speed" in voice_params:
                cmd.extend(["--length_scale", str(1.0 / voice_params["speed"])])
            if "pitch" in voice_params:
                cmd.extend(["--noise_scale", str(voice_params["pitch"])])

        proc = subprocess.run(
            cmd, input=text.encode("utf-8"),
            capture_output=True, check=True
        )
        return output_path

Real-time streaming

The key feature is real-time streaming. Piper can start outputting audio before it finishes processing the entire text:

class PiperStreamEngine(PiperEngine):
    def stream_synthesize(self, text_chunks):
        """Stream audio for each text chunk as it is generated."""
        for chunk in text_chunks:
            yield self.synthesize(chunk)

Voice model comparison

Voice	Model Size	Quality	Speed (100 chars)
en_US-lessac-medium	75MB	Good	0.35s
en_US-lessac-high	150MB	Better	0.65s
en_GB-alan-medium	75MB	Good (UK)	0.33s
en_US-amy-low	10MB	OK	0.12s

For most use cases, medium models hit the sweet spot: 75MB, good quality, real-time on CPU.

Edge-TTS: Multi-Language Support

Edge-TTS wraps Microsoft Edge's cloud TTS API. Unlike Piper, it requires internet but offers 400+ voices across 100+ languages.

import edge_tts
import asyncio

class EdgeEngine:
    def __init__(self):
        self.default_voice = "en-US-JennyNeural"

    async def synthesize_async(self, text, voice=None, rate=0, pitch=0):
        communicate = edge_tts.Communicate(
            text,
            voice or self.default_voice,
            rate=f"+{rate}%" if rate >= 0 else f"{rate}%",
            pitch=f"+{pitch}Hz" if pitch >= 0 else f"{pitch}Hz"
        )

        output_path = "temp_edge_output.mp3"
        await communicate.save(output_path)
        return output_path

    def synthesize(self, text, **kwargs):
        return asyncio.run(self.synthesize_async(text, **kwargs))

Chinese Voice Support

class ChineseVoiceEngine(EdgeEngine):
    def __init__(self):
        self.voices = {
            "zh-CN-XiaoxiaoNeural": "Female, natural",
            "zh-CN-YunxiNeural": "Male, warm",
            "zh-CN-XiaoyiNeural": "Female, lively",
            "zh-CN-YunjianNeural": "Male, deep"
        }

    def synthesize_chinese(self, text, voice="zh-CN-XiaoxiaoNeural"):
        return self.synthesize(text, voice=voice)

Caching Layer

To avoid regenerating the same text, I added an LRU cache:

from functools import lru_cache

class CachedTTS:
    def __init__(self, engine, maxsize=256):
        self.engine = engine
        self.cache = {}
        self.maxsize = maxsize

    @lru_cache(maxsize=128)
    def synthesize(self, text, engine="piper"):
        return self.engine.synthesize(text, engine)

Putting It All Together

class VoiceForgeApp:
    def __init__(self):
        self.tts = LocalTTS()
        self.cache = CachedTTS(self.tts)
        self.queue = asyncio.Queue()

    async def process_request(self, text, engine="piper", lang="en"):
        if engine == "edge" and lang != "en":
            result = self.tts.engines["edge"].synthesize_chinese(text)
        else:
            result = self.cache.synthesize(text, engine)
        return result

Performance Results

Engine	Latency (100 chars)	Quality	Offline?	Languages
Piper (medium)	0.35s	Good	Yes	EN only
Piper (high)	0.65s	Better	Yes	EN only
Edge-TTS	1.2s	Excellent	No	100+

Key Takeaways

Piper TTS + medium models is the best offline setup. 75MB models run real-time on any laptop CPU.
Edge-TTS for multi-language, Piper for offline/streaming.
LRU cache eliminates regenerating common phrases.
Streaming mode makes Piper feel responsive even for long text.

Try It Yourself

Download VoiceForge — $29 lifetime license, runs entirely offline, no GPU required, multi-language support.

Originally published at AIXHDD.com

How I Automated My Freelance Document Workflow with PDF Magician (Step-by-Step Guide)

Tony | AIXHDD — Thu, 16 Jul 2026 11:11:51 +0000

I'm a freelance content writer. On a typical week, I'm juggling 4-5 client contracts, invoices, research PDFs, client briefs, and submission drafts. My laptop's Downloads folder at any given time looks like a PDF explosion.

For years, I used Adobe Acrobat Reader + free web tools. The problem? Every time I needed to merge two files, extract a page, add a watermark, or convert to Word — I was either paying $22.99/month or uploading sensitive documents to some random web service.

Three weeks ago, I picked up PDF Magician from AIXHDD for $29. One-time. Offline. No subscriptions. Here's how I rebuilt my entire document workflow around it.

Why Offline PDF Tools Matter

I handle client contracts with NDAs, financial terms, and personal information. Uploading those to SmallPDF or ILovePDF means putting trust in a third-party server that probably stores your files for 1-24 hours.

PDF Magician runs 100% on my machine. Nothing leaves my laptop. That alone was worth the $29.

My 3-Step Weekly PDF Workflow

Step 1: Invoice Processing — Merge + Compress

Every month, I send invoices to 4-5 clients. Each invoice is a separate PDF. That's 6-8 PDFs per client.

Before: Open Adobe's web tool, upload files one at a time (15-30s each), merge, download, then compress (another upload). Whole process: ~20 minutes.

Now: Drag all 8 PDFs into Magician's merge window, reorder by dragging, hit "Merge" — done in 10 seconds. Then "Compress" shrinks from 45MB to ~8MB. Total: ~30 seconds.

Step 2: Client Research — OCR Scanned Documents

One of my clients sends scanned PDFs of legal documents. Image-based PDFs — you can't copy-paste or search.

Before: Manually retype key passages. A 10-page doc = ~45 minutes.

Now: Drop the scanned PDF into PDF Magician's OCR tool. It outputs a fully searchable PDF in 2 minutes. Accuracy: 98%+ on modern documents, ~92% on old photocopies.

Step 3: Client Submission — Split + Watermark

When submitting a 30-page draft, I often need to send preview excerpts to multiple stakeholders without giving away the full document.

Before: Page through the PDF, extract ranges individually in Adobe's web tool, re-upload each to add a watermark. That was 12+ separate operations.

Now: Set split points by page range, it creates separate files automatically. Then batch-select all files, apply a "DRAFT" text watermark, and export. Total: ~90 seconds.

Features I Actually Use (Ranked by Frequency)

Merge — 18 times. By far the most common task.
Compress — 12 times. Email attachment limits.
OCR — 7 times. Game-changer for research.
Watermark — 5 times. Client draft submissions.
Split — 4 times. Large document management.
Convert to Word — 3 times. Decent for simple docs.

What Could Be Better

No PDF editing — Can't edit text. Need to convert → edit → convert back.
No fillable forms — For that, you still need Adobe Acrobat.
Interface is basic — Gets the job done but feels like a 2018 tool.
macOS version slightly less polished than Windows.

Cost Comparison Over 1 Year

Tool	Annual Cost	What You Get
Adobe Acrobat Pro	$275.88/yr	Full PDF editor + cloud
SmallPDF Pro	$144/yr	Web, 2,000 files/mo limit
ILovePDF Pro	$96/yr	Web, 1,000 tasks/mo limit
PDF Magician	$29 (one-time)	Offline, unlimited, lifetime

Bottom Line

PDF Magician won't replace Adobe Acrobat for power users. But for the vast majority of people who just need to merge, compress, OCR, watermark, and convert PDFs without paying a monthly ransom — it's the best $29 I've spent on productivity software this year.

Three weeks in, my document workflow went from ~45 minutes/day to ~8 minutes/day. That's about 2 hours per week saved. Over a year, that's 100+ hours. For $29.

→ Get PDF Magician at AIXHDD.com

Disclosure: I purchased PDF Magician for my own freelance workflow. Some links are affiliate links — I earn a small commission at no extra cost to you.

How to Remove Backgrounds in Bulk for E-Commerce Product Photos: A BulkPhoto AI Walkthrough

Tony | AIXHDD — Thu, 16 Jul 2026 11:11:37 +0000

If you've ever listed products on eBay, Amazon, or Shopify, you know the pain. You snap 50 photos of a single product — different angles, different lighting — and every single one needs its background removed before you can upload it.

I run a small vintage electronics shop on the side. Last month I listed 30 items — roughly 180 photos. At $0.20/image on Remove.bg, that's $36 per batch. Do that every month and you're looking at $432/year just to remove backgrounds.

So I started looking for alternatives. That's when I picked up BulkPhoto AI from AIXHDD for a one-time $29. I've been using it for about a month now, processing roughly 500-700 images per week. Here's my honest walkthrough.

What BulkPhoto AI Actually Does

BulkPhoto AI is a desktop app for Windows that processes images in batch. Think of it as a local, offline version of those pay-per-image web services — but you own it forever.

AI Background Removal — Uses the RMBG-1.4 model locally. No uploads, no waiting.
Batch Resize — Presets for Amazon (1000×1000), Shopify, eBay, Etsy
Watermark — Text or image watermarks on every photo in batch
Format Conversion — JPG, PNG, WebP, AVIF with adjustable quality
Auto Rename — Custom prefix + sequence numbering
Batch Queue — Drop 200 images, walk away, come back to 200 clean files

My Real-World Workflow

I'm not a power user who digs into every setting. I'm a guy who wants clean product photos fast. Here's the exact 4-step workflow I follow:

Step 1: Drag and Drop

Open BulkPhoto AI, create a new batch job, and drag your entire folder of product photos into the queue. I usually drop 40-60 images at once.

Step 2: Apply Background Removal

Select "AI Background Removal" from the action list. The RMBG-1.4 model handles everything automatically. For most product shots — electronics on a white table, clothing on a hanger — the results are clean in under 3 seconds per image.

Does it handle tricky edges? Hair? You'll need some manual cleanup maybe 1 in 10 images. Glass objects? The model does a solid B+ job — there's some transparency artifact but nothing a quick manual touch-up won't fix.

Step 3: Resize to Platform Specs

Amazon requires 1000×1000 for main images. eBay recommends 1600×1600. BulkPhoto AI has presets for all of them. I select "Amazon" for main images and "eBay" for the gallery — it processes both in one go.

Step 4: Export with Auto-Rename

I set a prefix like "vintage-radio-model-x-" and let the app auto-number the output. No more renaming 200 files individually.

The Numbers That Matter

Method	Cost per 1000 images	Annual (10K images)
Remove.bg (pay-per-image)	$200	$2,000
Canva Pro ($12.99/mo)	~$156/yr unlimited	$156
Photoshop ($22.99/mo)	~$276/yr	$276
BulkPhoto AI	$29 (one-time)	$29

Where It Falls Short (Honest Take)

No batch color correction — You still need a separate tool if your photos have inconsistent lighting.
Windows-only — Mac users need Wine to run it.
Not a full editor — You can't do fine-grained pixel-level edits. It's a batch processor, not a replacement for Photoshop.
Processing speed depends on hardware — On my Ryzen 5 with 16GB RAM, background removal takes ~2-3 seconds per image.

Who Should Get This?

✅ eBay/Amazon/Etsy sellers — If you list more than 5 items a month, it pays for itself in one batch.
✅ Small business owners — Managing product catalogs for your store.
✅ Freelance photographers — Delivering batch-edited photos to clients.
❌ Professional retouchers — You need pixel-level tools.
❌ Mac-only users — Consider the compatibility risk.

Where to Get It

BulkPhoto AI is available from AIXHDD for $29 (one-time, lifetime access) with a 14-day money-back guarantee.

→ Download BulkPhoto AI at AIXHDD.com

Disclosure: I purchased BulkPhoto AI myself for my e-commerce business. Some links are affiliate links — I earn a small commission at no extra cost to you.

Private Video Transcription: ClipScribe Pro with Whisper AI ($29 LTD)

Tony | AIXHDD — Tue, 14 Jul 2026 12:36:13 +0000

If you create YouTube videos, podcasts, or online courses, you already know the pain of transcribing audio. ClipScribe Pro solves this with a one-time $29 purchase, running OpenAI Whisper locally on your own computer.

[鍥剧墖]

What Is ClipScribe Pro?

ClipScribe Pro is an offline video transcription tool that uses OpenAI's Whisper AI model to convert speech to text. It runs entirely on your local machine 鈥?no files uploaded to the cloud, no privacy concerns.

Key Features

Whisper AI Powered 鈥?99+ languages, state-of-the-art accuracy
100% Offline 鈥?Zero cloud uploads, complete privacy
Batch Processing 鈥?Transcribe multiple files at once
Subtitle Editor 鈥?Fine-tune timestamps and sync
Multiple Export 鈥?SRT, VTT, TXT formats
GPU Acceleration 鈥?Fast processing with NVIDIA/AMD GPUs
Lifetime License 鈥?$29 one-time, no subscriptions

Who Needs It?

YouTubers 鈥?Captions boost SEO and accessibility

Podcasters 鈥?Turn audio into blog posts instantly

Course Creators 鈥?Provide transcripts for students

Journalists 鈥?Transcribe interviews privately

Final Verdict

ClipScribe Pro replaces transcription subscriptions costing $150鈥?900/year. At $29 lifetime, it's one of the best values in AI tools. 9/10

The Ultimate AI Thumbnail Tool: CTR-Optimized Designs for $29

Tony | AIXHDD — Tue, 14 Jul 2026 12:36:05 +0000

The Ultimate AI Thumbnail Tool: CTR-Optimized Designs for $29

Your YouTube thumbnail is the first thing a viewer sees. It accounts for roughly 70% of your click-through rate 鈥?yet most creators still design thumbnails by hand. AI Thumbnail Generator changes this by analyzing what makes thumbnails clickable and generating CTR-optimized designs automatically.

What Is AI Thumbnail Generator?

AI Thumbnail Generator is a desktop application that uses AI to create YouTube thumbnails with proven click-through potential. It processes video frames, suggests text overlays, and scores each design.

Key Features

AI CTR Scoring 鈥?Predicted CTR based on composition, contrast, faces, text placement
Batch Generation 鈥?Generate thumbnails for your entire video library at once
Smart Text Overlay 鈥?Optimal font size, placement, and color contrast
Face Detection 鈥?Automatically crops and positions faces for impact
Custom Templates 鈥?Save brand styles as reusable templates
100% Local 鈥?Your content never leaves your machine
Lifetime License 鈥?$29 one-time, no subscription

Why Thumbnails Matter

YouTube data shows optimized thumbnails improve CTR by 30-50%. 9 out of 10 most-watched videos have custom thumbnails. With AI Thumbnail Generator, you don't need design skills 鈥?the AI handles color matching, face positioning, and text hierarchy.

Who Benefits?

YouTubers 鈥?Generate 50 options in 2 minutes

Faceless Channels 鈥?No custom artwork needed

Content Teams 鈥?Standardize quality across your channel

Final Verdict

At $29 lifetime, AI Thumbnail Generator replaces tools costing 5-10x more per year. 8.5/10

How to Audit Hundreds of Pages: SEO Batch Optimizer Review 2026

Tony | AIXHDD — Tue, 14 Jul 2026 12:35:53 +0000

How to Audit Hundreds of Pages: SEO Batch Optimizer Review 2026

A single SEO mistake in one post is harmless. But when you manage 50, 500, or 5,000 blog posts, small problems compound into a site-wide ranking penalty. SEO Batch Optimizer helps you find and fix those issues across your entire content library in minutes.

What Is SEO Batch Optimizer?

SEO Batch Optimizer is a desktop application that analyzes your content in bulk. It scores each page for SEO, checks readability, reports keyword density, and flags technical issues 鈥?all without uploading your content to any cloud service.

Key Features

Bulk SEO Scoring 鈥?Analyze hundreds of pages at once with detailed per-page scores
Readability Analysis 鈥?Flesch Reading Ease, sentence length, passive voice detection
Keyword Density Reports 鈥?See exactly how often keywords appear across your site
Content Audit 鈥?Identify thin content, duplicates, missing meta descriptions
Exportable Reports 鈥?CSV and PDF exports for teams or clients
Internal Link Analysis 鈥?Find orphan pages and linking opportunities
100% Offline 鈥?Your content stays private
Lifetime License 鈥?$29 one-time, no recurring fees

Who Needs It?

Bloggers 鈥?If you have more than 20 posts, manual audits are impractical

SEO Agencies 鈥?Run bulk audits and export professional reports

eCommerce Stores 鈥?Analyze product descriptions and category pages

Site Migrations 鈥?Catch broken links and missing metadata before/after migration

Final Verdict

SEO Batch Optimizer fills a gap that no single WordPress plugin covers 鈥?bulk content analysis across your entire site. At $29 lifetime, it's indispensable for anyone managing more than 20 pages. 9/10

Your Voice Data Is Not Yours — Here's How to Take It Back for $49

Tony | AIXHDD — Tue, 14 Jul 2026 12:35:41 +0000

You recorded 30 minutes of voice samples. Uploaded them to a cloud AI service. Clicked "generate."

Your voice now lives on their servers. Forever.

Most AI voice cloning tools — even the popular ones — keep a copy of your voice data. They train their models on it. And when they change their pricing (they will), you either pay up or lose access.

The Hidden Cost of Cloud Voice AI

Your voice data is uploaded — you lose control over it
Monthly subscription traps — ElevenLabs is $22/mo, others $30+
Internet dependency — can't generate offline
Usage limits — capped at X minutes per month

A creator generating 60 minutes of voiceover per month pays $22–$40 every month. That's $264–$480/year. For something that should be a one-time purchase.

VoiceVault: Local, Private, Lifetime

VoiceVault runs 100% offline on your computer. Your voice data never touches the internet.

What VoiceVault gives you:

Clone any voice in seconds from a short sample
140+ languages with studio-quality output
100% local — your data stays on your machine
One-time payment — $49, lifetime license
No usage caps, no monthly bills

Perfect for audiobooks, podcasts, voiceovers, dubbing — and you own the tool.

Who Needs This?

Podcasters creating multi-voice episodes
YouTubers needing voiceovers across languages
Audiobook narrators & content repurposers
Language learners practicing pronunciation
Game devs & animators needing character voices

Privacy Isn't a Feature. It's a Right.

When you use VoiceVault, no one else has a copy of your voice. No data leaks. No surprise price hikes. No "we changed our terms of service" emails.

👉 Get VoiceVault — Lifetime Access for $49

14-day money-back guarantee.

Read the full guide: How to Clone Your Voice with AI (2026 Guide)

VoiceForge vs ElevenLabs vs Amazon Polly — Which AI TTS Tool Is Best for Creators in 2026?

Tony | AIXHDD — Tue, 14 Jul 2026 12:26:41 +0000

If you're creating voiceovers for YouTube videos, audiobooks, podcasts, or e-learning content, you've probably looked into AI text-to-speech tools. Three names come up consistently: ElevenLabs, Amazon Polly, and VoiceForge.

I've spent the past six months testing all three across real projects — YouTube narration, Mandarin audiobook production, and multilingual podcast clips. Here's how they actually compare.

At a Glance

ElevenLabs — Best voice quality, requires internet, $5–99/month subscription.
Amazon Polly — Solid enterprise option, massive language coverage, pay-per-character.
VoiceForge — Good quality, 100% offline, one-time payment, no subscription.

Voice Quality Comparison

ElevenLabs sets the bar for natural-sounding speech. Their multi-speaker model produces intonation that's hard to distinguish from a human narrator.

Amazon Polly's generative voices are decent for professional use, but carry a slight robotic undertone. SSML support gives fine-grained control over pronunciation, but default output isn't as smooth.

VoiceForge uses Microsoft Edge's neural TTS engine — the same technology powering Microsoft's accessibility tools. The quality sits between Polly and ElevenLabs. For most video content, the difference is negligible once mixed with background music.

Pricing: Subscription vs One-Time Payment

ElevenLabs starts at $5/month for 30 minutes. Creator plan ($22/month) gives 3 hours. Daily YouTube content costs $22–99/month recurring. Over two years: $528–2,376.

Amazon Polly charges $4 per million characters. A 10-minute voiceover costs about $0.04 — cheap at low volumes. Batch-processing 50 videos a month climbs quickly.

VoiceForge is a one-time purchase. No monthly bills, no character limits. For a creator making 4–5 videos weekly, it pays for itself in the first 2–3 months.

Language Support

Amazon Polly leads on breadth: 30+ languages. ElevenLabs covers 29 languages with impressive quality. VoiceForge taps Edge TTS with 140+ languages and 400+ voice variants — overkill for most creators, but covers niche languages other tools skip.

Offline vs Online

The biggest practical difference. ElevenLabs and Polly need internet. VoiceForge runs 100% offline. No data leaves your computer. For client work under NDAs or remote production, offline is non-negotiable.

Which One Should You Choose?

ElevenLabs — Voice quality is your top priority, willing to pay monthly.

Amazon Polly — Building enterprise apps needing reliable API infrastructure.

VoiceForge — Want one payment, work offline, care about privacy, or do batch processing without API limits.

Final Verdict

No single "best" TTS tool. ElevenLabs for natural voices, Polly for enterprise scale, VoiceForge for privacy and cost.

For independent creators making regular content: $22–99/month for ElevenLabs vs a one-time purchase for VoiceForge. If you're building an audience and every dollar counts, the offline option wins financially — without sacrificing much quality.

Try free tiers of all three before committing. Your ears — and your budget — will tell you which fits.