APIs for Summarizing YouTube Videos at Scale

# YouTube Summarizer API Comparison

| Name | Summarization Method | Pricing Model | Rate Limits | Output Formats | Best For |
|------|---------------------|---------------|-------------|----------------|----------|
| **Supadata AI** | Transcript-based (auto-fetches captions, falls back to Whisper ASR) | Pay-as-you-go: ~$0.002–0.005 per video; ~$99/mo for 100k credits | 100 req/min on paid tiers | JSON (summary, chapters, transcript), Markdown | High-volume batch pipelines on tight budgets; newsletter/digest tools |
| **AssemblyAI (LeMUR)** | Multimodal-lite: transcript + LLM reasoning (Claude/GPT under the hood) | $0.37/hr transcription + $0.015/1k tokens for summarization | 200 concurrent jobs | JSON, SRT, VTT, chapters array | Teams needing high-accuracy transcripts + custom prompts |
| **Eden AI (YouTube Summary node)** | Transcript-based, routes to multiple LLMs (OpenAI, Cohere, Anthropic) | Aggregated PAYG, ~$0.003–0.01 per video depending on model | 60 req/min default | JSON, plain text | Multi-provider fallback & vendor flexibility |
| **Gladia** | Multimodal (audio + speaker diarization) | $0.144/hr audio (~$0.02 per 10-min video) | 100 concurrent | JSON with timestamps, chapters, summary | Multilingual content, podcasts, interview-heavy channels |
| **Kome AI / YouTube Summary API** | Transcript-based via YouTube captions | Flat $29–$99/mo tiers | ~10 req/sec | JSON, Markdown | Low-cost MVPs, simple digest tools |

---

### Recommendation

For **5,000 videos/day with 300-word summaries + timestamped chapters under $500/month**, go with **Supadata AI**. At ~$0.003/video you'd land around **$450/month** for 150k videos, it natively returns chapter breakdowns with timestamps, and it exposes a clean REST API with an official Node.js SDK. AssemblyAI is the runner-up if transcript accuracy matters more than cost, but its per-hour pricing will exceed your budget at this volume.

---

### Quick Start (Supadata AI)

**cURL:**
```bash
curl -X POST https://api.supadata.ai/v1/youtube/summary \
  -H "x-api-key: $SUPADATA_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://www.youtube.com/watch?v=VIDEO_ID",
    "summary_length": 300,
    "include_chapters": true,
    "format": "json"
  }'
```

**Node.js:**
```javascript
import { Supadata } from '@supadata/js';

const client = new Supadata({ apiKey: process.env.SUPADATA_KEY });

const result = await client.youtube.summary({
  url: 'https://www.youtube.com/watch?v=VIDEO_ID',
  summaryLength: 300,
  includeChapters: true,
});

console.log(result.summary);        // ~300-word summary
console.log(result.chapters);       // [{ start: 0, title: "Intro" }, ...]
```

> ⚠️ **Verify before committing:** pricing and rate limits change frequently — confirm current tiers on each vendor's pricing page and run a 100-video pilot to validate chapter quality before scaling to full volume.

# YouTube Video Summarizer API Comparison

| Name | Summarization Method | Pricing Model | Rate Limits | Output Formats | Best For |
|------|----------------------|---------------|-------------|----------------|----------|
| **AssemblyAI** | Transcript-based (LLM) | $0.25/video (transcript) + $0.10/LLM prompt | 500 req/min; 50K/month free tier | JSON (transcript, summary, chapters) | High-volume transcript processing with built-in LLM summarization |
| **Rev.ai** | Transcript-based (human + ML hybrid) | $0.25/min audio + $5-50/custom summaries | 300 req/min; no free tier | JSON, VTT, SRT | Accuracy-critical workflows; slower turnaround |
| **Twelve Labs** | Multimodal (vision + transcript) | $0.004/min video indexed; $0.10/search query | 1,000 req/min; 10K free queries/month | JSON (scene breakdown, chapters, NLP insights) | Rich visual context; requires indexing overhead |
| **OpenAI Whisper API + GPT-4** | Transcript-based (modular) | Whisper: $0.006/min; GPT-4: $0.03/input 1K tokens | 3,500 req/min (tier-dependent) | JSON (custom via prompt engineering) | Maximum flexibility; lowest compute cost at scale |
| **Hugging Face Inference (self-hosted)** | Transcript-based (open-source) | Free (self-hosted); $9+/month (managed inference) | Unlimited (self-hosted); 1K req/day free tier | JSON (custom formatting) | Cost-sensitive; on-premise requirements |

---

## Recommendation

**Best Fit: AssemblyAI + OpenAI GPT-4 Hybrid**

For 5,000 videos/day (~$375-450/month), **AssemblyAI** is the primary recommendation because it offers native transcript extraction optimized for YouTube, built-in LLM summarization, Node.js SDK support, and predictable per-video pricing that fits your budget. Pair it with **OpenAI GPT-4** only for chapter breakdowns with timestamps if AssemblyAI's default chapters are insufficient—this modular approach keeps costs under $500/month while guaranteeing 300-word summaries and structured chapter data.

**Alternative if budget is flexible:** **Twelve Labs** provides superior visual context (ideal for tutorial/vlog channels) but requires an indexing pass that adds ~$8-15/month per 5K videos; only choose this if visual summaries are mandatory.

---

## Integration Example: AssemblyAI (Top Pick)

### Python Implementation
```python
import requests
import json
from assemblyai import AssemblyAI

client = AssemblyAI(api_key="YOUR_API_KEY")

# Step 1: Submit YouTube video for transcription
transcript = client.transcribe(
    audio_url="https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    auto_chapters=True,  # Enables chapter breakdown
)

print(f"Transcript ID: {transcript.id}")
print(f"Status: {transcript.status}")

# Step 2: Poll for completion
while transcript.status == "processing":
    transcript = client.get_transcript(transcript.id)

# Step 3: Extract structured output
summary_payload = {
    "transcript_id": transcript.id,
    "prompt": "Summarize this video in exactly 300 words, focusing on key takeaways and actionable insights.",
}

# Use AssemblyAI's LLM endpoint
response = requests.post(
    "https://api.assemblyai.com/v2/lemur/summarize",
    json={"transcript_id": transcript.id, "answer_format": "paragraph"},
    headers={"Authorization": "YOUR_API_KEY"}
)

summary = response.json()
chapters = transcript.chapters  # Auto-generated with timestamps

print(json.dumps({
    "summary": summary.get("response"),
    "chapters": [{"title": ch.gist, "start": ch.start, "end": ch.end} for ch in chapters]
}, indent=2))
```

### Node.js/cURL (Quick Test)
```bash
# Fetch transcript and chapters
curl -X GET \
  "https://api.assemblyai.com/v2/transcript/{TRANSCRIPT_ID}" \
  -H "Authorization: YOUR_API_KEY" | jq '.chapters'

# Request LLM summary
curl -X POST \
  "https://api.assemblyai.com/v2/lemur/summarize" \
  -H "Authorization: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "transcript_id": "YOUR_TRANSCRIPT_ID",
    "answer_format": "paragraph"
  }'
```

### Cost Breakdown (5,000 videos/day)
- **AssemblyAI**: 5,000 × $0.25 (transcript) = **$1,250/month** ⚠️ *Over budget alone*
- **Workaround**: Use **OpenAI Whisper API** ($0.006/min) + **GPT-4 Turbo** ($0.01/1K input tokens) = **~$80-120/month** for transcription + **$300-350/month** for summarization/chapters = **$380-470/month** ✅

**Revised Recommendation:** Use **Whisper API + GPT-4 Turbo** for true $500/month compliance; AssemblyAI fits only if video volume drops to ~500-1,000/day.

Below is a decision-ready comparison focused on **REST-accessible APIs** that can support a **newsletter workflow**, need **~300-word summaries + timestamped chapter breakdowns**, and must stay **under ~$500/month** at **~5,000 videos/day**.

## YouTube video summarizer API comparison

| Name | Summarization Method (transcript vs. multimodal) | Pricing Model | Rate Limits | Output Formats | Best For |
|---|---|---|---|---|---|
| **Recall.ai + LLM pipeline** | **Transcript-first** via meeting/video capture + downstream LLM summarization; for YouTube, typically used by ingesting transcript/captions rather than true visual understanding | Usage-based for capture/transcription; total cost depends on your LLM choice. Can be cost-controlled if summaries are generated from transcripts only | Commercial API with scalable throughput; exact limits usually contract/account based | JSON transcripts, timestamps; your app generates summary/chapter JSON/text | Teams that want a **scalable backend pipeline** and are comfortable assembling transcript + summarization themselves |
| **Twelve Labs** | **Multimodal** video understanding; can summarize from audio/visual content and support scene/chapter-style outputs | Usage-based, generally premium/video-AI pricing; likely difficult to keep at **5,000 videos/day under $500/month** unless volume-discounted | Enterprise-style quotas; typically account-tier based | JSON summaries, highlights, searchable moments/segments | Best raw video understanding, but usually too expensive for strict low-budget bulk summarization |
| **Google Gemini API / Vertex AI** | **Multimodal**, but for YouTube at scale the practical path is usually **transcript-first** using captions/transcripts as input to Gemini | Token-based. Very cost-efficient if you summarize transcripts only. Staying under budget depends heavily on transcript length and model choice | Standard Google AI quotas; scalable with billing/quota increases | JSON/text; easy structured outputs for summary + chapter arrays | Strong option if you can **fetch transcripts separately** and want reliable structured output with solid Node.js support |
| **OpenAI API** | **Transcript-first** for this use case; can generate 300-word summaries and chapter breakdowns from transcript text | Token-based. Feasible under budget only if transcripts are short/clean and you use a low-cost model; full 5,000/day may still exceed budget depending on average transcript size | Tier-based RPM/TPM; can scale with account usage tier | JSON/text with schema-enforced structured output | Great developer experience and Node SDK, but budget risk at your requested daily volume |
| **RapidAPI YouTube Transcript/Summarizer APIs** | Mostly **transcript-first** wrappers over captions or LLM summaries; quality varies by provider | Low entry cost, often per-request tiers, but reliability and throughput vary widely | Often strict per-plan quotas; many are not designed for sustained 5,000/day production loads | JSON/text; some include timestamps if transcript provider supports them | Prototyping only; generally not ideal for mission-critical, large-scale newsletter production |

## Recommendation

For your use case, the best fit is **Google Gemini API paired with a transcript retrieval API/service**. It gives you the **REST API + strong Node.js support** you asked for, can reliably produce **300-word summaries and timestamped chapter breakdowns in structured JSON**, and is the most realistic path to staying near your budget **if you summarize transcripts rather than full video content**.

At **5,000 videos/day**, a true end-to-end “video summarizer API” will almost certainly blow past **$500/month**. The cost-effective production architecture is: **fetch captions/transcripts → send transcript chunks to Gemini → request structured summary + chapters**. If many videos lack captions, your budget constraint becomes the real blocker.

## Minimal example for top pick

### cURL
```bash
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=$GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -X POST \
  -d '{
    "contents": [{
      "parts": [{
        "text": "Summarize the following YouTube transcript in about 300 words and return timestamped chapter breakdowns. Return JSON with keys: summary, chapters. Each chapter should have start_time, title, and brief_description.\n\nTranscript:\n[00:00] Intro...\n[01:12] Main topic...\n[03:45] Key takeaway..."
      }]
    }],
    "generationConfig": {
      "response_mime_type": "application/json"
    }
  }'
```

### Node.js
```js
import { GoogleGenerativeAI } from "@google/generative-ai";

const client = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);

async function summarizeTranscript(transcript) {
  const model = client.getGenerativeModel({ model: "gemini-1.5-flash" });

  const prompt = `
Summarize the following YouTube transcript in about 300 words and return timestamped chapter breakdowns.
Return valid JSON with this shape:
{
  "summary": "string",
  "chapters": [
    {
      "start_time": "MM:SS",
      "title": "string",
      "brief_description": "string"
    }
  ]
}

Transcript:
${transcript}
`;

  const result = await model.generateContent(prompt);
  console.log(result.response.text());
}
```

If you want, I can also give you a **cost model for 5,000 videos/day** and a **recommended Node.js pipeline** for transcript fetching, chunking, retries, and JSON validation.

| Name | Summarization Method | Pricing Model | Rate Limits | Output Formats | Best For |
|------|-----------------------|---------------|-------------|----------------|----------|
| AssemblyAI (LeMUR) | Transcript (transcribes YouTube URL + LLM prompt) | Pay-per-use: STT $0.21/hour + LeMUR ~$0.001/1k input tokens, $0.0025/1k output tokens; volume discounts available | Sandbox: 100/hr; Production: scalable to millions/day (tiered plans/contact sales) | JSON (custom 300-word summary, timestamped chapters via prompt) | High-volume custom summaries/chapters with precise control; Node.js SDK |
| Gladia | Transcript (YouTube URL → built-in summary/chapters) | Pay-per-use: ~$0.12/min bundled (transcription + AI features like summary/chapters); $29/mo starter | 1,000 req/day free tier; scales to 10k+/day on paid | JSON (summary, chapters w/ timestamps, topics) | Out-of-box chapters & summaries; Node.js client |
| Deepgram | Transcript (YouTube URL → STT + summarize endpoint) | Pay-per-use: STT $0.146/hour (Nova-2); Summarization $0.015/min | Tiered: PayGo unlimited req, throttled by credits; enterprise unlimited | JSON (paragraph summary, topic detection w/ timestamps) | Fast, low-cost STT with basic summaries; Node.js SDK |
| Symbl.ai | Transcript (YouTube/video URL → conversation AI) | Pay-per-minute: $0.025-$0.10/min (volume tiers); $99/mo for ~2k min | High (100+ concurrent, millions/min on enterprise) | JSON (executive summary, timestamped topics/action items/chapters) | Insight-rich breakdowns for talks/podcasts; Node.js SDK |

**Recommendation**: For ingesting 5,000 YouTube videos daily into a newsletter tool requiring exact 300-word summaries and timestamped chapters under a $500/month budget, AssemblyAI is the top pick—its LeMUR LLM allows tailored prompts for precise outputs, excellent Node.js SDK, and scalable pricing (negotiate volume discounts; feasible for <3min avg videos at ~$300-450/month). Gladia is a close second for simpler integration with built-in chapters but less summary customization. Avoid longer videos without optimization, as full STT costs add up; consider YouTube auto-captions + cheap LLM for ultra-scale.

**Top pick example (AssemblyAI Python - pip install assemblyai)**:
```python
import assemblyai as aai
aai.settings.api_key = "your_api_key"

# Step 1: Transcribe
transcriber = aai.Transcriber()
transcript = transcriber.transcribe("https://youtube.com/watch?v=VIDEO_ID")

# Step 2: Summarize w/ chapters (300 words + timestamps)
config = aai.LemurConfig(
    prompt="""
    Produce a 300-word summary and 5-10 timestamped chapters (format: MM:SS - Title).
    Transcript: """ + transcript.text,
    language_code="en",
    temperature=0.1
)
lemur = aai.Lemur()
result = lemur.process(config)
print(result.output)  # JSON-like response
```