For those making short video remixes, check out this open-source tool: AutoClip. It’s an AI-powered automatic video clipping system that turns long videos into a streamlined pipeline—from downloading, analyzing, and editing to generating compilations. Currently has 3780+ stars on GitHub.

The basic workflow is:

• Input a YouTube/Bilibili link (local video upload also supported)
• The system automatically downloads the video and subtitles
• AI analyzes content, extracts outlines and topic timestamps
• Scores each segment for excitement level
• Automatically cuts highlight clips and generates titles
• Recommends compilation combinations, one-click generation of compilation videos

Technically, it uses Qwen (Tongyi Qianwen) for content understanding, FFmpeg for video processing, and WebSocket for real-time task progress updates.

Tech stack: • FastAPI • React • Celery • Redis • Docker deployment

Suitable for scenarios like: • Cutting long videos into short clips • Extracting podcast highlights • Remixing interview content • Splitting live stream replays • Batch content matrix production • Bilibili video highlight slicing

Upcoming features include automatic Bilibili upload and subtitle editing.

Previously, making a remix video required watching the entire content, finding highlights, cutting clips, creating titles, and assembling a compilation. Now just drop a link and let the system run automatically.

Open source under MIT license, free to use.

Project address: https://github.com/zhouxiaoka/autoclip

One-line summary: AutoClip turns “manually finding highlight clips” into an AI-driven automated pipeline.

Note: Be mindful of platform rules, copyright licensing, and remix compliance boundaries when using.

zhouxiaoka/autoclip

Source: https://github.com/zhouxiaoka/autoclip

AutoClip - Automated Video Highlight Slicing Tool

Supports YouTube/Bilibili video download, automatic slicing, and intelligent compilation generation.

Python (https://python.org) React (https://reactjs.org) FastAPI (https://fastapi.tiangolo.com) TypeScript (https://www.typescriptlang.org) Celery (https://celeryproject.org)

License GitHub stars (https://github.com/zhouxiaoka/autoclip) GitHub forks (https://github.com/zhouxiaoka/autoclip) GitHub issues (https://github.com/zhouxiaoka/autoclip/issues)

Languages: English | 中文

🎯 Introduction

AutoClip is an AI-based intelligent video slicing system that can automatically download videos from platforms like YouTube and Bilibili, extract highlight clips through AI analysis, and intelligently generate compilations. The system adopts a modern front-end/back-end separation architecture, providing an intuitive web interface and powerful back-end processing capabilities.

✨ Core Features

• 🎬 Multi-platform support: One-click download from YouTube and Bilibili, local file upload supported
• 🤖 AI intelligent analysis: Video content understanding based on the Qwen large language model
• ✂️ Auto-slicing: Intelligent identification of highlight clips with automatic cutting, support for multiple video categories
• 📚 Smart compilations: AI-recommended and manual compilation creation with drag-and-drop sorting
• 🚀 Real-time processing: Asynchronous task queue with real-time progress feedback via WebSocket
• 🎨 Modern UI: React + TypeScript + Ant Design, responsive design
• 📱 Mobile support [In development] : Responsive design, mobile experience under improvement
• 🔐 Account management [In development] : Multi-account management for Bilibili with automatic health checks
• 📊 Data statistics: Comprehensive project management and data statistics
• 🛠️ Easy deployment: One-click startup script, Docker support, detailed documentation
• 📤 Bilibili upload [In development] : Automatic upload of sliced videos to Bilibili
• ✏️ Subtitle editing [In development] : Visual subtitle editing and synchronization

🏗️ System Architecture

mermaid graph TB
A[User Interface] --> B[FastAPI Backend]
B --> C[Celery Task Queue]
B --> D[Redis Cache]
B --> E[SQLite Database]
C --> F[AI Processing Engine]
F --> G[Video Processing]
F --> H[Subtitle Analysis]
F --> I[Content Understanding]
B --> J[File Storage]
K[YouTube API] --> B
L[Bilibili API] --> B

Tech Stack

Backend

• FastAPI: Modern Python web framework, auto API documentation generation
• Celery: Distributed task queue for async processing
• Redis: Message broker and cache, task status management
• SQLite: Lightweight database, supports upgrade to PostgreSQL
• yt-dlp: YouTube video download, supports multiple formats
• Qwen: AI content analysis, supports multiple models
• WebSocket: Real-time communication, progress push
• Pydantic: Data validation and serialization

Frontend

• React 18: UI framework, Hooks and functional components
• TypeScript: Type safety, better development experience
• Ant Design: Enterprise-grade UI component library
• Vite: Fast build tool with hot reload
• Zustand: Lightweight state management
• React Router: Routing management
• Axios: HTTP client
• React Player: Video player

🚀 Quick Start

Requirements

Docker Deployment (Recommended)

• Docker: 20.10+
• Docker Compose: 2.0+
• Memory: At least 4GB, recommended 8GB+
• Storage: At least 10GB free space

Local Deployment

• OS: macOS / Linux / Windows (WSL)
• Python: 3.8+ (recommended 3.9+)
• Node.js: 16+ (recommended 18+)
• Redis: 6.0+ (recommended 7.0+)
• FFmpeg: Video processing dependency
• Memory: At least 4GB, recommended 8GB+
• Storage: At least 10GB free space

One-Click Startup

Option 1: Docker Deployment (Recommended)

# Clone the project
git clone https://github.com/zhouxiaoka/autoclip.git
cd autoclip

# Docker one-click start
./docker-start.sh

# Dev environment start
./docker-start.sh dev

# Stop services
./docker-stop.sh

# Check service status
./docker-status.sh

Option 2: Local Deployment

# Clone the project
git clone https://github.com/zhouxiaoka/autoclip.git
cd autoclip

# One-click start (recommended, includes full check and monitoring)
./start_autoclip.sh

# Quick start (dev environment, skips detailed checks)
./quick_start.sh

# Check system status
./status_autoclip.sh

# Stop the system
./stop_autoclip.sh

Manual Installation

# 1. Create virtual environment
python3 -m venv venv
source venv/bin/activate  # Linux/macOS
# or venv\Scripts\activate  # Windows

# 2. Install Python dependencies
pip install -r requirements.txt

# 3. Install frontend dependencies
cd frontend && npm install && cd ..

# 4. Install Redis
# macOS
brew install redis
brew services start redis
# Ubuntu/Debian
sudo apt update
sudo apt install redis-server
sudo systemctl start redis-server
# CentOS/RHEL
sudo yum install redis
sudo systemctl start redis

# 5. Install FFmpeg
# macOS
brew install ffmpeg
# Ubuntu/Debian
sudo apt install ffmpeg
# CentOS/RHEL
sudo yum install ffmpeg

# 6. Configure environment variables
cp env.example .env
# Edit .env file, fill in API keys and other configurations

🎬 Feature Demo

Main Features

1. Video Download & Processing

   • Supports YouTube and Bilibili video link parsing
   • Auto-download video and subtitle files
   • Local file upload support

2. AI Intelligent Analysis

   • Auto-extract video outline
   • Intelligent identification of topic timestamps
   • Excitement scoring for each segment

3. Video Slicing & Compilations

   • Auto-generate highlight clips
   • Intelligent compilation combination recommendations
   • Manual editing and sorting support

4. Real-time Progress Monitoring

   • WebSocket real-time progress push
   • Detailed task status display
   • Error handling and retry mechanism

5. Bilibili Upload [In development]

   • Auto-upload sliced videos to Bilibili
   • Multi-account management support
   • Batch upload and queue management

6. Subtitle Editing [In development]

   • Visual subtitle editor
   • Subtitle synchronization and adjustment
   • Multi-language subtitle support

📖 Usage Guide

1. Video Download

YouTube Video

1. Click “New Project” on the homepage
2. Select “YouTube Link”
3. Paste the video URL
4. Choose browser cookies (optional)
5. Click “Start Download”

Bilibili Video

1. Click “New Project” on the homepage
2. Select “Bilibili Link”
3. Paste the video URL
4. Choose a login account
5. Click “Start Download”

Local File

1. Click “New Project” on the homepage
2. Select “File Upload”
3. Drag or select a video file
4. Upload subtitle file (optional)
5. Click “Start Processing”

2. Intelligent Processing

The system will automatically perform the following steps:

1. Material Preparation: Download video and subtitle files
2. Content Analysis: AI extracts video outline and key information
3. Timeline Extraction: Identify topic time intervals
4. Excitement Scoring: AI scores each segment
5. Title Generation: Generate attractive titles for highlight clips
6. Compilation Recommendations: AI recommends video compilations
7. Video Generation: Generate clipped videos and compilation videos

3. Result Management

• View Clips: See all generated video clips on the project detail page
• Edit Info: Modify clip title, description, etc.
• Create Compilations: Create manually or use AI-recommended compilations
• Download Export: Download individual clips or complete compilations
• Bilibili Upload [In development]: One-click upload clips to Bilibili
• Subtitle Editing [In development]: Visual editing and synchronization of subtitle files

🔧 Configuration

Environment Variables

Create .env file:

# Database configuration
DATABASE_URL=sqlite:///./data/autoclip.db

# Redis configuration
REDIS_URL=redis://localhost:6379/0

# AI API configuration
API_DASHSCOPE_API_KEY=your_dashscope_api_key
API_MODEL_NAME=qwen-plus

# Log configuration
LOG_LEVEL=INFO
ENVIRONMENT=development
DEBUG=true

# File storage
UPLOAD_DIR=./data/uploads
PROJECT_DIR=./data/projects

Bilibili Account Configuration [In development]

1. Click “Bilibili Account Management” on the settings page
2. Choose login method:
   • Cookie Import (recommended): Export cookies from browser
   • Account/Password: Direct input
   • QR Code Login: Scan to login
3. After adding, the system automatically manages account health status

📁 Project Structure

autoclip/
├── backend/                 # Backend code
│   ├── api/                 # API routes
│   │   ├── v1/              # API v1
│   │   │   ├── youtube.py   # YouTube download API
│   │   │   ├── bilibili.py  # Bilibili download API
│   │   │   ├── projects.py  # Project management API
│   │   │   ├── clips.py     # Video clip API
│   │   │   ├── collections.py # Compilation management API
│   │   │   └── settings.py  # System settings API
│   │   └── upload_queue.py  # Upload queue management
│   ├── core/                # Core configuration
│   │   ├── database.py      # Database configuration
│   │   ├── celery_app.py    # Celery configuration
│   │   ├── config.py        # System configuration
│   │   └── llm_manager.py   # AI model management
│   ├── models/              # Data models
│   │   ├── project.py       # Project model
│   │   ├── clip.py          # Clip model
│   │   ├── collection.py    # Compilation model
│   │   └── bilibili.py      # Bilibili account model
│   ├── services/            # Business logic
│   │   ├── video_service.py # Video processing service
│   │   ├── ai_service.py    # AI analysis service
│   │   └── upload_service.py # Upload service
│   ├── tasks/               # Celery tasks
│   │   ├── processing.py    # Processing tasks
│   │   ├── upload.py        # Upload tasks
│   │   └── maintenance.py   # Maintenance tasks
│   ├── pipeline/            # Processing pipeline
│   │   ├── step1_outline.py # Outline extraction
│   │   ├── step2_timeline.py # Timeline analysis
│   │   ├── step3_scoring.py # Excitement scoring
│   │   └── step6_video.py   # Video generation
│   └── utils/               # Utility functions
├── frontend/                # Frontend code
│   ├── src/
│   │   ├── components/      # React components
│   │   │   ├── UploadModal.tsx   # Upload modal
│   │   │   ├── ClipCard.tsx      # Clip card
│   │   │   ├── CollectionCard.tsx # Compilation card
│   │   │   └── BilibiliManager.tsx # Bilibili management
│   │   ├── pages/           # Page components
│   │   │   ├── HomePage.tsx # Homepage
│   │   │   ├── ProjectDetailPage.tsx # Project detail
│   │   │   └── SettingsPage.tsx # Settings page
│   │   ├── services/        # API services
│   │   │   └── api.ts       # API client
│   │   └── stores/          # State management
│   └── package.json
├── data/                    # Data storage
│   ├── projects/            # Project data
│   ├── uploads/             # Uploaded files
│   ├── temp/                # Temporary files
│   ├── output/              # Output files
│   └── autoclip.db          # Database file
├── scripts/                 # Utility scripts
│   ├── start_autoclip.sh    # Start script
│   ├── stop_autoclip.sh     # Stop script
│   └── status_autoclip.sh   # Status check script
├── docs/                    # Documentation
│   ├── README.md            # Documentation center
│   ├── i18n.md              # Internationalization configuration
│   └── *.md                 # Other docs
├── logs/                    # Log files
├── Dockerfile               # Docker image build file
├── Dockerfile.dev           # Dev environment Dockerfile
├── docker-compose.yml       # Production Docker compose
├── docker-compose.dev.yml   # Dev Docker compose
├── docker-start.sh          # Docker start script
├── docker-stop.sh           # Docker stop script
├── docker-status.sh         # Docker status check script
├── .dockerignore            # Docker ignore file
├── DOCKER.md                # Docker deployment documentation
└── *.sh                     # Startup scripts

🌐 API Documentation

After startup, visit the following URLs to view API docs:

• Swagger UI: http://localhost:8000/docs (local dev environment)
• ReDoc: http://localhost:8000/redoc (local dev environment)

Main API Endpoints

🔍 Troubleshooting

Common Issues

1. Port Already in Use

# Check port occupation
lsof -i :8000   # Backend port
lsof -i :3000   # Frontend port

# Kill the occupying process
kill -9 <PID>

2. Redis Connection Failure

# Check Redis status
redis-cli ping

# Start Redis service
brew services start redis   # macOS
systemctl start redis       # Linux

3. YouTube Download Failure

• Check network connection
• Update yt-dlp: pip install --upgrade yt-dlp
• Try using browser cookies
• Check video availability

4. Bilibili Download Failure

• Check account login status
• Update account cookies
• Check video permission settings

Viewing Logs

# View all logs
tail -f logs/*.log

# View specific service logs
tail -f logs/backend.log   # Backend logs
tail -f logs/frontend.log  # Frontend logs
tail -f logs/celery.log    # Task queue logs

System Status Check

# Detailed status check
./status_autoclip.sh

# Manual service check
curl http://localhost:8000/api/v1/health/  # Backend health check
curl http://localhost:3000/                 # Frontend access test
redis-cli ping                              # Redis connection test

🛠️ Development Guide

Backend Development

# Activate virtual environment
source venv/bin/activate

# Set Python path
export PYTHONPATH="${PWD}:${PYTHONPATH}"

# Start backend dev server
python -m uvicorn backend.main:app --reload --port 8000

Frontend Development

# Go to frontend directory
cd frontend

# Start dev server
npm run dev

Celery Worker

# Start worker
celery -A backend.core.celery_app worker --loglevel=info

# Start beat scheduler
celery -A backend.core.celery_app beat --loglevel=info

# Start Flower monitoring
celery -A backend.core.celery_app flower --port=5555

📊 Performance Optimization

Production Configuration

1. Database Optimization

   • Use PostgreSQL instead of SQLite
   • Configure connection pool
   • Enable query caching

2. Redis Optimization

   • Configure memory limits
   • Enable persistence
   • Set expiration policies

3. Celery Optimization

   • Adjust concurrency
   • Configure task routing
   • Enable result backend

🔒 Security Configuration

Production Security

1. Environment Variables

   • Use strong passwords
   • Rotate keys regularly
   • Restrict API access

2. Network Security

   • Configure firewall
   • Use HTTPS
   • Restrict CORS

3. Data Security

   • Regular backups
   • Encrypt sensitive data
   • Access control

🚀 Deployment Guide

Docker Deployment

Quick Start

# Clone the project
git clone https://github.com/zhouxiaoka/autoclip.git
cd autoclip

# Configure environment variables
cp env.example .env
# Edit .env file, fill in necessary configuration

# Start all services
docker-compose up -d

# View service status
docker-compose ps

Access Services

• Frontend UI: http://localhost:3000 (local dev environment)
• Backend API: http://localhost:8000 (local dev environment)
• API Documentation: http://localhost:8000/docs (local dev environment)
• Flower Monitoring: http://localhost:5555 (local dev environment)

Dev Environment

# Use dev environment configuration
docker-compose -f docker-compose.dev.yml up -d

# View logs in real-time
docker-compose -f docker-compose.dev.yml logs -f

Detailed Instructions

For complete Docker deployment guide, please refer to DOCKER.md.

System Service

# Create systemd service file
sudo nano /etc/systemd/system/autoclip.service

[Unit]
Description=AutoClip Video Processing System
After=network.target redis.service

[Service]
Type=forking
User=autoclip
WorkingDirectory=/opt/autoclip
ExecStart=/opt/autoclip/start_autoclip.sh
ExecStop=/opt/autoclip/stop_autoclip.sh
Restart=always

[Install]
WantedBy=multi-user.target

📈 Roadmap

Upcoming

• Bilibili Upload: Auto-upload sliced videos to Bilibili with multi-account management
• Subtitle Editing: Visual subtitle editor and synchronization
• Multi-language Support: Video processing for more languages
• Cloud Storage: Integration with cloud storage services
• Batch Processing: Support for batch video processing
• Open API: Public API endpoints
• Mobile App: Mobile application development

Long-term

• AI Model Optimization: Integrate more AI models
• Real-time Collaboration: Multi-user collaboration support
• Plugin System: Support for third-party plugins
• Enterprise Edition: Enterprise-grade features and services

🤝 Contributing

We welcome all forms of contributions! Whether it’s code, documentation, bug reports, or feature suggestions.

How to Contribute

1. Fork the project to your GitHub account
2. Clone your fork locally:

git clone https://github.com/zhouxiaoka/autoclip.git
cd autoclip

3. Create a feature branch:

git checkout -b feature/amazing-feature

4. Develop and test
5. Commit your changes:

git add .
git commit -m 'feat: add amazing feature'

6. Push to the branch:

git push origin feature/amazing-feature

7. Create a Pull Request on GitHub

Development Standards

Code Standards

• Backend: Follow PEP 8 Python coding style
• Frontend: Use TypeScript, follow ESLint rules
• Commit messages: Use conventional commit format (feat, fix, docs, style, refactor, test, chore)

Development Process

1. Ensure all tests pass
2. Add necessary test cases
3. Update relevant documentation
4. Ensure code quality checks pass

Commit Message Format

<type>(<scope>): <subject>
<BLANK LINE>
[optional body]
[optional footer(s)]

Examples:

• feat(api): add video download endpoint
• fix(ui): resolve upload modal display issue
• docs(readme): update installation instructions

📄 License

This project is licensed under the MIT License.

❓ FAQ

Installation and Startup

Q: Port is already in use during startup? A: Use the following commands to check and kill the occupying process:

lsof -i :8000   # Backend port
lsof -i :3000   # Frontend port
kill -9 <PID>

Q: Redis connection fails? A: Ensure Redis service is running:

redis-cli ping
brew services start redis   # macOS
sudo systemctl start redis-server   # Linux

Q: Frontend dependency installation fails? A: Try clearing cache and reinstalling:

cd frontend
rm -rf node_modules package-lock.json
npm cache clean --force
npm install

Functional Issues

Q: YouTube download fails? A: 1. Check network connection 2. Update yt-dlp: pip install --upgrade yt-dlp 3. Try using browser cookies 4. Check if video is available or requires login

Q: Bilibili download fails? A: 1. Check account login status 2. Update account cookies 3. Check video permission settings 4. Try another account

Q: AI processing is slow? A: 1. Check API key configuration 2. Adjust processing parameters (reduce chunk_size) 3. Check network connection 4. Consider using a faster AI model

Q: When will Bilibili upload feature be available? A: The Bilibili upload feature is under development and expected in the next release. It will support:

• Auto-upload sliced videos to Bilibili
• Multi-account management and switching
• Batch upload and queue management
• Upload progress monitoring

Q: When will subtitle editing feature be available? A: The subtitle editing feature is under development and expected in the next release. It will support:

• Visual subtitle editor
• Subtitle timeline synchronization
• Multi-language subtitle support
• Subtitle format conversion

Performance Optimization

Q: How to improve processing speed? A: 1. Increase Celery Worker concurrency 2. Use SSD storage 3. Increase system memory 4. Optimize video quality settings

Q: How to reduce storage usage? A: 1. Regularly clean temporary files 2. Compress output videos 3. Delete unnecessary projects 4. Use external storage

📞 Support & Feedback

Getting Help

• Bug Reports: GitHub Issues (https://github.com/zhouxiaoka/autoclip/issues)
• Feature Suggestions: GitHub Discussions (https://github.com/zhouxiaoka/autoclip/discussions) (available after repository creation)
• Bug Reports: Please use GitHub Issues template
• Documentation: Project Docs

Contact

If you have questions or suggestions, reach out via:

💬 QQ

📱 Feishu (Lark)

📧 Other

• Submit a GitHub Issue (https://github.com/zhouxiaoka/autoclip/issues)
• Email: [email protected]
• Add the above QQ or Feishu contact

🙏 Acknowledgements

Thanks to the following open-source projects and services:

Core Tech Stack

• FastAPI (https://fastapi.tiangolo.com/) - Modern Python web framework
• React (https://reactjs.org/) - UI library
• Ant Design (https://ant.design/) - Enterprise-grade UI design language
• TypeScript (https://typescriptlang.org/) - JavaScript superset
• Celery (https://docs.celeryproject.org/) - Distributed task queue
• Redis (https://redis.io/) - In-memory data structure store

Video Processing

• yt-dlp (https://github.com/yt-dlp/yt-dlp) - YouTube video download tool
• FFmpeg (https://ffmpeg.org/) - Audio/video processing framework

AI Services

• Tongyi Qianwen (Qwen) (https://tongyi.aliyun.com/) - Alibaba Cloud LLM service
• DashScope (https://dashscope.aliyun.com/) - Alibaba Cloud AI service platform

Development Tools

• Vite (https://vitejs.dev/) - Frontend build tool
• Zustand (https://github.com/pmndrs/zustand) - State management library
• Pydantic (https://pydantic-docs.helpmanual.io/) - Data validation library

Special Thanks

• All developers contributing to the open-source community
• Users who provided feedback and suggestions
• Community members who participated in testing and code contributions

If this project is helpful to you, please give us a ⭐ Star

Star History Chart (https://star-history.com/#zhouxiaoka/autoclip&Date)

Made with ❤️ by AutoClip Team

⭐ If you find this useful, please give it a Star to support us!