Bilibili Video API: Search, Details and Subtitle Extraction

python3 -m pip install requests
export JUSTONEAPI_TOKEN='your_token'

import json
import os
from datetime import datetime, timezone
from pathlib import Path

import requests

BASE_URL = "https://api.justoneapi.com"
TOKEN = os.environ.get("JUSTONEAPI_TOKEN", "")


def call_api(path, **params):
    try:
        response = requests.get(
            BASE_URL + path,
            params={"token": TOKEN, **params},
            timeout=120, allow_redirects=False,
        )
    except requests.RequestException:
        raise RuntimeError("API network error or timeout") from None
    if response.status_code != 200:
        raise RuntimeError(f"API HTTP {response.status_code}")
    try:
        result = response.json()
    except ValueError:
        raise RuntimeError("API response is not JSON") from None
    if not isinstance(result, dict) or result.get("code") != 0:
        code = result.get("code") if isinstance(result, dict) else None
        raise RuntimeError(f"API failed: code={code}; check the docs")
    data = result.get("data")
    if not isinstance(data, dict):
        raise RuntimeError("Unexpected data shape; inspect the docs")
    inner = data.get("base_resp")
    if isinstance(inner, dict) and inner.get("status_code") not in (0, "0"):
        raise RuntimeError("Platform response was unsuccessful")
    return result


def save_json(folder, name, value):
    (folder / name).write_text(
        json.dumps(value, ensure_ascii=False, indent=2), encoding="utf-8"
    )


def require_list(data, key):
    value = data.get(key)
    if not isinstance(value, list):
        raise RuntimeError(f"Expected a list at {key}; inspect saved JSON")
    return value


def output_folder(topic):
    if not TOKEN or TOKEN == "your_token":
        raise RuntimeError("Set JUSTONEAPI_TOKEN before running")
    run_id = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S%fZ")
    folder = Path(topic + "-output") / run_id
    folder.mkdir(parents=True, exist_ok=False)
    return folder


from urllib.parse import urlparse

KEYWORD = "Python 入门"
MAX_VIDEOS = 2


def download_subtitle(url):
    if url.startswith("//"):
        url = "https:" + url
    parsed = urlparse(url)
    host = parsed.hostname or ""
    if (parsed.scheme != "https" or parsed.username or parsed.password
            or parsed.port not in (None, 443)
            or not (host == "hdslb.com" or host.endswith(".hdslb.com"))):
        raise RuntimeError("Subtitle host needs manual review")
    try:
        response = requests.get(url, timeout=30, allow_redirects=False)
    except requests.RequestException:
        raise RuntimeError("Subtitle download failed") from None
    if response.status_code != 200:
        raise RuntimeError(f"Subtitle HTTP {response.status_code}")
    try:
        payload = response.json()
    except ValueError:
        raise RuntimeError("Subtitle response is not JSON") from None
    if not isinstance(payload, dict):
        raise RuntimeError("Unexpected subtitle document")
    segments = require_list(payload, "body")
    if any(not isinstance(s, dict) or not isinstance(s.get("content"), str)
           for s in segments):
        raise RuntimeError("Unexpected subtitle segment")
    return payload, "\n".join(s["content"] for s in segments)


def main():
    folder = output_folder("bilibili")
    result = call_api(
        "/api/bilibili/search-video/v2", keyword=KEYWORD,
        page="1", order="general",
    )
    save_json(folder, "search-1.json", result)
    search = result["data"]
    if search.get("code") != 0 or not isinstance(search.get("data"), dict):
        raise RuntimeError("Video search was unsuccessful")
    rows = require_list(search["data"], "result")
    ids, seen = [], set()
    for row in rows:
        bvid = row.get("bvid") if isinstance(row, dict) else None
        if bvid and str(bvid) not in seen:
            seen.add(str(bvid))
            ids.append(str(bvid))
    selected = ids[:MAX_VIDEOS]
    save_json(folder, "selected-videos.json", selected)
    outcomes = []
    for index, bvid in enumerate(selected, start=1):
        detail = call_api("/api/bilibili/get-video-detail/v2", bvid=bvid)
        save_json(folder, f"video-{index}-detail.json", detail)
        video = detail["data"].get("videoData")
        if not isinstance(video, dict) or not video.get("aid"):
            raise RuntimeError("Missing videoData/AID; inspect saved JSON")
        pages = require_list(video, "pages")
        if not pages or not isinstance(pages[0], dict) or not pages[0].get("cid"):
            raise RuntimeError("Missing segment CID; inspect saved JSON")
        cid = str(pages[0]["cid"])
        captions = call_api(
            "/api/bilibili/get-video-caption/v2",
            bvid=bvid, aid=str(video["aid"]), cid=cid,
        )
        save_json(folder, f"video-{index}-captions.json", captions)
        tracks = require_list(captions["data"], "data")
        if not tracks:
            outcomes.append({"bvid": bvid, "cid": cid, "status": "no_tracks"})
            continue
        track = tracks[0]
        url = track.get("subtitle_url") if isinstance(track, dict) else None
        if not isinstance(url, str) or not url:
            raise RuntimeError("Missing subtitle URL; inspect saved JSON")
        outcome = {"bvid": bvid, "cid": cid, "language": track.get("lan")}
        try:
            payload, text = download_subtitle(url)
        except (RuntimeError, ValueError) as error:
            outcome.update(status="download_failed", error=str(error))
        else:
            save_json(folder, f"video-{index}-subtitle.json", payload)
            (folder / f"video-{index}-subtitle.txt").write_text(text, encoding="utf-8")
            outcome["status"] = "downloaded" if text else "empty_text"
        outcomes.append(outcome)
    save_json(folder, "subtitle-outcomes.json", outcomes)
    print(f"Saved {len(selected)} video samples to {folder}")


if __name__ == "__main__":
    try:
        main()
    except RuntimeError as error:
        raise SystemExit(str(error)) from None

Summarize the main concepts using only the supplied subtitles.
For each point, include the supporting excerpt and its timestamp if provided.
Mark information absent from the subtitles as "not stated" instead of guessing.