Integrate a YouTube Summarizer with OpenClaw by building a small, authenticated external summarization service (fetches transcripts, chunks them, calls an LLM), hosting it with TLS and an API key or OAuth, then installing a thin OpenClaw skill via ClawHub that calls that service. Keep heavy or stateful work (transcript storage, long-running jobs, retries) outside the agent runtime; the agent should make simple REST calls and return structured results. Configure authentication (YouTube OAuth if you need private captions, OpenAI or LLM credentials for summarization, and a service API key for the OpenClaw-to-service call) in ClawHub as credentials/environment variables, and then test and debug by checking logs, API responses, token scopes, and skill invocation traces.

Overview: components and responsibilities

• External summarization service (required) — Responsible for pulling YouTube transcripts (public or private), chunking text, calling an LLM provider to summarize, and exposing a small authenticated REST API (e.g., POST /summarize).
• LM provider & credentials — API key or OAuth for the model you use (OpenAI, Anthropic, etc.). Stored as environment variables or in a secrets store; the external service uses them.
• YouTube access — Public transcripts can often be retrieved without OAuth using transcript scraping libraries; private captions require OAuth and appropriate YouTube Data API scopes (for private data use the official Google OAuth flow with youtube.readonly or captions scopes as required).
• OpenClaw skill (thin) — Deployed via ClawHub; authenticates to your external service (API key or signed token from ClawHub secrets) and simply forwards user input (YouTube URL, options) and returns the response to callers.
• Operational pieces (outside the agent) — Storage, queuing, retry/backoff, long jobs, and logs should be hosted externally (cloud functions, web servers, message queues, DBs).

Concrete external service example (working Python Flask)

This example is a practical external HTTP service you host. It:

• Accepts POST /summarize with {"youtube\_url":"..."}.
• Obtains the transcript using youtube_transcript_api.
• Chunks the transcript and summarizes each chunk via OpenAI’s chat completions API.
• Combines chunk summaries into a final concise summary and returns JSON.

Install dependencies:

# <b>//</b> install packages
pip install flask youtube-transcript-api openai

from flask import Flask, request, jsonify
from youtube_transcript_api import YouTubeTranscriptApi
import openai
import os
import re
import math

app = Flask(__name__)
openai.api_key = os.environ.get("OPENAI_API_KEY")  # <b>//</b> set this in environment

def extract_video_id(url_or_id):
    # accepts a raw id or a full YouTube URL
    m = re.search(r"(?:v=|\/)([0-9A-Za-z_-]{11})", url_or_id)
    if m:
        return m.group(1)
    if re.fullmatch(r"[0-9A-Za-z_-]{11}", url_or_id):
        return url_or_id
    raise ValueError("Invalid YouTube URL or ID")

def chunk_text(text, max_chars=3000):
    # naive character-based chunking; tune for tokens if needed
    chunks = []
    start = 0
    while start < len(text):
        end = min(start + max_chars, len(text))
        chunks.append(text[start:end])
        start = end
    return chunks

@app.route("/summarize", methods=["POST"])
def summarize():
    data = request.get_json() or {}
    youtube_url = data.get("youtube_url")
    if not youtube_url:
        return jsonify({"error": "youtube_url required"}), 400

    try:
        video_id = extract_video_id(youtube_url)
    except ValueError:
        return jsonify({"error": "invalid youtube url or id"}), 400

    # <b>//</b> Fetch transcript (may throw if not available)
    try:
        transcript_parts = YouTubeTranscriptApi.get_transcript(video_id)
    except Exception as e:
        return jsonify({"error": "transcript_unavailable", "details": str(e)}), 500

    full_text = " ".join(part.get("text", "") for part in transcript_parts).strip()
    if not full_text:
        return jsonify({"error": "empty_transcript"}), 500

    # <b>//</b> Chunk and summarize each chunk with the LLM
    chunks = chunk_text(full_text, max_chars=3000)
    chunk_summaries = []
    for c in chunks:
        resp = openai.ChatCompletion.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": "You are a concise summarization assistant. Produce short bullet-point summaries and a single-paragraph concise summary."},
                {"role": "user", "content": f"Summarize the following transcript chunk:\n\n{c}"}
            ],
            max_tokens=500,
            temperature=0.2
        )
        text = resp["choices"][0]["message"]["content"].strip()
        chunk_summaries.append(text)

    # <b>//</b> Combine chunk summaries into final summary
    combine_prompt = "Combine these chunk summaries into a final concise summary (first a single-paragraph summary, then 3 bullets with key takeaways):\n\n" + "\n\n---\n\n".join(chunk_summaries)
    final_resp = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": "You are a concise summarization assistant."},
            {"role": "user", "content": combine_prompt}
        ],
        max_tokens=600,
        temperature=0.2
    )
    final_summary = final_resp["choices"][0]["message"]["content"].strip()

    return jsonify({"summary": final_summary, "video_id": video_id})

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8080)

Sample request to the external service

curl -X POST "https://your-service.example.com/summarize" \
  -H "Authorization: Bearer YOUR_SERVICE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"youtube_url":"https://www.youtube.com/watch?v=VIDEO_ID"}'

How to wire this into OpenClaw (ClawHub + skill)

• Create the external service and host it — Deploy with HTTPS, put an API key in the service (or use OAuth). Store that API key in a secure place (cloud secret manager).
• Register credentials in ClawHub — Use ClawHub’s secure inputs or secrets mechanism (do not hard-code keys in the skill). Provide the external service URL and API key to the skill as environment variables or secrets.
• Implement a thin OpenClaw skill — The skill should accept high-level inputs (YouTube URL, summarization options) and make a single authenticated HTTP POST to your external service, then return the JSON result. Keep the skill simple: no heavy transcript scraping or LLM calls inside the agent runtime.
• Permissions and auth — If your external service requires an API key, send it in Authorization: Bearer or a custom header. If YouTube private data is needed, perform OAuth on your external service or via ClawHub’s OAuth setup and ensure the token is stored/revoked/rotated properly.
• Install/configure the skill via ClawHub — Upload the skill manifest/code, bind environment variables from secrets (external service URL, service API key), and grant the skill only the minimum permissions it needs.

When to use YouTube Data API / OAuth vs. scraping transcripts

• Public auto-generated captions — You can often use scraping libraries (youtube-transcript-api in Python) to get transcripts without OAuth. This is simpler but less reliable for private videos or some region-restricted content.
• Private captions or channel-owned captions — Use Google OAuth and the YouTube Data API with the appropriate scopes (for viewing private videos/captions you need user consent; common scope: https://www.googleapis.com/auth/youtube.readonly). Implement the OAuth flow on the external service or via a separate auth component; store refresh tokens securely.
• Respect rate limits — The YouTube Data API has quotas; the scraping approach may be rate-limited by YouTube. Design caching and backoff in your external layer.

Design & reliability considerations (what belongs outside the agent)

• Run transcripts & model calls externally — LLM calls and transcript fetching are I/O-heavy and possibly long-running; the OpenClaw agent should only orchestrate and call a REST endpoint.
• Persistence — Store transcripts, intermediate summaries, errors, and job status in an external DB if you need auditability or re-use.
• Long-running jobs — If summarization may exceed agent time limits, provide an async job interface (POST returns job\_id, you poll GET /jobs/{id}). Use queues (SQS, Pub/Sub) and workers to scale.
• Observability — Emit structured logs and request IDs. In the skill, pass a request ID header so you can correlate OpenClaw skill invocations with external service logs.

Testing and debugging checklist

• Verify credentials — Ensure OPENAI_API_KEY (or other LLM keys), YouTube OAuth tokens (if used), and the service API key are correctly set in environment/secrets.
• Check scopes — If private captions fail, confirm the OAuth scope covers the operation (youtube.readonly / captions as required) and that refresh tokens are valid.
• Test external service independently — Call /summarize directly with curl and confirm transcript retrieval and LLM summarization work end-to-end.
• Watch logs — External service logs should show transcript fetch results, LLM API responses, durations, and errors. Correlate with OpenClaw skill logs from ClawHub.
• Validate API responses — Return structured errors (HTTP 4xx/5xx, JSON error codes) so the skill can display clear messages to users.
• Rate limits and retries — Implement exponential backoff for transient LLM or YouTube API failures; surface permanent failures clearly to the skill caller.

Security checklist

• Use HTTPS — External service must be TLS-protected.
• Authenticate calls from OpenClaw — Use short-lived tokens or an API key stored in ClawHub secrets. Rotate keys periodically.
• Least privilege — Grant YouTube OAuth scopes only for the data needed. Grant the skill only the secrets/vars it needs.
• Validate webhooks & inputs — If your external service offers callbacks, validate signatures and origins.