TikTok Live Recorder: Finally Got Live Streams Recording

import asyncio
import subprocess
from datetime import datetime
from typing import List
import os
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class TikTokLiveMonitor:
    """
    Monitor multiple TikTok creators for live streams
    and automatically record when they go live.
    """

    def __init__(self, creators: List[str], download_dir: str = "~/Videos/TikTok"):
        """
        Args:
            creators: List of @usernames to monitor
            download_dir: Directory to save recordings
        """
        self.creators = creators
        self.download_dir = os.path.expanduser(download_dir)
        os.makedirs(self.download_dir, exist_ok=True)

    async def check_and_record(self, username: str):
        """
        Check if user is live and record if so

        Args:
            username: @username to check
        """
        logger.info(f"Checking {username}...")

        # Run tiktok-live-recorder with --record-if-offline flag
        # This will wait for stream to start if offline
        cmd = [
            'tiktok-live-recorder',
            '-u', username,
            '--record-if-offline',
            '--download-folder', self.download_dir,
            '--tiktok-domain', 'www.tiktok.com'
        ]

        try:
            # Run recorder
            process = await asyncio.create_subprocess_exec(
                *cmd,
                stdout=asyncio.subprocess.PIPE,
                stderr=asyncio.subprocess.PIPE
            )

            # Wait for process to complete
            stdout, stderr = await process.communicate()

            if process.returncode == 0:
                logger.info(f"Successfully recorded {username}")
            else:
                logger.error(f"Error recording {username}: {stderr.decode()}")

        except Exception as e:
            logger.error(f"Exception checking {username}: {e}")

    async def monitor_all(self, interval: int = 300):
        """
        Monitor all creators periodically

        Args:
            interval: Check interval in seconds (default: 5 minutes)
        """
        while True:
            logger.info(f"Checking {len(self.creators)} creators...")

            tasks = [
                self.check_and_record(creator)
                for creator in self.creators
            ]

            # Run checks concurrently
            await asyncio.gather(*tasks, return_exceptions=True)

            # Wait before next check
            logger.info(f"Waiting {interval}s before next check...")
            await asyncio.sleep(interval)

# Usage
async def main():
    # List of creators to monitor
    creators = [
        '@creator1',
        '@creator2',
        '@creator3'
    ]

    monitor = TikTokLiveMonitor(
        creators=creators,
        download_dir='~/Videos/TikTok'
    )

    # Start monitoring (runs continuously)
    await monitor.monitor_all(interval=300)

if __name__ == '__main__':
    asyncio.run(main())

# Add to crontab with: crontab -e

# Check for live streams every 5 minutes
*/5 * * * * /usr/bin/python3 /path/to/tiktok_monitor.py >> /var/log/tiktok_monitor.log 2>&1

# Or use systemd service for more control

#!/bin/bash
# tiktok_recorder.sh - Production recording script

set -e

# Configuration
CREATORS=("@creator1" "@creator2" "@creator3")
DOWNLOAD_DIR="$HOME/Videos/TikTok"
FFMPEG_PATH="/usr/bin/ffmpeg"
MAX_DURATION=14400  # 4 hours in seconds

# Create download directory
mkdir -p "$DOWNLOAD_DIR"

# Function to record a single creator
record_creator() {
    local username="$1"
    local timestamp=$(date +"%Y%m%d_%H%M%S")
    local log_file="$DOWNLOAD_DIR/${username}_${timestamp}.log"

    echo "[$(date)] Checking $username..."

    tiktok-live-recorder \
        -u "$username" \
        --download-folder "$DOWNLOAD_DIR" \
        --ffmpeg-path "$FFMPEG_PATH" \
        --tiktok-domain www.tiktok.com \
        --record-if-offline \
        --max-recording-duration "$MAX_DURATION" \
        2>&1 | tee "$log_file"

    echo "[$(date)] Finished recording $username"
}

# Main loop
main() {
    echo "Starting TikTok Live Recorder..."
    echo "Monitoring ${#CREATORS[@]} creators"

    while true; do
        for creator in "${CREATORS[@]}"; do
            record_creator "$creator"
        done

        # Wait 5 minutes before next check
        echo "Waiting 5 minutes..."
        sleep 300
    done
}

# Run main function
main "$@"

# Check if recorder is running
pgrep -f tiktok-live-recorder

# View active recordings
ls -lh ~/Videos/TikTok/*.mp4

# Check disk space (recordings can be large)
df -h ~/Videos/TikTok

# Monitor log file
tail -f ~/.config/tiktok-live-recorder/recorder.log