Bibi

BibiGPT — AI Video & Audio Summarizer

Environment Check

Run scripts/bibi-check.sh first. It detects which mode is available:

If neither mode is available, see references/installation.md for setup instructions.

Payment fallback (China): if neither auth is set but the user has an Alipay account, BibiGPT may emit HTTP 402 Payment Required with a Payment-Needed header (AI 收 protocol). The agent can resolve this automatically by installing `@alipay/agent-payment`, or manually by directing the user to a one-off QR purchase. See references/billing-aipay.md.

Detect 402 deterministically: the bibi CLI prints a stable marker line [HTTP/402 Payment Required] to stderr before any human-readable prompt; direct HTTP callers get status 402 + Payment-Needed header. When either signal appears, route to references/billing-aipay.md instead of treating the call as failed.

Intent Routing

Route the user's request to the appropriate workflow:

Disambiguation

• If the user's intent matches more than one workflow, ask one clarifying question before routing.
• If it matches none, ask what they are trying to accomplish. Do not guess.
• If the user just pastes a URL with no context, default to workflows/quick-summary.md.

Local File Support

The bibi CLI directly accepts local file paths (no upload needed):

bibi summarize "/path/to/video.mp4"
bibi summarize "/path/to/podcast.mp3"

For API mode (no CLI), guide the user to upload the file to a publicly accessible URL (OSS, S3, etc.) first, then pass that URL to the API. See references/supported-platforms.md for details.

Direct CLI Operations

Use progressive help to discover options: bibi --help → bibi summarize --help → run.

For simple, single-command requests that don't need a full workflow:

bibi summarize "<URL>"              # Quick summary (URL or local file path)
bibi summarize "<URL>" --chapter    # Chapter summary
bibi summarize "<URL>" --subtitle   # Transcript only
bibi summarize "<URL>" --json       # Full JSON response
bibi auth check                     # Check auth status
bibi me                             # Get account, plan, remaining minutes
bibi commands                       # List all manifest-driven commands

See references/cli.md for all commands and flags.

References

BibiGPT OpenAPI Reference

Use these HTTP endpoints when the bibi CLI is not installed (Linux, containers, CI).

An auto-generated companion (references/endpoints.md) lists every

endpoint with curl examples — derived from the live OpenAPI spec

(https://bibigpt.co/api/openapi.json).

This file (api.md) is hand-curated for auth, decision tables, and

agent-friendly explanations. Use both together.

Base URL: https://api.bibigpt.co/api OpenAPI spec: https://bibigpt.co/api/openapi.json MCP Server: https://bibigpt.co/api/mcp (Streamable HTTP, OAuth 2.1)

Authentication

Every request MUST include both headers:

Authorization: Bearer $BIBI_API_TOKEN
x-client-type: bibi-cli

Get your token at: https://bibigpt.co/user/integration

The x-client-type: bibi-cli header identifies agent-skill channel calls. Paid members get 100 free calls/day before normal billing.

OAuth 2.0

Use bibigpt-skill as client_id with redirect URI http://localhost.

URL Encoding

URLs must be percent-encoded when passed as query params:

# Python
python3 -c 'import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1], safe=""))' "$URL"

# Node.js
node -e 'console.log(encodeURIComponent(process.argv[1]))' "$URL"

---

Endpoints

1. Summarize — GET /v1/summarize

MCP tool: summarize_video

curl -s "https://api.bibigpt.co/api/v1/summarize?url=ENCODED_URL" \
  -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "x-client-type: bibi-cli"

Response:

{
  "success": true,
  "id": "...",
  "service": "youtube",
  "sourceUrl": "...",
  "htmlUrl": "https://bibigpt.co/video/...",
  "summary": "Markdown summary...",
  "costDuration": 12.5,
  "remainingTime": 3600
}

2. Summarize with Config — POST /v1/summarizeWithConfig

MCP tool: summarize_video_with_config

curl -s -X POST "https://api.bibigpt.co/api/v1/summarizeWithConfig" \
  -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "x-client-type: bibi-cli" \
  -H "Content-Type: application/json" \
  -d '{"url":"VIDEO_URL","promptConfig":{"outputLanguage":"en-US","customPrompt":"Focus on key insights"}}'

3. Chapter Summary — GET /v1/summarizeByChapter

MCP tool: summarize_by_chapter

curl -s "https://api.bibigpt.co/api/v1/summarizeByChapter?url=ENCODED_URL" \
  -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "x-client-type: bibi-cli"

Response adds: title, chapters array (with start, end, content, summary), chapterSummary.

4. Get Subtitles — GET /v1/getSubtitle

MCP tool: get_subtitle

curl -s "https://api.bibigpt.co/api/v1/getSubtitle?url=ENCODED_URL" \
  -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "x-client-type: bibi-cli"

Subtitles returned in detail.subtitlesArray with timestamps.

5. Create Async Task — GET /v1/createSummaryTask

MCP tool: create_summary_task

curl -s "https://api.bibigpt.co/api/v1/createSummaryTask?url=ENCODED_URL" \
  -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "x-client-type: bibi-cli"
# → { "success": true, "taskId": "abc-123", "status": "pending" }

6. Poll Task Status — GET /v1/getSummaryTaskStatus

MCP tool: get_task_status

# Poll every 3s, max ~6 min
curl -s "https://api.bibigpt.co/api/v1/getSummaryTaskStatus?taskId=abc-123" \
  -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "x-client-type: bibi-cli"
# → status: "pending" | "completed" | "failed"

When status: "completed", the response includes the full summary result.

7. Polished Text — GET /v1/getPolishedText

Not MCP-enabled. Converts video subtitles into polished, readable paragraphs segment-by-segment.

curl -s "https://api.bibigpt.co/api/v1/getPolishedText?url=ENCODED_URL" \
  -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "x-client-type: bibi-cli"

Response:

{
  "success": true,
  "title": "...",
  "segments": [
    {
      "startTime": 0,
      "endTime": 120,
      "chapterTitle": "Introduction",
      "polishedText": "...",
      "fromCache": false
    }
  ],
  "costDuration": 10.5,
  "remainingTime": 3600
}

8. Express Article — GET /v1/express

Not MCP-enabled. Generates a full polished article from video content in one call.

curl -s "https://api.bibigpt.co/api/v1/express?url=ENCODED_URL&outputLanguage=zh-CN" \
  -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "x-client-type: bibi-cli"

Response:

{
  "success": true,
  "title": "...",
  "article": "Full polished article in Markdown...",
  "fromCache": false,
  "costDuration": 15.0,
  "remainingTime": 3600
}

9. Expand URL — GET /v1/expandUrl

Resolve shortened/redirected URLs to their full form.

curl -s "https://api.bibigpt.co/api/v1/expandUrl?url=ENCODED_SHORT_URL" \
  -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "x-client-type: bibi-cli"
# → { "url": "https://full-expanded-url..." }

10. Version — GET /version

No auth required.

curl -s "https://api.bibigpt.co/api/version"
# → { "version": "1.0.0" }

Saved library

List saved videos — GET /v1/library/list

Query params: limit (1–100, default 20), cursor (page number string), channelId, sortBy (createdAt | updatedAt), sortOrder (asc | desc).

curl -s "https://api.bibigpt.co/api/v1/library/list?limit=20" \
  -H "Authorization: Bearer $BIBI_API_TOKEN"
# → { "videos": [...], "nextCursor": "2", "total": 87 }

MCP tool: list_saved_videos.

Get saved video — GET /v1/library/get

curl -s "https://api.bibigpt.co/api/v1/library/get?id=CONTENT_ID" \
  -H "Authorization: Bearer $BIBI_API_TOKEN"
# → { "id":..., "title":..., "note":..., "summary":..., "chapters":null, "subtitles":null, ... }

MCP tool: get_saved_video. Returns chapters (when generated) and subtitles (when stored). For fresh transcripts of unstored videos, call get_subtitle.

Search saved videos — GET /v1/library/search

curl -s "https://api.bibigpt.co/api/v1/library/search?keyword=AI%20agents&limit=10" \
  -H "Authorization: Bearer $BIBI_API_TOKEN"
# → { "results": [{ "contentId":..., "title":..., "snippet":..., "matchType":"note" }], "count": 7 }

MCP tool: search_saved_videos. Searches title + note (ILIKE) in parallel with subtitle full-text (Postgres websearch_to_tsquery). Subtitle hits include the matched segment's timestamp so the agent can deep-link into the moment.

Advanced tools

All five mutations require write scope. Read-only tokens (scopes: ['read']) get 403 from the agent middleware.

# Notion connection status (works today)
curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/notion/status"

# Collection chat history
curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/collections/chatHistory?collectionId=..."

User notes

# List
curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/notes/list?limit=20"

# Update
curl -s -X POST -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"contentId":"...","text":"My polished summary"}' \
  "https://api.bibigpt.co/api/v1/notes/update"

Collections

# List owned + purchased
curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/collections/list?scope=all"

# Create
curl -s -X POST -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name":"AI Agents 2026","description":"Best of","isPublic":false}' \
  "https://api.bibigpt.co/api/v1/collections/create"
# → { "id": "..." }

Feed

GET /v1/feed — latest items from all subscribed channels.

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/feed?limit=20"
# → { "items": [{ "contentId", "channelId", "channelTitle", "title", "sourceUrl", "coverUrl", "publishedAt" }], "nextCursor": "..." }

Query params: since (ISO 8601, default 7 days ago), limit (1–100, default 20), cursor (use nextCursor from prior response). MCP tool: get_latest_feed.

Channel subscriptions

# List
curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/channels/list"

# Subscribe (POST JSON)
curl -s -X POST -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"channelUrl":"https://www.youtube.com/@VeritasiumZH"}' \
  "https://api.bibigpt.co/api/v1/channels/subscribe"

# Channel preview videos
curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/channels/videos?channelUrl=https%3A%2F%2Fwww.youtube.com%2F%40VeritasiumZH&limit=10"

Subscribe/unsubscribe respect plan quota — 403 returned when exceeded, with upgrade-link message.

11. Account / Quota — GET /v1/me

Get the current authenticated user's account, plan, and remaining minutes. Auth required.

curl -s "https://api.bibigpt.co/api/v1/me" \
  -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "x-client-type: bibi-cli"
# → {
#     "userId": "...",
#     "email": "user@example.com",
#     "plan": {
#       "tier": "pro",        // free | plus | pro | lifetime
#       "isPaidMember": true,
#       "expiresAt": "2027-01-15T00:00:00.000Z"
#     },
#     "remainingMinutes": 1280
#   }

MCP tool name: get_account_info. Use it to inform the user before they queue heavy work, or to suggest upgrading when minutes are low.

---

Error Handling

Typical Agent Workflow

# 1. Check token
test -n "$BIBI_API_TOKEN" || { echo "Set BIBI_API_TOKEN first"; exit 1; }

# 2. Encode URL
ENCODED=$(python3 -c 'import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1], safe=""))' "$VIDEO_URL")

# 3. Summarize
RESULT=$(curl -sf "https://api.bibigpt.co/api/v1/summarize?url=$ENCODED" \
  -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "x-client-type: bibi-cli")

# 4. Extract summary
echo "$RESULT" | jq -r '.summary'

Billing via Alipay AI收 (402 Payment Required)

BibiGPT supports the Alipay AI收 protocol for per-call agent payments. This is an HTTP-402-based standard (similar to the x402 protocol) that lets an agent autonomously pay for an API call without the user needing a BibiGPT subscription.

This is a fallback channel — if BIBI_API_TOKEN is set or the user is a BibiGPT member, calls go through the existing subscription / quota path and no 402 is emitted.

When 402 happens

A call returns HTTP 402 Payment Required only if all of these are true:

1. The route opted in to AI 收 (currently POST /v1/summarize; more endpoints roll out one at a time) 2. The call came in via the agent-skill channel (i.e., x-client-type: bibi-cli or the MCP server) 3. The caller has no active subscription / API token / free-quota credit

The response includes a Payment-Needed HTTP header (base64url-encoded JSON) that names the price, the resource being charged for, and the seller's signed challenge. The bibi CLI prints [HTTP/402 Payment Required] to stderr before the human-readable prompt — agent skills can grep for it to detect 402 deterministically.

What the agent should do

Option 1 — automated via Alipay AI 钱包 skill (recommended)

If your agent has @alipay/agent-payment installed, payment is automatic:

npx -y @alipay/agent-payment@latest install

After install, the agent will: 1. See the 402, ask the user to authorize via Alipay (one-time push or scan) 2. Retry the original BibiGPT call with a Payment-Proof header 3. BibiGPT verifies the proof via alipay.aipay.agent.payment.verify 4. Returns the resource and confirms fulfillment with Alipay

User experience: roughly one Alipay approval per API call (≈ ¥1).

Option 2 — manual (any agent)

If @alipay/agent-payment is not installed, the bibi CLI prints a prompt:

── 此次调用需要支付 ────────────────────────
  金额:     ¥1.00 (CNY)
  商品:     YouTube 视频总结
  卖家:     BibiGPT
  ...

Guide the user to:

• Visit https://bibigpt.co/shop?onDemand=true for a one-off purchase, or
• Install @alipay/agent-payment and retry

Detecting 402 from CLI output

The bibi CLI emits a stable marker line to stderr ahead of any human prompt:

[HTTP/402 Payment Required]

If an agent skill sees this line on stderr (or HTTP 402 from a direct API call), it should switch to the Alipay-AI-钱包 flow above. The marker appears on every code path that yields 402 — direct summarize, chapter, subtitle, async, and the generic bibi call dispatcher.

Caveats

• Trial-period limits: 个人商家 ≤ ¥50 / call, ≤ ¥1000 / day. Most BibiGPT

endpoints are priced ≤ ¥3 so this rarely matters.

• No sandbox: integration must be tested with real money (¥0.01 minimum).
• CNY only (mainland China). International users should keep using

BIBI_API_TOKEN (subscription) for now.

Pricing snapshot (subject to change)

Free for individual developers from 2026-04-15 through 2026-12-31 (Alipay zero-fee promo); 1% fee thereafter.

Troubleshooting

BibiGPT CLI Reference

The bibi command is available after installing the BibiGPT desktop app.

Help Discovery

The CLI supports progressive help — discover subcommands step by step:

bibi --help                # Global help: list all subcommands
bibi summarize --help      # Summarize-specific options, examples, output format
bibi auth --help           # Auth actions and environment variables

Each --help includes examples — pattern-match off those for fastest results.

Commands

Summarize

bibi summarize accepts both URLs and local file paths.

Important: URLs containing ? or & must be quoted to avoid shell glob errors.

# Basic summary (Markdown to stdout, progress to stderr)
bibi summarize "<URL>"

# Local file — audio or video on disk
bibi summarize "/path/to/video.mp4"
bibi summarize "/path/to/podcast.mp3"

# Async mode — recommended for long videos (>30 min)
bibi summarize "<INPUT>" --async

# Chapter-by-chapter summary
bibi summarize "<INPUT>" --chapter

# Subtitles/transcript only (no AI summary)
bibi summarize "<INPUT>" --subtitle

# Full JSON response
bibi summarize "<INPUT>" --json

# Combine flags
bibi summarize "<INPUT>" --chapter --json
bibi summarize "<INPUT>" --subtitle --json

Supported local formats: .mp4, .mkv, .avi, .mov, .webm, .mp3, .wav, .m4a, .flac, .ogg

Auth

bibi auth check         # Check login status
bibi auth login         # OAuth login via browser (saves token automatically)
bibi auth set-token <TOKEN>  # Set API token directly

Updates

bibi check-update       # Check for new version
bibi self-update        # Download and install latest

Version

bibi --version          # Print CLI version

Account & Quota

bibi me                  # Returns account, plan tier, remaining minutes (raw JSON)
bibi me --json           # Same but pretty-printed

Saved Library

bibi library list                                 # 20 most-recently updated saved videos
bibi library list --limit 50 --json
bibi library list --channelId <authorId>          # filter by channel
bibi library list --cursor "2"                    # next page
bibi library get --id <contentId> --json          # full detail incl. note + chapters + subtitles
bibi library search --keyword "AI agents"         # title/note ILIKE + subtitle full-text

Channel Subscriptions

bibi channels list --json
bibi channels subscribe --channelUrl "https://www.youtube.com/@..." --json
bibi channels unsubscribe --channelUrl "https://www.youtube.com/@..." --json
bibi channels videos --channelUrl "https://..." --limit 10 --json

subscribe / unsubscribe are mutations (write scope); list / videos are read-only.

Feed

bibi feed --json                          # since last_seen_at (default), up to 20 items
bibi feed --since 2026-05-01 --limit 50   # explicit window
bibi feed --cursor "2026-05-04T12:00:00Z" # paginate via prior nextCursor
bibi feed-mark-seen --json                # bump last_seen_at on all subscribed channels
bibi feed-mark-seen --channelUrl "https://..." --json  # bump just one channel

Collections

bibi collections list --scope all --json                                     # owned + purchased
bibi collections get --id <collectionId> --json
bibi collections create --name "AI Agents 2026" --isPublic false --json     # write scope
bibi collections add-item --collectionId <id> --contentId <contentId> --json # write scope
bibi collections add-item --collectionId <id> --sourceUrl "https://..." --json

Notes

bibi notes list --limit 20 --json                       # cursor by updated_at desc
bibi notes list --cursor "2026-05-04T12:00:00Z" --json
bibi notes get --contentId <contentId> --json
bibi notes update --contentId <contentId> --text "..." --json   # write scope

Advanced Tools

bibi video mindmap --contentId <id> --summary "..." --json          # generate XMind file
bibi video visuals --videoUrl "https://..." --json                  # PPT + OCR + slides task (Pro)
bibi summary by-prompt --contentId <id> --customPrompt "..." --json # re-summarize with custom prompt
bibi notion status --json                                           # check Notion connection
bibi notion export-note --contentId <id> --json                     # push saved note to Notion
bibi collections chat-history --collectionId <id> --json            # cached chat history

Discovery and escape hatch

bibi --help                                # Static help + cached manifest commands
bibi commands                              # Re-fetch manifest and list all server-defined commands
bibi call <PROCEDURE> [--key value ...]    # Escape hatch — invoke by dotted procedure name
bibi call --help                           # When you need it

bibi --help reads the local manifest cache; if no commands are listed yet, run bibi commands once after bibi auth login to populate it. The CLI auto-refreshes the manifest every 24 h, so new server-side procedures are usable without bibi self-update.

Skill installation

bibi skill                       # Print bundled SKILL.md to stdout
bibi skill mcp-config            # Print MCP client config snippet (JSON)
bibi skill --install             # Install to ~/.claude/skills/bibi/SKILL.md
bibi skill --install --target claude   # Explicit target

For the full skill (references + workflows): npx skills add JimmyLv/bibigpt-skill.

Output

Pipe-friendly:

bibi summarize "<URL>" > summary.md
bibi summarize "<URL>" --json | jq '.summary'
bibi summarize "<URL>" --subtitle > transcript.txt

Exit Codes

Environment Variables

OpenAPI Endpoints

Auto-generated. Do not edit by hand. Regenerate via:

```bash

bun packages/bibigpt-core/scripts/sync-skill-endpoints.ts --write

```

>

The companion references/api.md is hand-curated for auth, decision tables,

and agent-friendly explanations. Use both together.

Spec: BibiGPT OpenAPI 规范 (v1.1.0)

agent

GET /v1/channel/health

Probe RSS health for every subscribed channel

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/channel/health"

GET /v1/channels/list

List subscribed channels

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/channels/list"

POST /v1/channels/subscribe

Subscribe to a channel by URL

curl -s -X POST -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ ... }' \
  "https://api.bibigpt.co/api/v1/channels/subscribe"

POST /v1/channels/unsubscribe

Unsubscribe from a channel

curl -s -X POST -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ ... }' \
  "https://api.bibigpt.co/api/v1/channels/unsubscribe"

GET /v1/channels/videos

Latest videos from a channel

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/channels/videos?channelUrl=<channelUrl>&limit=<limit>"

POST /v1/collections/addItem

Add a saved video to a collection

curl -s -X POST -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ ... }' \
  "https://api.bibigpt.co/api/v1/collections/addItem"

GET /v1/collections/chatHistory

Get cached chat history for a collection

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/collections/chatHistory?collectionId=<collectionId>"

POST /v1/collections/create

Create a new collection

curl -s -X POST -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ ... }' \
  "https://api.bibigpt.co/api/v1/collections/create"

GET /v1/collections/get

Get a collection with its items

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/collections/get?id=<id>"

GET /v1/collections/list

List user collections (owned + purchased)

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/collections/list?limit=<limit>&cursor=<cursor>&scope=<scope>"

GET /v1/feed

Latest videos across all subscribed channels (live RSS)

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/feed?since=<since>&limit=<limit>&cursor=<cursor>"

POST /v1/feed/markSeen

Bump last-seen cursor for one or all subscribed channels

curl -s -X POST -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ ... }' \
  "https://api.bibigpt.co/api/v1/feed/markSeen"

GET /v1/library/get

Get a saved video with summary, chapters, subtitles, note

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/library/get?id=<id>"

GET /v1/library/list

List saved videos with pagination

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/library/list?limit=<limit>&cursor=<cursor>&channelId=<channelId>&sortBy=<sortBy>&sortOrder=<sortOrder>"

GET /v1/library/search

Search across saved videos (title, subtitles, notes)

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/library/search?keyword=<keyword>&limit=<limit>"

GET /v1/me

Get current account, plan and remaining minutes

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/me"

GET /v1/notes/get

Get a single note by content id

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/notes/get?contentId=<contentId>"

GET /v1/notes/list

List user notes across all saved videos

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/notes/list?limit=<limit>&cursor=<cursor>"

POST /v1/notes/update

Create or update a note for a saved video

curl -s -X POST -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ ... }' \
  "https://api.bibigpt.co/api/v1/notes/update"

POST /v1/notion/exportNote

Export a saved video summary to Notion

curl -s -X POST -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ ... }' \
  "https://api.bibigpt.co/api/v1/notion/exportNote"

GET /v1/notion/status

Check whether the user has connected Notion

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/notion/status"

POST /v1/summary/byPrompt

Re-summarize a saved video with a custom prompt

curl -s -X POST -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ ... }' \
  "https://api.bibigpt.co/api/v1/summary/byPrompt"

POST /v1/video/mindmap

Generate XMind mindmap from a saved video summary

curl -s -X POST -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ ... }' \
  "https://api.bibigpt.co/api/v1/video/mindmap"

POST /v1/video/visuals

Create / look up a visual analysis task for a video

curl -s -X POST -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ ... }' \
  "https://api.bibigpt.co/api/v1/video/visuals"

open

GET /v1/createSummaryTask

Submit video summary processing task

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/createSummaryTask?url=<url>"

GET /v1/expandUrl

Expand shortened video or audio URLs

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/expandUrl?url=<url>"

GET /v1/express

Rewrite video subtitles as a polished article

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/express?url=<url>&includeDetail=<includeDetail>&outputLanguage=<outputLanguage>&model=<model>"

GET /v1/getPolishedText

Polish video subtitles into readable article segments

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/getPolishedText?url=<url>&includeDetail=<includeDetail>&keywords=<keywords>"

GET /v1/getSubtitle

Only returns the video subtitles array in detail

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/getSubtitle?url=<url>&audioLanguage=<audioLanguage>&transcribeProvider=<transcribeProvider>&whisperPrompt=<whisperPrompt>&apiKey=<apiKey>&enabledSpeaker=<enabledSpeaker>"

GET /v1/getSummaryTaskStatus

Check task status and get result if completed

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/getSummaryTaskStatus?taskId=<taskId>&includeDetail=<includeDetail>"

GET /v1/summarize

Generate video or audio summary from url

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/summarize?url=<url>&includeDetail=<includeDetail>"

POST /v1/summarize

Generate video or audio summary from url (POST variant for agent payment)

curl -s -X POST -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ ... }' \
  "https://api.bibigpt.co/api/v1/summarize"

GET /v1/summarizeByChapter

Generate chapter summary for url

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/v1/summarizeByChapter?url=<url>&includeDetail=<includeDetail>&outputLanguage=<outputLanguage>"

POST /v1/summarizeWithConfig

Generate configurable summary from url based on prompt config

curl -s -X POST -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ ... }' \
  "https://api.bibigpt.co/api/v1/summarizeWithConfig"

GET /version

Get the version of the API

curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://api.bibigpt.co/api/version"

Installation & Setup

1. Install the Skill

Claude Code

npx skills add JimmyLv/bibigpt-skill

OpenClaw / Other Agents

npx skills add JimmyLv/bibigpt-skill --agents <agent-name> --yes

Cursor (manual install)

The bundled CLI can install the skill body directly:

bibi skill --install --target cursor

Codex CLI (manual install)

bibi skill --install --target codex

For other clients, copy the bibi skill --print output into your skill / rules system.

2. Install BibiGPT Desktop App (for CLI mode)

macOS (Homebrew)

brew install --cask jimmylv/bibigpt/bibigpt

Windows

winget install BibiGPT --source winget

Linux

curl -fsSL https://bibigpt.co/install.sh | bash

Or download from: https://bibigpt.co/download/desktop

Verify:

bibi --version

3. Authentication

Option A — CLI Login (recommended)

bibi auth login

Opens your browser for OAuth login, then automatically saves the API token to the CLI. No manual copy-paste needed.

Option B — Desktop App Login

Log in via the BibiGPT desktop app GUI. The CLI reads the saved session automatically.

Option C — API Token (manual)

1. Visit https://bibigpt.co/user/integration (API Token section) 2. Copy your token 3. Set environment variable:

export BIBI_API_TOKEN="<your-token>"

Option D — OAuth 2.0 (programmatic)

For custom integrations:

Use bibigpt-skill or bibigpt-desktop as client_id with redirect URI http://localhost.

4. Verify Setup

# CLI mode
bibi auth check

# API mode
curl -sf "https://api.bibigpt.co/api/version" \
  -H "Authorization: Bearer $BIBI_API_TOKEN"

5. MCP Server (Alternative — No CLI Required)

BibiGPT also provides a remote MCP server for any MCP-compatible client:

URL: https://bibigpt.co/api/mcp (Streamable HTTP, OAuth 2.1)

Claude Code

claude mcp add --transport http bibigpt https://bibigpt.co/api/mcp

Cursor

Add to .cursor/mcp.json:

{
  "mcpServers": {
    "bibigpt": { "url": "https://bibigpt.co/api/mcp", "type": "streamable-http" }
  }
}

Claude Desktop

Settings → Connectors → Add Connector → paste https://bibigpt.co/api/mcp

VS Code (Copilot)

Add .vscode/mcp.json:

{
  "servers": {
    "bibigpt": { "type": "http", "url": "https://bibigpt.co/api/mcp" }
  }
}

See README.md for full MCP setup instructions for all clients.

6. Updates

BibiGPT ships three independently updateable layers. Pick the one that matches what you want refreshed.

A. Skill content (workflows + references) — npx skills

The skill does not auto-update — Agents read whatever was last fetched. Re-run when you want new BibiGPT capabilities, fixed workflows, or new MCP tools surfaced:

npx skills update JimmyLv/bibigpt-skill

For a clean reinstall (rare, e.g. after big breaking changes):

npx skills remove JimmyLv/bibigpt-skill
npx skills add    JimmyLv/bibigpt-skill

The BibiGPT changelog on GitHub Releases lists what each version added — useful before/after update to see what's new.

Recommended cadence: weekly, or any time the BibiGPT changelog mentions new MCP tools / agent endpoints.

B. Bibi desktop CLI binary — bibi self-update

The CLI binary embeds a snapshot of SKILL.md (used by bibi skill --print/--install) and ships the manifest dispatcher (bibi <resource> <action>, bibi commands, bibi skill). Update both at once:

bibi check-update    # peek at the latest published version
bibi self-update     # download + install (uses brew on macOS, installer on Windows)

Or via your OS package manager:

Manifest is hot-cached, not embedded. Even without bibi self-update, the CLI dispatcher fetches https://bibigpt.co/api/cli-manifest.json on first call (24h TTL), so newly-released agent procedures show up the next day. bibi self-update only matters when the dispatcher itself or the embedded SKILL.md changes.

C. Remote MCP server — automatic

The MCP endpoint at https://bibigpt.co/api/mcp always serves the latest tool list (filtered by meta.mcp.enabled). MCP clients re-discover tools on every session — no manual update needed. If you don't see a new tool, restart your client (Claude Desktop / Cursor / etc.) to refresh its tools/list cache.

Decision matrix

Supported Platforms & URL Types

Supported Platforms

Duration & Async Mode

Async mode creates a background task. Poll getSummaryTaskStatus every 3 seconds until status: "completed" (max ~6 min).

Language Support

• Auto-detection: BibiGPT detects the audio language automatically
• Subtitle languages: Supports all languages available on the platform
• Output language: Configurable via outputLanguage param (e.g., zh-CN, en-US, ja, ko)
• Speaker identification: Enable with enabledSpeaker=true (API) for multi-speaker content

Local Files

CLI Mode (Recommended)

The bibi CLI directly accepts local file paths — no upload needed:

bibi summarize "/path/to/video.mp4"
bibi summarize "/path/to/podcast.mp3" --chapter

Supported formats:

• Audio: .mp3, .wav, .m4a, .flac, .ogg
• Video: .mp4, .mkv, .avi, .mov, .webm

API Mode (No Direct File Upload)

The OpenAPI endpoints only accept URLs, not local files. To summarize a local file via API:

1. Upload the file to any publicly accessible storage (e.g., OSS, S3, Cloudflare R2, or any file hosting) 2. Get the public URL 3. Pass the public URL to the API:

curl -s "https://api.bibigpt.co/api/v1/summarize?url=ENCODED_PUBLIC_URL" \
  -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "x-client-type: bibi-cli"

If the user has a local file and no CLI installed, guide them to:

• Upload to a cloud storage service first
• Or install the BibiGPT desktop app to use CLI mode directly

Platform-Specific Notes

• Bilibili: Short links (b23.tv/xxx) are auto-expanded. Use expandUrl API if you need the full URL first
• Twitter/X: Only video tweets are supported; text-only tweets return an error
• Xiaohongshu: Short links (xhslink.com/xxx) are auto-expanded
• Podcasts: All three podcast platforms (Apple, Spotify, Xiaoyuzhou) extract audio transcripts
• YouTube Shorts: Treated the same as regular YouTube videos

Workflow: Account & Quota Check

Use this when the user asks about their BibiGPT plan, member status, or remaining summarization minutes.

Triggers

• "What's my plan?"
• "How many minutes do I have left?"
• "Am I a Pro member?"
• "我还剩多少分钟？"
• "我的账户是什么套餐？"
• "查询我的剩余额度"
• "Show my BibiGPT account info"

Environment Check

Run scripts/bibi-check.sh to confirm CLI or API mode is available. Authentication is required (this is per-user data).

Steps

CLI mode (preferred)

bibi me --json

Output (example):

{
  "userId": "...",
  "email": "...",
  "plan": {
    "tier": "pro",
    "isPaidMember": true,
    "expiresAt": "2027-01-15T00:00:00.000Z"
  },
  "remainingMinutes": 1280
}

API mode

curl -H "Authorization: Bearer $BIBI_API_TOKEN" \
  https://bibigpt.co/api/v1/me

Same JSON shape as CLI.

Output formatting

Present the result conversationally:

你目前是 Pro 会员，到期时间 2027-01-15，剩余 1280 分钟。

For free users, suggest the upgrade page if they're running low:

你是免费用户，剩余 12 分钟。如需更多时长，可访问 https://bibigpt.co/shop?onDemand=true 升级或购买时长。

Error handling

• 401 Unauthorized: Run bibi auth check then bibi auth login (CLI) or set BIBI_API_TOKEN (API).
• Network error: Check connection; the endpoint is https://bibigpt.co/api/v1/me.

Plan tiers

Workflow: Advanced Tools (Mindmap / Visuals / By-Prompt / Notion / Chat)

Higher-value but lower-frequency capabilities. Each maps to a single CLI invocation or MCP tool call; pick by intent.

Triggers and routing

Steps

1. Notion connection status

bibi notion status --json
# → { "connected": true, "workspaceId":..., "workspaceName":..., "email":... }

If connected is false, surface this guide to the user:

Notion 还没连接。请到 https://bibigpt.co/user/integration → Notion 完成 OAuth 授权。

2. Collection chat history

bibi collections chat-history --collectionId <id> --json
# → { "messages": [...], "suggestedQuestions": [...], "updatedAt": "..." }

Returns prior chat messages and AI-suggested questions. Use this to summarize what the user has already discussed about a collection before generating new questions or extending the conversation.

3. Notion export

bibi notion export-note --contentId <id> --json
# → { "success": true, "pageUrl": "https://www.notion.so/..." }

Validates that the note exists and Notion is connected, then creates a new Notion page in the bound database. Returns the page URL on success.

Working examples

Mindmap

bibi video mindmap \
  --contentId <contentId> \
  --summary "$(bibi notes get --contentId <contentId> --json | jq -r .note)" --json
# → { "fileUrl": "https://...storage.../<userId>/<contentId>.xmind" }

Cached per (user, contentId). Pass --isRefresh true to regenerate.

Visual analysis

# 1. Create the task (Pro-only; rate-limited)
bibi video visuals --videoUrl "https://..." --json
# → { "taskId":..., "status": "pending"|"processing"|"completed"|... }

# 2. Poll for completion (legacy procedure — agent wrapper coming)
curl -s -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://bibigpt.co/api/trpc/vision.getVideoProcessingTask?input=$(printf %s '{"json":{"taskId":"..."}}' | jq -sRr @uri)"

Custom-prompt summary

bibi summary by-prompt \
  --contentId <contentId> \
  --customPrompt "Top 3 actionable insights" \
  --outputLanguage zh-CN --json
# → { "summary": "...", "fromCache": false }

Side effect: overwrites the user's saved note for this video. Use /v1/summarizeWithConfig directly if you don't want the note clobbered.

Notion export

bibi notion status --json                  # confirm connection
bibi notion export-note --contentId <contentId> --json
# → { "success": true, "pageUrl": "https://www.notion.so/..." }

Notes

• All five tools are mutations with agent.scope = 'write'; require a token with write scope. Read-only tokens get 403.
• Custom-prompt summary clobbers user_contents_note; use /v1/summarizeWithConfig directly when you need a one-shot generation that doesn't touch the saved note.

Article Rewrite

Transform video or audio content into a polished article — directly on the agent side using the transcript, no extra API call needed.

Triggers

"turn into article", "write blog post from video", "AI改写", "公众号图文", "video to blog", "rewrite as article", "小红书文案", "newsletter from video", "twitter thread"

Steps

1. Get the Transcript

If you already have the transcript/subtitles from a previous step, use it directly.

Otherwise, fetch it first:

CLI mode:

bibi summarize "<URL>" --subtitle --json

API mode:

ENCODED=$(python3 -c 'import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1], safe=""))' "$URL")
curl -s "https://api.bibigpt.co/api/v1/getSubtitle?url=$ENCODED" \
  -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "x-client-type: bibi-cli"

Also get the summary for context if available (via workflows/quick-summary.md).

2. Clarify Article Style

Ask the user which format they want:

3. Rewrite Directly as the Agent

You already have the transcript. Do not call the API — rewrite the content yourself following the prompt guidelines below.

For Full Article (公众号/Blog)

Act as an expert copywriter specializing in content optimization for video. Transform the transcript into a well-structured, engaging Markdown article.

Article goals:

• Extract and present core viewpoints, arguments, and examples accurately
• Distill and synthesize — do NOT transcribe word-by-word
• Cover ALL content completely — do not summarize only partial sections

Article structure:

• Title: Concise, compelling, includes keywords
• Pyramid structure: Conclusion first, then supporting details
• 3-5 secondary headings (H2): Each covers a major content section
• Under each heading: summarize the key point first, then elaborate step-by-step
• Conclude each section with a synthesis

Style:

• Preserve the original creator's expression style — do not over-edit
• Use Markdown with sub-headings
• Output in the user's requested language (default: same as source)

Template:

# [Compelling Title]

[Opening paragraph — core thesis / hook]

## [Section 1 Heading]
[Key point summary]
[Detailed elaboration...]

## [Section 2 Heading]
[Key point summary]
[Detailed elaboration...]

## [Section 3 Heading]
...

## Summary
[Key takeaways]

For Twitter/X Thread

Transform the video content into a Chinese tweet thread:

• Hook first: The opening tweet must grab curiosity like a "钩子"
• High density: Each tweet = one core insight, no info overload
• Minimal emoji: Max 1-2 emoji for emphasis, avoid exclamation marks
• Logical flow: Use questions as transitions between tweets for rhythm
• Strong close: Final tweet summarizes or poses an open question for discussion
• CTA: Encourage likes, retweets, comments, or follows
• 1-2 relevant #Hashtags for discoverability

Format:

1/ [Hook tweet — grab attention]
---
2/ [Core insight 1]
---
3/ [Core insight 2]
...
7/ [Summary + CTA] #Hashtag1 #Hashtag2

• Max 7 tweets
• Max 280 chars (English) or 140 chars (Chinese) per tweet

For Social Media Copy (小红书)

• Condensed key points with visual-friendly formatting
• Short paragraphs, bullet points
• Conversational tone
• Include relevant tags/keywords at the end

For Plain Readable Text

Polish the transcript into readable paragraphs:

• Add proper punctuation
• Fix transcription errors (common with Whisper ASR: homophones, filler words)
• Remove filler words (呃, 诶, 哎, 啊, 然后, 那种, 其实, 可能, 比较, 这个)
• Add paragraph breaks at natural topic shifts
• Bold formatting: Only bold complete phrases/sentences (core conclusions), max 1-2 per paragraph, never bold single words
• Preserve original expression and timestamps

4. Present the Result

• Show the rewritten article in Markdown
• Include source attribution: original video title + URL
• If the user specified a language, ensure output matches

5. Follow-up Options

• "Save to Notion or Obsidian" → workflows/export-notes.md
• "Get the original transcript" → workflows/transcript-extract.md
• "Summarize another video" → workflows/quick-summary.md
• "Rewrite in a different style" — re-run step 3 with a different format
• "Translate to another language" — re-run with target language specified

Batch Process

Process multiple URLs sequentially. Ideal for content teams, researchers, or API users.

Triggers

"summarize all these", "batch", "process these URLs", "批量总结", "summarize these videos", "process multiple links"

Steps

1. Environment Check

Run scripts/bibi-check.sh to detect available mode. Async mode is recommended for batch processing to avoid timeouts.

2. Collect URLs

• Parse the user's message for multiple URLs
• Present the list back and confirm:

Found N URLs to process:
1. [URL 1] (YouTube)
2. [URL 2] (Bilibili)
3. [URL 3] (Podcast)

Proceed with batch summarization?

• If any URL looks unsupported, flag it (see references/supported-platforms.md)

3. Estimate Cost

• Each URL costs duration-based quota (minutes of content)
• Warn the user about total estimated quota usage
• If quota is limited, suggest processing in priority order

4. Process Loop

For each URL, execute in sequence:

CLI mode:

for URL in "${URLS[@]}"; do
  echo "Processing: $URL"
  bibi summarize "$URL" --json
  echo "---"
done

API mode (prefer async for batch):

# Step 1: Create all tasks
for URL in "${URLS[@]}"; do
  ENCODED=$(python3 -c 'import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1], safe=""))' "$URL")
  curl -s "https://api.bibigpt.co/api/v1/createSummaryTask?url=$ENCODED" \
    -H "Authorization: Bearer $BIBI_API_TOKEN" \
    -H "x-client-type: bibi-cli"
done

# Step 2: Poll each task until all complete

Report progress after each URL completes:

[1/5] ✓ "Video Title" — 12 min summary
[2/5] Processing...

5. Compile Results

Present all summaries in a structured format:

# Batch Summary (N videos)

## 1. [Video Title]
**Source**: [platform] | **Duration**: [X min]
[Summary]

## 2. [Video Title]
**Source**: [platform] | **Duration**: [X min]
[Summary]

...

**Total quota used**: X minutes | **Remaining**: Y minutes

6. Follow-up Options

• "Save all to Notion" → workflows/export-notes.md
• "Compare these videos" → workflows/research-compile.md
• "Get detailed chapters for video #N" → workflows/deep-dive.md
• "Turn video #N into an article" → workflows/article-rewrite.md

Workflow: Channel Subscriptions

Use this when the user wants to manage which YouTube/Bilibili/podcast channels they're subscribed to in BibiGPT, or to preview a channel's recent videos before deciding to subscribe.

Triggers

• "List my subscribed channels"
• "Subscribe to <channel URL>"
• "Unsubscribe from <channel>"
• "Show me the latest videos on <channel>"
• "我订阅了哪些频道"
• "把这个频道加进我的订阅"
• "取消订阅"

Steps

1. List subscribed channels

bibi channels list --json

Returns { channels: [{ id, title, url, platform, logoUrl, description, lastSummarizedAt }] }. The platform field is best-effort (youtube / bilibili / xiaoyuzhou / etc.) derived from the URL host.

2. Subscribe to a channel

bibi channels subscribe --channelUrl "https://www.youtube.com/@VeritasiumZH" --json
# → { "channelId": "..." }

Subscription is subject to plan quota. Free / Plus users have a lower per-account cap; Pro / Lifetime have higher. If quota is exceeded, the API returns 403 with a clear message — surface it to the user with the upgrade link.

Optional --author "Name" if the channel needs a manual author label.

3. Unsubscribe

bibi channels unsubscribe --channelUrl "https://www.youtube.com/@..." --json
# → { "success": true }

4. Preview channel videos (RSS)

bibi channels videos --channelUrl "https://www.youtube.com/@VeritasiumZH" --limit 10 --json

Returns { title, description, videos: [{ id, title, url, publishedAt, coverUrl }] } from the RSSHub feed. Use this to preview before subscribing, or to inspect what's new on a channel without it being in the user's library yet.

Output formatting

For lists, render a Markdown table or compact list with title + platform + lastSummarizedAt. For subscribe/unsubscribe, confirm with a one-line success line.

Common follow-ups

• "Which channel haven't I summarized recently" → call channels.list and sort by lastSummarizedAt (when populated)
• "What's new in my feed" → use get_latest_feed instead, which aggregates across all subscribed channels

Notes

• channels.subscribe and channels.unsubscribe are mutations and require write scope. Read-only API tokens cannot subscribe/unsubscribe.
• lastSummarizedAt may be null for newly subscribed channels with no summarized videos yet.

Workflow: Collections (Curated Video Sets)

Use when the user wants to organize saved videos into collections — think Pinterest boards, Notion databases, or YouTube playlists. Collections can be private to the user, public for sharing, or paid (sold to other users).

Triggers

• "Make a collection of these videos"
• "Show my collections"
• "Add this video to <collection>"
• "我创建的合集"
• "把这个视频加进 X 合集"
• "Open my purchased collections"

Steps

1. List collections

bibi collections list --json                   # default: scope=all (owned + purchased)
bibi collections list --scope owned --json
bibi collections list --scope purchased --json
bibi collections list --limit 50 --json

Returns { collections: [{ id, name, slug, isPublic, videoCount, coverUrl, ownership }], nextCursor }. ownership is "owned" or "purchased".

2. Get collection details (with items)

bibi collections get --id <collectionId> --json

Returns { id, name, description, isPublic, ownership, items: [<savedVideoSummary>], aggregatedSummary }. Authorization: owner can always view; non-owner needs an active purchase OR the collection must be public.

3. Create a collection

bibi collections create --name "AI Agents 2026" --description "Best videos this year" --isPublic false --json
# → { "id": "..." }

Mutation; requires write scope.

4. Add a video to a collection

# By contentId (preferred — already in your library)
bibi collections add-item --collectionId <id> --contentId <contentId> --json

# By sourceUrl (must already be in your library; will return 404 if you haven't summarized it)
bibi collections add-item --collectionId <id> --sourceUrl "https://..." --json

Adding the same video twice is idempotent (returns { success: true }). To import a video first, run bibi summarize <URL> then add by contentId.

Error handling

• 403 FORBIDDEN on collections.get: collection is private and not owned/purchased — confirm to the user.
• 404 NOT_FOUND on collections.add-item with sourceUrl: the URL is not in their library — suggest bibi summarize <URL> first.
• 403 FORBIDDEN on collections.add-item: only the collection owner can add items.

Output formatting

For lists, render a Markdown table with name + videoCount + ownership badge. For details, lead with the description, then list items with title + sourceUrl.

Notes

• collections.create and collections.add-item are mutations (write scope).
• list is cursor-paginated by effective-created-at across owned + purchased collections.
• aggregatedSummary is populated by a background job; null for newly-created collections.

Deep Dive

Get a chapter-by-chapter summary with timestamps, then optionally ask follow-up questions about specific sections.

Triggers

"chapter summary", "break down by section", "detailed summary", "分章节总结", "逐章总结", "what topics does this cover"

Steps

1. Environment Check

Run scripts/bibi-check.sh to detect available mode.

2. Get Chapter Summary

CLI mode:

bibi summarize "<URL>" --chapter

API mode:

ENCODED=$(python3 -c 'import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1], safe=""))' "$URL")
curl -s "https://api.bibigpt.co/api/v1/summarizeByChapter?url=$ENCODED" \
  -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "x-client-type: bibi-cli"

Optional: add &outputLanguage=en-US (or other language code) for translated output.

See references/api.md endpoint #3 for full details.

3. Present Results

Format each chapter as:

## Chapter 1: [Title] (00:00 – 05:30)
[Chapter summary]

## Chapter 2: [Title] (05:30 – 12:15)
[Chapter summary]
...

If chapters array is empty, fall back to the overall chapterSummary text and explain that the video did not have chapter markers.

4. Interactive Q&A

If the user wants to go deeper into a specific chapter:

1. Use the returned subtitle data (from includeDetail=true) as context 2. Answer follow-up questions about specific sections 3. Reference timestamps when quoting content

For example:

• "What exactly did they say about X in chapter 3?"
• "Can you elaborate on the point at 15:30?"

5. Follow-up Options

• "Get the full transcript" → workflows/transcript-extract.md
• "Turn a specific chapter into an article" → workflows/article-rewrite.md
• "Compare with another video on the same topic" → workflows/research-compile.md
• "Save these notes" → workflows/export-notes.md

Export Notes

Save summaries, transcripts, or articles to external tools or local files.

Triggers

"save to Notion", "export to Obsidian", "save notes", "导出笔记", "save this summary", "download as markdown", "copy to clipboard"

Steps

1. Determine Content to Export

• If there is already a summary/transcript/article from this session → use it
• If not → ask the user what they'd like to export and run the appropriate workflow first:
• Summary → workflows/quick-summary.md
• Chapters → workflows/deep-dive.md
• Transcript → workflows/transcript-extract.md
• Article → workflows/article-rewrite.md

2. Choose Destination

Ask the user where to save:

3A. Local Markdown / Obsidian

Format the content as a proper Markdown file with YAML frontmatter:

---
title: "[Video Title]"
source: "[Original URL]"
platform: "[youtube/bilibili/podcast/...]"
date: "[YYYY-MM-DD]"
duration: "[X min]"
tags: [video-summary]
---

# [Video Title]

[Summary / Transcript / Article content]

---
*Summarized by [BibiGPT](https://bibigpt.co)*

Write to the specified path:

# Default location
cat > "$HOME/Documents/bibigpt-notes/[slug].md" << 'EOF'
[content]
EOF

For Obsidian, ask for the vault path or use a common default:

# Common Obsidian vault paths
$HOME/Documents/Obsidian/[vault-name]/BibiGPT/[slug].md

3B. Clipboard

# macOS
echo "[content]" | pbcopy

# Linux
echo "[content]" | xclip -selection clipboard

3C. Notion

BibiGPT's Notion integration is available through the web UI:

1. The summary response includes htmlUrl (e.g., https://bibigpt.co/video/xxx) 2. Direct the user to visit the htmlUrl and use the "Save to Notion" button 3. First-time users need to connect their Notion workspace at https://bibigpt.co/settings

4. Confirm Success

Report what was saved and where:

Saved to: ~/Documents/bibigpt-notes/video-title-2024-01-15.md
Content: Summary + Chapter breakdown
Size: 2.3 KB

5. Follow-up Options

• "Summarize another video" → workflows/quick-summary.md
• "Export in a different format" — re-run with different destination

Workflow: Latest Feed (Subscribed Channels)

Use this when the user wants a digest of new content across all their subscribed channels — "what's new", "today's update", or a recurring daily/weekly digest.

Triggers

• "What's new in my subscriptions?"
• "Anything new today?"
• "Daily digest of my channels"
• "我的订阅频道有什么更新"
• "最近有什么新视频"
• "Show me my feed"

Steps

1. Pull latest items

bibi feed --json                                  # default: items from last 7 days, up to 20
bibi feed --since 2026-05-01 --limit 50 --json    # explicit since (ISO date)

API mode:

curl -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://bibigpt.co/api/v1/feed?limit=20"

Response:

{
  "items": [
    {
      "contentId": "...",
      "channelId": "...",
      "channelTitle": "Veritasium",
      "title": "...",
      "sourceUrl": "https://...",
      "coverUrl": "...",
      "publishedAt": "2026-05-06T..."
    }
  ],
  "nextCursor": "2026-05-04T..." // ISO date of last item; pass back as ?since=
}

2. Paginate

nextCursor is the publishedAt of the last item; pass it back as --since <nextCursor> to fetch the next batch. Stop when nextCursor is null.

3. Drill in

For each interesting item, the agent can:

• Summarize: bibi summarize <sourceUrl>
• Get transcript: bibi summarize <sourceUrl> --subtitle
• Save user note: bibi notes update --contentId <contentId> --text "..."

Output formatting

Group items by channel (using channelTitle). For each channel show 2-3 most recent titles with publish date. Skip channels that have no items in the window.

Default window

If the user doesn't specify a date range, the API defaults to the last 7 days. For "today" or "this week" intents, set --since accordingly. For very narrow windows (last 24h), explicitly pass --since ISO 8601 string.

Notes

• Feed items are videos that already have user_contents rows (i.e., have been seen by some user, not necessarily this user).
• The default since resolves to MIN(user_channel_subscriptions.last_seen_at) — call feedMarkSeen after presenting items so the next call returns only newer ones.
• feed is read-only and free of minute-cost — agents can poll without burning quota (still respects per-IP rate limits).

Workflow: Browse & Search Saved Library

Use this when the user asks about videos they've already summarized — listing, fetching by ID, or keyword search.

Triggers

• "What videos have I summarized?"
• "Show my saved videos"
• "Find my summaries about <topic>"
• "我之前总结过的视频里有 X 吗？"
• "列出我最近的总结"
• "search my notes for <keyword>"

Steps

1. List saved videos (paginated)

bibi library list --json                          # default: 20 items, sorted by updatedAt desc
bibi library list --limit 50 --json
bibi library list --channelId "<authorId>" --json # filter by channel
bibi library list --cursor "2" --json             # next page (cursor is page number)

Or via API:

curl -H "Authorization: Bearer $BIBI_API_TOKEN" \
  "https://bibigpt.co/api/v1/library/list?limit=20"

Response:

{
  "videos": [
    {
      "id": "...",
      "title": "...",
      "sourceUrl": "https://...",
      "coverUrl": "...",
      "duration": 1234,
      "channelId": "...",
      "channelTitle": "...",
      "createdAt": "2026-04-..."
    }
  ],
  "nextCursor": "2",
  "total": 87
}

2. Get a single saved video with note

bibi library get --id "<contentId>" --json

Returns the user's saved note (their personalized summary), chapters (when generated), and subtitles (when stored). For fresh transcripts of unstored videos, call get_subtitle (bibi summarize <URL> --subtitle).

3. Search saved videos

bibi library search --keyword "AI agents" --limit 10 --json

Searches title and note (ILIKE) in parallel with subtitle full-text (Postgres websearch_to_tsquery). Subtitle hits include the matched segment's timestamp so you can deep-link into a specific moment. Each result has a snippet excerpt around the match and matchType ∈ title | subtitle | note | summary.

Output formatting

Render results as a Markdown table or list, using title as the link text and sourceUrl as the href. Highlight channelTitle and createdAt.

Pagination

Library is sorted by updatedAt desc by default. Use nextCursor (string, treat as opaque) to fetch the next page:

bibi library list --cursor <nextCursor> --json

Stop when nextCursor is null.

Common follow-ups

• User says "summarize this one again" → take sourceUrl from a list item, call bibi summarize <URL>
• User says "what was that video about X" → library.search --keyword X, then library.get --id <id> on the most relevant hit

Workflow: User Notes (Personalized Summaries)

Use when the user wants to read, edit, or list their personal notes on saved videos. In BibiGPT, the "note" is the user's saved version of a video summary — initially the AI-generated summary, but the user can edit it afterwards (and Notion/Obsidian sync may push edits back).

Triggers

• "Show me my notes on <video>"
• "Update the note for <video>"
• "List my recent notes"
• "我的笔记"
• "把这个视频的笔记改成 ..."
• "Save this as my note for the video"

Steps

1. List notes (paginated)

bibi notes list --limit 20 --json                       # default
bibi notes list --limit 50 --json
bibi notes list --cursor "2026-05-04T12:00:00Z" --json  # paginate

Returns { notes: [{ contentId, title, sourceUrl, excerpt, updatedAt }], nextCursor }.

excerpt is the first 200 characters of the note. For full text, call notes.get.

2. Get a single note

bibi notes get --contentId <contentId> --json
# → { "contentId":..., "note":..., "updatedAt":... }

If the user has never saved a note for that contentId, note is null (valid state).

3. Update a note

bibi notes update --contentId <contentId> --text "My polished summary..." --json
# → { "success": true }

Mutation; requires write scope. Empty string is rejected (won't clobber existing note). Updating triggers any user-configured global webhook (Notion, etc.).

Output formatting

For lists: render a Markdown list with title (linked to sourceUrl) + relative-time updatedAt + excerpt. For single note: render the full text as Markdown.

Common follow-ups

• "Edit this note to focus on X" → fetch with notes.get, agent rewrites, then notes.update
• "Find videos where I noted Y" → use library.search --keyword Y (which searches notes by ILIKE)
• "Export note to Notion" → call bibi notion export-note --contentId <id> (the user's configured global webhook still fires on notes.update automatically)

Notes

• notes.update is a mutation (write scope); list and get are read-only.
• notes.list uses cursor by updated_at desc — pass nextCursor from prior response to continue.
• Unsaved videos (no user_contents_note row) won't appear in notes.list even if they're in library.list.

Quick Summary

Summarize a single video or audio URL to get an AI-generated overview.

Triggers

"summarize this video", "what's this about", "TL;DR", "总结这个视频", "帮我看看这个视频讲了什么", "video summary", "podcast notes"

Steps

1. Environment Check

Run scripts/bibi-check.sh to detect available mode (CLI or API). If neither mode is available, follow the setup instructions in references/installation.md.

2. Validate Input

• Extract the URL or local file path from the user's message
• If it's a URL: confirm it looks like a supported platform (see references/supported-platforms.md)
• If it's a local file path: confirm the file exists and is a supported format (.mp4, .mp3, .wav, .mkv, .mov, .webm, .m4a, .flac, .ogg, .avi)
• If no URL or file is provided, ask the user to paste one
• If the URL looks shortened (b23.tv, xhslink.com), it will be auto-expanded

3. Estimate Duration

• If the user mentions "long video", "1-hour lecture", etc., recommend async mode
• If unsure, proceed synchronously — the API will return an error if the video is too long for sync processing

4. Execute Summary

CLI mode (supports both URLs and local files):

bibi summarize "<URL_OR_FILE_PATH>"

For long videos (>30 min):

bibi summarize "<URL_OR_FILE_PATH>" --async

API mode (URLs only — no direct file upload):

ENCODED=$(python3 -c 'import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1], safe=""))' "$URL")
curl -s "https://api.bibigpt.co/api/v1/summarize?url=$ENCODED" \
  -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "x-client-type: bibi-cli"

API mode with local file: The API does not accept file uploads directly. Guide the user to: 1. Upload the file to a publicly accessible URL (OSS, S3, Cloudflare R2, etc.) 2. Pass the public URL to the API

For long videos, use async:

# Create task
TASK=$(curl -s "https://api.bibigpt.co/api/v1/createSummaryTask?url=$ENCODED" \
  -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "x-client-type: bibi-cli")
TASK_ID=$(echo "$TASK" | jq -r '.taskId')

# Poll every 3s until completed
while true; do
  STATUS=$(curl -s "https://api.bibigpt.co/api/v1/getSummaryTaskStatus?taskId=$TASK_ID" \
    -H "Authorization: Bearer $BIBI_API_TOKEN" \
    -H "x-client-type: bibi-cli")
  echo "$STATUS" | jq -r '.status'
  [ "$(echo "$STATUS" | jq -r '.status')" = "completed" ] && break
  sleep 3
done

See references/cli.md and references/api.md for full command/endpoint details.

5. Format Output

Present the result to the user:

• Title: Video/audio title
• Source: Platform name + original URL
• Summary: The AI-generated Markdown summary
• Duration/Quota: Mention costDuration and remainingTime if relevant

6. Follow-up Options

After presenting the summary, offer:

• "Want a chapter-by-chapter breakdown?" → workflows/deep-dive.md
• "Need the raw transcript?" → workflows/transcript-extract.md
• "Turn this into an article?" → workflows/article-rewrite.md
• "Save to Notion or Obsidian?" → workflows/export-notes.md

Research & Compile

Summarize multiple videos on the same topic and synthesize insights into a research brief.

Triggers

"research this topic", "compare these videos", "what do these say about...", "综合分析", "对比总结", "cross-reference these sources"

Steps

1. Environment Check

Run scripts/bibi-check.sh to detect available mode.

2. Gather Sources

If the user provides URLs: use them directly.

If the user provides a topic: ask for specific URLs to analyze. BibiGPT summarizes content from URLs — it does not search for videos. Example prompt:

"I can summarize specific videos for you. Could you share the URLs of the videos you'd like me to analyze on this topic?"

3. Summarize Each Source

For each URL, run the quick-summary workflow:

CLI mode:

bibi summarize "<URL>" --json

API mode:

ENCODED=$(python3 -c 'import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1], safe=""))' "$URL")
curl -s "https://api.bibigpt.co/api/v1/summarize?url=$ENCODED&includeDetail=true" \
  -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "x-client-type: bibi-cli"

Collect all summaries before proceeding to synthesis.

4. Synthesize

Analyze all summaries together to identify:

• Common themes: Points made across multiple sources
• Unique insights: Ideas found in only one source
• Divergent views: Where sources disagree or offer different perspectives
• Key quotes: Notable statements with source attribution

5. Present Research Brief

# Research Brief: [Topic]

## Sources Analyzed
1. **[Title 1]** ([platform]) — [one-line key takeaway]
2. **[Title 2]** ([platform]) — [one-line key takeaway]
3. **[Title 3]** ([platform]) — [one-line key takeaway]

## Common Themes
- [Theme 1]: discussed in sources 1, 2, 3
- [Theme 2]: discussed in sources 1, 3

## Unique Insights
- Source 1 uniquely argues that...
- Source 3 introduces the concept of...

## Divergent Views
- On [topic X], Source 1 claims... while Source 2 argues...

## Key Quotes
> "[Quote]" — Source 1, [timestamp]
> "[Quote]" — Source 2, [timestamp]

6. Follow-up Options

• "Turn this into an article" → workflows/article-rewrite.md
• "Save to Obsidian" → workflows/export-notes.md
• "Get the full transcript of source #N" → workflows/transcript-extract.md
• "Add more sources to this research" — repeat steps 2-5 with additional URLs

Transcript Extract

Get raw subtitles or transcript with timestamps, optionally with speaker identification.

Triggers

"get subtitles", "extract transcript", "download captions", "获取字幕", "提取文字稿", "get the raw text"

Steps

1. Environment Check

Run scripts/bibi-check.sh to detect available mode.

2. Ask Preferences (optional)

If the user doesn't specify, use defaults. Otherwise ask:

• Language: default is the original audio language. Pass audioLanguage to override
• Speaker identification: enable with enabledSpeaker=true for multi-speaker content (interviews, panels)

3. Fetch Subtitles

CLI mode:

bibi summarize "<URL>" --subtitle

For JSON with timestamps:

bibi summarize "<URL>" --subtitle --json

API mode:

ENCODED=$(python3 -c 'import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1], safe=""))' "$URL")
curl -s "https://api.bibigpt.co/api/v1/getSubtitle?url=$ENCODED" \
  -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "x-client-type: bibi-cli"

Optional params: &audioLanguage=en, &enabledSpeaker=true

See references/api.md endpoint #4 for full details.

4. Format Output

Offer the user their preferred format:

Plain text (readable):

[Speaker A]: The key insight here is that...
[Speaker B]: I agree, and additionally...

Timestamped (for reference):

[00:00:15] The key insight here is that...
[00:00:32] I agree, and additionally...

File output:

# Save as text file
bibi summarize "<URL>" --subtitle > transcript.txt

5. Follow-up Options

• "Now summarize this" → workflows/quick-summary.md
• "Polish into a readable article" → workflows/article-rewrite.md
• "Break down by chapter" → workflows/deep-dive.md
• "Save to my notes" → workflows/export-notes.md

Video → TikTok-style Music Video

Turn any video or podcast into a vertical, TikTok-style music video by composing lyrics from its content and generating an AI song with a shareable HTML player.

Triggers

"turn this video into a TikTok MV", "make a music video from this", "video to song", "短视频化", "做一个 TikTok 视频", "把这个视频变成 MV", "music video from podcast", "song from summary", "vertical MV from video"

Output

A https://suno.bi/song/share/<songId>?vertical=1 URL that hosts a TikTok-ratio (9:16) HTML player with the AI-generated song, cover, and karaoke-style lyrics overlay — embeddable on Twitter / X cards, ready for screen-record for social posting.

Steps

1. Environment Check

Run scripts/bibi-check.sh to detect available mode (CLI or API).

2. Get the Source Content

Fetch the video / podcast summary plus chapters and transcript — both feed into the lyric.

CLI mode (recommended — one call gives all the materials):

bibi summarize "<URL_OR_FILE_PATH>" --chapter --json

API mode:

ENCODED=$(python3 -c 'import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1], safe=""))' "$URL")
curl -s "https://api.bibigpt.co/api/v1/summarizeByChapter?url=$ENCODED&includeDetail=true" \
  -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "x-client-type: bibi-cli"

From the JSON response, keep:

• title — used as the song title default
• summary — top-level distilled message
• chapters — anchor points for verse / chorus structure
• subtitlesText (or stitched subtitles[].text) — raw quotes for hook material

3. Confirm Style & Language

Before composing, ask one short clarifying question if any of these is ambiguous:

If the user already specified them, skip the question.

4. Compose the Lyric (Agent-native, no API call)

You write the lyric yourself from the summary + chapters. Do not call any API for this step. Follow the structure below.

Hard rules:

• Vertical-first: assume the audience is scrolling on TikTok / 抖音 / Reels — first 5 seconds carry the hook
• One core message distilled from the summary — do NOT cram every chapter in
• TikTok pacing: short lines (4–10 chars zh / 4–7 words en), high consonant density, repetition welcome
• Genuine hook: pick the most quotable / counter-intuitive line from the transcript and turn it into the chorus refrain
• No filler words (呃 / 啊 / 然后 / actually / basically) — TTS will mispronounce them
• No platform/model names in the lyric itself (no "GPT", "Claude", "bibi" branding) — keeps it portable as social content

Suggested length by target duration:

Template:

[Hook]                             ← 5-second attention grab from the most quotable insight
<2 short lines>

[Verse 1]                          ← Build context from the first 1-2 chapters
<3–4 lines, narrative arc>

[Chorus]                           ← The core message, repeated
<3–4 lines, anthemic phrasing>

[Verse 2]                          ← Pivot — second insight from later chapters
<3–4 lines>

[Chorus]                           ← Repeat with one tiny variation
<same 3–4 lines>

[Outro]                            ← One-line takeaway / CTA
<1–2 lines>

5. Present Lyric + Generation Path

Show the composed lyric to the user, then guide them to generate the actual song. Today the song generation step happens in the BibiGPT web app (mobile-friendly, one-click); the agent does not yet hold a public OpenAPI for music generation.

Recommended phrasing:

"Here's the TikTok-fit lyric I composed (≈ N seconds). Copy this into the SunoMV creator at https://suno.bi/ → Create. Once the song renders, paste the share link back to me and I'll wrap it in a TikTok player URL for you."

Include in the reply:

• The lyric in a fenced code block (so the user can copy with one tap)
• Suggested title (default: source video title, optionally remixed)
• Suggested style tag (the genre / vibe chosen in step 3)

6. Wrap the Result as a Vertical Share Link

After the user reports back with the generated song URL (looks like https://suno.bi/song/<uuid>), respond with:

🎬 TikTok-ready share link:
https://suno.bi/song/share/<uuid>?vertical=1

✓ 9:16 HTML player (no app install needed)
✓ Auto-plays with karaoke lyric overlay
✓ Screen-record to repost on TikTok / Reels / Shorts
✓ Use as Twitter player card meta tag

Default to ?vertical=1 for TikTok / Shorts. Drop the ?vertical=1 query when the user explicitly says "landscape" or wants 16:9.

7. Follow-up Options

After the share link is delivered, offer:

• "Want a different vibe?" → re-run step 3 with new style, then step 4
• "Need a longer cut?" → bump target duration, re-run step 4
• "Get a chapter breakdown of the source" → workflows/deep-dive.md
• "Turn the same content into an article instead" → workflows/article-rewrite.md
• "Save the source notes" → workflows/export-notes.md

Don'ts

• Don't transcribe the source word-for-word — lyrics must distill, not summarize linearly
• Don't include the source URL inside the lyric
• Don't add timestamps, chapter markers, or speaker tags to the lyric (those break TTS)
• Don't mention model / service names in the user-facing reply (no "Suno", "豆包 TTS", "AI 模型"); the user just gets a TikTok-ready link
• Don't assume the user wants a full English MV from a Chinese source — keep language matching the source unless the user opted to translate

Why this workflow exists

A growing share of BibiGPT users want the takeaway from a long-form video repackaged for TikTok / Reels / Shorts: vertical, hook-driven, ≤ 90 seconds, with lyrics on screen. This workflow composes the lyric agent-side (where the LLM is strongest) and hands off to the SunoMV web flow for the actual audio + share-page rendering — keeping the agent contract simple and the audio quality predictable.

Visual Analysis

Analyze video frames to understand visual content beyond the audio transcript — slides, demos, diagrams, on-screen text.

Triggers

"analyze what's shown", "visual content", "画面分析", "screenshot analysis", "what's on screen", "analyze the slides", "视觉分析"

Steps

1. Environment Check

Run scripts/bibi-check.sh to detect available mode.

2. Explain Capability & Limitations

BibiGPT can analyze video frames for visual content. Be upfront about current limitations:

• Best for: Slides, presentations, tutorials, demos, whiteboard sessions
• Current access: Visual analysis is primarily available through the BibiGPT web UI
• CLI/API limitation: Frame-by-frame visual analysis is not yet exposed via CLI or the public OpenAPI. The web UI at https://bibigpt.co/video/[id] provides this feature

3. Get Text Summary First

Before visual analysis, get the text-based summary for context:

CLI mode:

bibi summarize "<URL>" --chapter

API mode:

ENCODED=$(python3 -c 'import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1], safe=""))' "$URL")
curl -s "https://api.bibigpt.co/api/v1/summarizeByChapter?url=$ENCODED&includeDetail=true" \
  -H "Authorization: Bearer $BIBI_API_TOKEN" \
  -H "x-client-type: bibi-cli"

This provides the audio/text content and chapter structure as a foundation.

4. Direct to Web UI for Visual Analysis

1. Use the htmlUrl from the summary response (e.g., https://bibigpt.co/video/xxx) 2. Inform the user:

"The text summary is above. For visual frame analysis (slides, diagrams, on-screen content), visit the BibiGPT web interface:

[htmlUrl]

>

The web UI can analyze key frames and extract visual information that complements the audio transcript."

5. Present Combined Results

If the user has both text and visual results, combine them:

# [Video Title] — Combined Analysis

## Audio/Text Summary
[Chapter-by-chapter text summary]

## Visual Content Highlights
[Visual analysis from web UI — slides, diagrams, key frames]

## Insights
- Points where visual content adds information not in the audio
- Key slides or diagrams that support the spoken content

6. Follow-up Options

• "Get the full transcript" → workflows/transcript-extract.md
• "Turn this into an article" → workflows/article-rewrite.md
• "Just give me the summary" → workflows/quick-summary.md
• "Save these notes" → workflows/export-notes.md