# How to Vibe Code Your Own AudioFetcher (and Stop Paying for It)

> Extract and convert audio from YouTube videos and playlists into MP3 files.

- Site: https://audiofetcher.com
- Category: Media Conversion Utility
- Platforms: Web app
- Verdict: **Solid side project** (65/100 vibecodeable)
- Estimated effort: 2-3 weeks of focused development

## Verdict

Build a personal subset of this utility in a couple of weeks, but brace for ongoing maintenance headaches keeping the YouTube extraction pipeline from breaking.

The core engineering challenge here is not the frontend UI or the local Web Audio tools, but keeping the backend extractor alive against frequent upstream delivery changes. For personal use, you can build a working single-video ripper with Next.js, an SQLite quota table, and a background worker running yt-dlp wrapped in FFmpeg. However, expect to patch the extraction scripts regularly as upstream targets update their anti-bot measures.

### What you can't replicate

- The exact organic search traffic and domain authority of the production site

## What it does

AudioFetcher is a web-based utility designed to extract and convert audio from YouTube videos and playlists into MP3 files, alongside a suite of local browser-based audio tools and technical guides.

### Core features

- YouTube video metadata parsing and stream extraction
- Server-side audio conversion pipeline (FFmpeg integration)
- Playlist batch processing and queue management
- Client-side local audio tools (Web Audio API: trimming, format conversion, metadata tagging)
- User authentication and session management via magic links
- Subscription and pass tier enforcement
- Rate-limiting and usage tracking for free tier quotas

## The business

### Pricing

- Free: Free
- Supporter Pass: $5 one-time
- AudioFetcher Pro (Monthly): $6/mo
- AudioFetcher Pro (Annual): $59/yr

## The hard parts

- Constant maintenance of YouTube extraction pipelines against upstream bot-detection and format changes
- Managing server-side concurrency, CPU-intensive FFmpeg transcoding, and temporary file storage
- Reliable handling of long-running downloads (up to 12-hour videos) without worker timeouts

## How to vibe code AudioFetcher

### Prerequisites

- Node.js (free): Required for running the Next.js development environment and managing packages.
- Docker (free): Required to run FFmpeg and containerized extraction tools reliably on your deployment host.
- GitHub (free): Version control and repository hosting for your project code.

### Recommended AI tools

- Claude Code: Best-in-class multi-file agentic coding tool for scaffolding the full stack, setting up the API routes, and writing backend extraction scripts.
- Cursor: Ideal for fine-tuning the Tailwind CSS frontend UI and client-side Web Audio utility components.

### Stack

- Frontend: Next.js (React) with Tailwind CSS
- Backend: Next.js API routes with a containerized Node worker executing yt-dlp and FFmpeg
- Database: Turso (SQLite over HTTP for single-user quota tracking)
- Auth: better-auth (magic link authentication)
- Payments: None (personal use clone skips billing)
- Other: yt-dlp, FFmpeg

### Hosting

- Railway (Host the Next.js server, persistent disk storage, and background worker running FFmpeg and yt-dlp binaries.): $5/mo

### Build guide

1. **Project Scaffolding and Database Schema** — Initialize a Next.js project with Tailwind CSS and configure Turso SQLite for tracking daily conversion quotas and user records.

```
Create a new Next.js project using TypeScript and Tailwind CSS. Set up a Turso SQLite database client using @libsql/client. Create a schema with tables for users (id, email, role, createdAt) and conversions (id, userId, videoUrl, status, createdAt). Implement a basic migration script to initialize these tables on startup.
```

2. **Authentication Integration** — Implement magic link authentication using better-auth so you can securely log in to your personal instance.

```
Integrate better-auth into the Next.js application using SQLite as the backing store. Configure magic link authentication. Create simple sign-in and account management pages with Tailwind CSS that allow signing in via email token.
```

3. **Backend Extraction Pipeline** — Build an API route that accepts a YouTube URL, invokes yt-dlp to extract audio streams, and uses FFmpeg to transcode them into MP3 files.

```
Build a robust backend API route in Next.js that accepts a YouTube video URL and a target audio quality (e.g., 128, 256, 320 kbps). Ensure the environment has access to yt-dlp and ffmpeg binaries. Write a helper function that spawns a child process to download and convert the stream into a temporary MP3 file, handling errors gracefully if the URL is invalid or blocked.
```

4. **Conversion Queue and Rate Limiting** — Add daily quota tracking to restrict unauthenticated or free-tier usage to 3 conversions per day.

```
Implement middleware or service logic that checks the user's conversion count for the current calendar day against their role (Free vs Supporter/Pro). If a free user attempts a 4th conversion, return a 429 status code with an explanatory message. Log successful conversions to the database.
```

5. **Frontend Conversion Dashboard** — Create the main converter interface with URL input, quality selector, live status updates, and download links.

```
Build a clean, responsive frontend dashboard in Tailwind CSS matching the aesthetic of AudioFetcher. Include a URL input form, a quality selector dropdown (128, 192, 256, 320 kbps), and a conversions list area that displays active progress and completed download links. Wire this up to the backend conversion API.
```

6. **Client-Side Audio Utility Tools** — Implement browser-side audio utility tools using HTML5 Web Audio APIs for trimming and converting audio files locally.

```
Create a dedicated 'Local Tools' section in the web app featuring an audio trimmer and format converter that run entirely in the browser using the Web Audio API and HTML5 Canvas. Allow users to upload a local audio file, adjust trim start/end timestamps visually, and export the processed file directly without server uploads.
```

### Cost vs paying

**Starting costs (one-time):**

- AI Coding Assistant (Cursor/Claude Pro): $20
- Total: ~$20 one-time

**Ongoing costs (monthly):**

- Railway Hosting (Server + Disk): $5/mo
- Total: ~$5/mo

- Paying for the SaaS instead: $6/mo
- Build time: 25-35 hours
- AI tool credits: $20
- Break-even: Never (paying $6/mo is cheaper than your time, build for learning)

## Sources

- [AudioFetcher Website](https://audiofetcher.com)