# How to Vibe Code Your Own TranscriptAPI (and Stop Paying for It) > YouTube Transcript API with Search, Channels & Playlists - Site: https://transcriptapi.com - Category: Developer Tools - Verdict: **Solid side project** (68/100 vibecodeable) - Estimated effort: 2-3 weekends of development and proxy tuning ## Verdict You can build a functional personal clone for your own AI agents, but maintaining uptime against YouTube's anti-scraping defenses will require ongoing maintenance. Writing an Express or Cloudflare Worker backend that parses YouTube caption tracks or utilizes python libraries like youtube-transcript-api is straightforward. However, running this at production scale without getting your datacenter IPs permanently flagged by YouTube requires managing a complex residential proxy pool and rotating cookies. For a personal-use tool plugged into Claude or Cursor, a lightweight self-hosted Node/Python wrapper works well, but it will occasionally break whenever YouTube updates its inner player mechanisms. ### What you can't replicate - Zero Point Studio's proven residential proxy infrastructure and uptime track record at 15M+ requests/month - Commercial economies of scale for low-cost proxy bandwidth ## What it does A developer-focused REST API and Model Context Protocol (MCP) server that bypasses YouTube anti-scraping blocks to deliver structured transcripts, video search, channel browsing, and playlist metadata at scale. ### Core features - Transcript extraction with timestamp or plain text options - YouTube video, channel, and playlist search via REST endpoints - Channel library enumeration and video pagination - RSS-based upload tracking for monitoring new channel uploads - Model Context Protocol (MCP) server implementation for direct AI client integration - OAuth and Bearer token authentication management - Credit consumption accounting and rate limiting ## The business ### Pricing - Free Tier: Free — 100 free sign-up credits (expires after 90 days, no credit card required). - Monthly Plan: $5.00/mo — Includes 1,000 credits per month with 200 RPM rate limit. - Annual Plan: $4.50/mo — Billed annually at $54.00/year, featuring higher rate limits and cheaper top-ups. Founded 2024. Team size: Micro-studio / solo team. ## The hard parts - IP block evasion and anti-scraping countermeasures against YouTube's active datacenter blocks - Continuous schema patching when YouTube alters internal web player structures or player response signatures - Maintaining low median response times (~49ms) through aggressive edge/Redis caching layers for popular transcripts - Managing robust MCP OAuth server flows and persistent agent connections across multiple LLM clients ## How to vibe code TranscriptAPI ### Prerequisites - Node.js (free): Required for running the TypeScript backend and MCP server runtime. - GitHub (free): For version control and CI/CD deployment pipelines. ### Recommended AI tools - Claude Code: Best-in-class terminal coding agent for scaffolding full-stack TypeScript applications and MCP server integrations. ### Stack - Frontend: Next.js - Backend: Cloudflare Workers (TypeScript) - Database: Cloudflare D1 (SQLite) - Auth: better-auth - Payments: Stripe - Other: Model Context Protocol SDK, youtube-transcript library / custom inner-tube scraper, Zod ### Hosting - Cloudflare (Hosting the edge REST API backend, D1 database, and MCP server endpoint.): $0-5/mo ### Build guide 1. **Project Scaffolding & Database Schema** — Initialize a TypeScript project on Cloudflare Workers with a D1 SQLite database to manage users, API keys, and credit tracking. ``` Scaffold a new TypeScript project configured for Cloudflare Workers using Hono or standard fetch handlers. Set up a Cloudflare D1 SQLite database schema with tables for users (id, email, created_at), api_keys (id, user_id, key_hash, created_at), and credit_ledger (id, user_id, delta, reason, timestamp). Include Zod validation for all incoming requests and establish a secure Bearer token authentication middleware that hashes incoming API keys and verifies them against the database. ``` 2. **YouTube Transcript Extraction Engine** — Implement the core scraping and parsing logic to fetch caption tracks from YouTube videos. ``` Implement a TypeScript module that extracts transcripts from YouTube video URLs. The module must fetch the YouTube watch page HTML, extract the inner player response JSON, locate the caption tracks (timedtext URL endpoints), handle auto-generated vs creator-uploaded tracks, support language selection (with fallback to English or ASR), and parse XML/JSON caption formats into structured JSON containing timestamps, durations, and text. Implement robust error handling for private, age-restricted, or missing-caption videos. ``` 3. **YouTube Search & Channel Enumeration Endpoints** — Build REST endpoints for searching YouTube videos, channels, and paginating through channel upload lists. ``` Add REST API endpoints to the Cloudflare Worker: GET /api/v2/youtube/transcript?video_url=...&format=json, GET /api/v2/youtube/search?q=...&type=video&limit=5, GET /api/v2/youtube/channel/search?channel=@handle&q=..., GET /api/v2/youtube/channel/videos?channel=@handle, and GET /api/v2/youtube/playlist/videos?playlist=... Ensure that each successful API call deducts 1 credit from the authenticated user's balance unless it's a free endpoint like GET /api/v2/youtube/channel/latest (RSS-based upload tracker). Return standardized JSON responses matching the TranscriptAPI specification. ``` 4. **Model Context Protocol (MCP) Server Endpoint** — Expose an MCP-compliant server endpoint so AI clients like Claude and Cursor can interact with the YouTube tools natively. ``` Implement a Model Context Protocol (MCP) server endpoint at /mcp using the official MCP TypeScript SDK. Expose tools matching the REST capabilities: get_transcript, search_youtube, search_channel, get_channel_videos, and get_playlist_videos. Implement proper JSON-RPC transport handling over HTTP SSE or streamable transports, authenticating requests via OAuth or Bearer token headers so AI agents can query YouTube contextually in natural language. ``` 5. **Developer Dashboard & Key Management UI** — Build a simple web frontend for users to sign up, view their credit balance, and generate API keys. ``` Build a Next.js developer dashboard frontend styled with Tailwind CSS. Implement pages for user authentication (sign up / log in), a dashboard overview showing remaining credits and rate limits, an API key generation modal that displays the key once securely, and an MCP integration guide page with copy-pasteable configuration snippets for ChatGPT and Claude. Connect the frontend to the Cloudflare Worker backend API. ``` 6. **Testing, Rate Limiting & Proxy Fallback** — Add rate limiting, request logging, and proxy fallback mechanics to prevent blocks. ``` Incorporate a rate-limiting middleware into the Cloudflare Worker enforcing 200 RPM limits per user account using Cloudflare KV. Add a proxy configuration layer allowing optional residential proxy rotation URLs via environment variables to ensure robust uptime against YouTube anti-bot blocks during heavy test runs. Write integration tests verifying credit deductions and error responses. ``` ### Cost vs paying **Starting costs (one-time):** - Custom domain registration: $12 one-time - Total: ~$12 one-time **Ongoing costs (monthly):** - Cloudflare Workers Paid / D1: $5/mo - Total: ~$5/mo - Paying for the SaaS instead: $4.50/mo - Build time: 16-24 hours - AI tool credits: $20 - Break-even: Never (building is purely for personal self-hosting and learning) ## Sources - [TranscriptAPI Homepage](https://transcriptapi.com) - [TranscriptAPI Documentation & API Reference](https://transcriptapi.com/docs/api) - [TranscriptAPI MCP Guides](https://transcriptapi.com/docs/mcp/chatgpt)