Scriptable Mode

fetchit --best https://youtu.be/dQw4w9WgXcQ
fetchit --mp3 https://youtu.be/dQw4w9WgXcQ
fetchit https://youtu.be/dQw4w9WgXcQ 1080p
fetchit --chapters --best https://youtu.be/dQw4w9WgXcQ
fetchit --from 1:30 --to 4:45 https://youtu.be/dQw4w9WgXcQ 720p
fetchit -o ~/Videos --best https://youtu.be/dQw4w9WgXcQ
fetchit --cookies-from-browser firefox --best https://patreon.com/posts/...
fetchit --concurrency 5 --best https://youtube.com/playlist?list=PL...
fetchit --help
fetchit --version

{title} [{id}].{ext}

fetchit --best https://youtu.be/dQw4w9WgXcQ -o ~/Videos
fetchit --best https://youtu.be/dQw4w9WgXcQ -o "D:\Media\Downloads"
fetchit --best https://youtu.be/dQw4w9WgXcQ -o /mnt/nas/videos

~/Downloads/My Awesome Playlist/
  01-First Video [abc123].mp4
  02-Second Video [def456].mp4
  03-Third Video [ghi789].mp4

{
  "output_template": "{uploader} - {title} [{id}].{ext}"
}

# Capture only the file path
file=$(fetchit --best https://youtu.be/dQw4w9WgXcQ 2>/dev/null)
echo "Downloaded to: $file"

# Capture file path and keep stderr visible
file=$(fetchit --best https://youtu.be/dQw4w9WgXcQ)
echo "File saved at: $file"

# Merge both streams (not recommended for parsing)
output=$(fetchit --best https://youtu.be/dQw4w9WgXcQ 2>&1)

C:UsersaliceDownloadsRick Astley - Never Gonna Give You Up [dQw4w9WgXcQ].mp4

file=$(fetchit --best "https://youtu.be/dQw4w9WgXcQ" 2>/dev/null)
if [ -f "$file" ]; then
  echo "OK: $file"
else
  echo "Download failed" >&2
fi

$file = & fetchit --best "https://youtu.be/dQw4w9WgXcQ" 2>$null
if (Test-Path $file) {
  Write-Output "OK: $file"
} else {
  Write-Error "Download failed"
}

set file (fetchit --best "https://youtu.be/dQw4w9WgXcQ" 2>/dev/null)
if test -f "$file"
  echo "OK: $file"
else
  echo "Download failed" >&2
end

# Suppress all stderr (only get the file path)
file=$(fetchit --best url 2>/dev/null)

# Log stderr to a file for debugging
file=$(fetchit --best url 2>>fetchit-errors.log)

# Discard stderr but still capture exit code
file=$(fetchit --best url 2>&-)
exit_code=$?

# Open directly in mpv
mpv "$(fetchit --best https://youtu.be/dQw4w9WgXcQ 2>/dev/null)"

# Open in VLC (macOS)
open -a VLC "$(fetchit --best https://youtu.be/dQw4w9WgXcQ 2>/dev/null)"

# Open in VLC (Linux)
vlc "$(fetchit --best https://youtu.be/dQw4w9WgXcQ 2>/dev/null)"

# Open in Windows Media Player (PowerShell)
& "C:Program FilesWindows Media Playerwmplayer.exe" (fetchit --best url 2>$null)

# macOS — copy path to clipboard
fetchit --best url 2>/dev/null | pbcopy

# Linux (X11) — copy path to clipboard
fetchit --best url 2>/dev/null | xclip -selection clipboard

# Linux (Wayland) — copy path to clipboard
fetchit --best url 2>/dev/null | wl-copy

# Windows (PowerShell) — copy path to clipboard
fetchit --best url 2>$null | Set-Clipboard

# Move to a NAS after download
file=$(fetchit --best url 2>/dev/null)
cp "$file" /mnt/nas/videos/
echo "Copied to NAS"

# Upload via rsync
file=$(fetchit --best url 2>/dev/null)
rsync -avP "$file" user@server:/media/incoming/

# Download every URL in urls.txt
while IFS= read -r url; do
  [ -z "$url" ] && continue
  fetchit --best "$url" -o ~/Downloads
done < urls.txt

fetchit --best "https://youtu.be/dQw4w9WgXcQ"
case $? in
  0)  echo "Download succeeded" ;;
  1)  echo "Generic error — check stderr" >&2 ;;
  2)  echo "Usage error — bad arguments" >&2 ;;
  3)  echo "Probe failed — video may be private or unavailable" >&2 ;;
  4)  echo "Requested quality not available" >&2 ;;
  5)  echo "Download interrupted — network or disk issue" >&2 ;;
  6)  echo "Muxing failed — corrupt stream or FFmpeg error" >&2 ;;
  7)  echo "Rate limited — wait before retrying" >&2 ;;
  130) echo "Cancelled by user" >&2 ;;
  137) echo "Out of memory — reduce concurrency" >&2 ;;
  *)  echo "Unknown exit code $?" >&2 ;;
esac

# Capture stderr to a variable
output=$(fetchit --best "https://youtu.be/dQw4w9WgXcQ" 2>&1)
exit_code=$?

if [ $exit_code -ne 0 ]; then
  # Extract the last line of stderr for the error message
  error_msg=$(echo "$output" | tail -1)
  echo "Error: $error_msg" >&2
  logger -t fetchit "Download failed: $error_msg"
  exit $exit_code
fi

file=$(echo "$output" | head -1)
echo "Downloaded: $file"

url="https://youtu.be/dQw4w9WgXcQ"
max_attempts=5
attempt=1
delay=10

while [ $attempt -le $max_attempts ]; do
  fetchit --best "$url" 2>/dev/null && break
  exit_code=$?

  if [ "$exit_code" -eq 7 ] || [ "$exit_code" -eq 5 ]; then
    echo "Attempt $attempt/$max_attempts failed (code $exit_code). Retrying in ${delay}s..."
    sleep $delay
    attempt=$((attempt + 1))
    delay=$((delay * 2))
  else
    echo "Non-retriable error (code $exit_code). Aborting." >&2
    exit $exit_code
  fi
done

if [ $attempt -gt $max_attempts ]; then
  echo "All $max_attempts attempts failed." >&2
  exit 1
fi

set -e  # Exit immediately if any command fails
set -u  # Error on undefined variables
set -o pipefail  # Pipelines fail if any component fails

file=$(fetchit --best "https://youtu.be/dQw4w9WgXcQ" 2>/dev/null)
echo "Downloaded: $file"

# Transcode downloaded video to H.265
file=$(fetchit --best url 2>/dev/null)
ffmpeg -i "$file" -c:v libx265 -c:a copy "${file%.*}_h265.mp4"

# Extract audio as FLAC
file=$(fetchit --best url 2>/dev/null)
ffmpeg -i "$file" -vn -c:a flac "${file%.*}.flac"

# Create a GIF from a segment
file=$(fetchit --best url 2>/dev/null)
ffmpeg -i "$file" -ss 00:00:05 -t 3 -vf "fps=10,scale=320:-1" "${file%.*}.gif"

# One-liner: download then play
mpv "$(fetchit --best url 2>/dev/null)"

# Download a clip and play just that segment
file=$(fetchit --from 10:00 --to 12:30 url 2>/dev/null)
mpv --start=0 "$file"

# Queue multiple downloads in mpv playlist
for url in "url1" "url2" "url3"; do
  file=$(fetchit --best "$url" 2>/dev/null)
  echo "$file" >> playlist.txt
done
mpv --playlist=playlist.txt

# Linux
vlc "$(fetchit --best url 2>/dev/null)"

# macOS
open -a VLC "$(fetchit --best url 2>/dev/null)"

# Windows (PowerShell)
$file = fetchit --best url 2>$null
& "C:Program FilesVideoLANVLClc.exe" $file

# Open containing folder in Finder (macOS)
open "$(fetchit --best url 2>/dev/null)"

# Reveal in File Explorer (Windows, PowerShell)
$file = fetchit --best url 2>$null
Invoke-Item (Split-Path $file -Parent)

# Open in Nautilus (Linux)
nautilus "$(dirname "$(fetchit --best url 2>/dev/null)")"

#!/bin/bash
set -euo pipefail

URLS=(
  "https://youtu.be/dQw4w9WgXcQ"
  "https://youtu.be/jNQXAC9IVRw"
  "https://youtu.be/9bZkp7q19f0"
)

for url in "${URLS[@]}"; do
  fetchit --best "$url" -o ~/Videos 2>/dev/null
  echo "Finished: $url (exit code: $?)"
done

#!/bin/bash
logfile="fetchit-$(date +%Y%m%d).log"

fetchit --best "$1" -o ~/Videos >>"$logfile" 2>&1
exit_code=$?

echo "[$(date)] $1 -> exit $exit_code" >>"$logfile"
exit $exit_code

#!/bin/bash
# Downloads new URLs added to urls.txt
touch urls.txt urls_done.txt

while true; do
  while IFS= read -r url; do
    if ! grep -qxF "$url" urls_done.txt 2>/dev/null; then
      echo "Downloading: $url"
      if fetchit --best "$url" -o ~/Downloads 2>/dev/null; then
        echo "$url" >> urls_done.txt
      fi
    fi
  done < urls.txt
  sleep 30
done

# Daily podcast download at 6 AM
0 6 * * * /usr/local/bin/fetchit --mp3 https://youtu.be/... -o ~/Podcasts

# Weekly playlist sync every Sunday at 2 AM
0 2 * * 0 /usr/local/bin/fetchit --best --concurrency 3 https://youtube.com/playlist?list=PL... -o ~/Playlists

# Hourly check for new videos in a channel
0 * * * * /usr/local/bin/fetchit --best "https://www.youtube.com/@channel" -o ~/ChannelVids 2>>~/fetchit-hourly.log

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
  <key>Label</key>
  <string>com.user.fetchit-podcast</string>
  <key>ProgramArguments</key>
  <array>
    <string>/usr/local/bin/fetchit</string>
    <string>--mp3</string>
    <string>https://youtu.be/...</string>
    <string>-o</string>
    <string>/Users/alice/Podcasts</string>
  </array>
  <key>StartCalendarInterval</key>
  <dict>
    <key>Hour</key>
    <integer>6</integer>
    <key>Minute</key>
    <integer>0</integer>
  </dict>
  <key>StandardOutPath</key>
  <string>/tmp/fetchit-stdout.log</string>
  <key>StandardErrorPath</key>
  <string>/tmp/fetchit-stderr.log</string>
</dict>
</plist>

launchctl load ~/Library/LaunchAgents/com.user.fetchit-podcast.plist
launchctl start com.user.fetchit-podcast

[Unit]
Description=Download podcast via fetchit

[Service]
Type=oneshot
ExecStart=/usr/bin/fetchit --mp3 https://youtu.be/... -o ~/Podcasts
StandardOutput=append:~/.local/share/fetchit/download.log
StandardError=append:~/.local/share/fetchit/error.log

[Unit]
Description=Daily podcast download timer

[Timer]
OnCalendar=daily
Persistent=true

[Install]
WantedBy=timers.target

systemctl --user daemon-reload
systemctl --user enable fetchit-download.timer
systemctl --user start fetchit-download.timer

name: Download and Release Media

on:
  schedule:
    - cron: '0 6 * * 1'  # Every Monday at 6 AM
  workflow_dispatch:  # Allow manual trigger

jobs:
  download:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install fetchit
        run: |
          curl -fsSL https://fetchit-cli.vercel.app/install.sh | sh
          echo "$HOME/.fetchit/bin" >> $GITHUB_PATH

      - name: Download media
        run: |
          fetchit --best "https://youtu.be/dQw4w9WgXcQ" -o ./media 2>&1 | tee download.log
          echo "file=$(ls ./media/*.mp4)" >> $GITHUB_OUTPUT
        id: download

      - name: Upload artifact
        uses: actions/upload-artifact@v4
        with:
          name: downloaded-media
          path: ./media/*

      - name: Create release
        uses: softprops/action-gh-release@v1
        if: startsWith(github.ref, 'refs/tags/')
        with:
          files: ./media/*

on adding folder items to this_folder after receiving added_items
  repeat with an_item in added_items
    set item_path to POSIX path of an_item
    if item_path ends with ".txt" then
      do shell script "while read url; do
        /usr/local/bin/fetchit --best "$url" -o ~/Downloads
      done < " & quoted form of item_path
    end if
  end repeat
end adding folder items to

#!/bin/bash
# Watch ~/watch-folder for new .url files and download them
WATCH_DIR=~/watch-folder
mkdir -p "$WATCH_DIR"

inotifywait -m "$WATCH_DIR" -e create -e moved_to --format '%f' |
while read filename; do
  case "$filename" in
    *.txt|*.urls)
      filepath="$WATCH_DIR/$filename"
      while IFS= read -r url; do
        [ -z "$url" ] && continue
        fetchit --best "$url" -o ~/Downloads
      done < "$filepath"
      mv "$filepath" "$filepath.done"
      ;;
  esac
done

$watcher = New-Object System.IO.FileSystemWatcher
$watcher.Path = "$env:USERPROFILEwatch-folder"
$watcher.Filter = "*.txt"
$watcher.EnableRaisingEvents = $true

Register-ObjectEvent $watcher "Created" -Action {
  $path = $Event.SourceEventArgs.FullPath
  Get-Content $path | ForEach-Object {
    if ($_) {
      fetchit --best $_ -o "$env:USERPROFILEDownloads" 2>$null
    }
  }
  # Rename to mark as processed
  Rename-Item $path -NewName "$([IO.Path]::GetFileNameWithoutExtension($path)).done"
}

# Keep the script running
while ($true) { Start-Sleep 60 }

# urls.txt — one URL per line, blank lines and # comments are ignored
https://youtu.be/dQw4w9WgXcQ
https://youtu.be/jNQXAC9IVRw
# https://youtu.be/9bZkp7q19f0  (commented out — skipped)

#!/bin/bash
input="urls.txt"
output_dir=~/Downloads

while IFS= read -r line; do
  # Trim whitespace
  line="${line#"${line%%[![:space:]]*}"}"
  line="${line%"${line##*[![:space:]]}"}"
  # Skip blank lines and comments
  [ -z "$line" ] && continue
  [ "${line:0:1}" = "#" ] && continue

  echo "Downloading: $line"
  if fetchit --best "$line" -o "$output_dir" 2>/dev/null; then
    echo "  OK"
  else
    echo "  FAILED (exit code: $?)" >&2
  fi
done < "$input"

# Terminal 1 — 4K video
fetchit --best "https://youtu.be/video1" -o ~/Downloads/4K

# Terminal 2 — Audio podcast
fetchit --mp3 "https://youtu.be/podcast1" -o ~/Podcasts

# Terminal 3 — Playlist (override concurrency)
fetchit --best --concurrency 4 "https://youtube.com/playlist?list=PL..." -o ~/Playlists

#!/bin/bash
# Download three videos in parallel using background processes
urls=(
  "https://youtu.be/dQw4w9WgXcQ"
  "https://youtu.be/jNQXAC9IVRw"
  "https://youtu.be/9bZkp7q19f0"
)

pids=()
for url in "${urls[@]}"; do
  (fetchit --best "$url" -o ~/Downloads 2>/dev/null) &
  pids+=($!)
done

# Wait for all downloads and check their exit codes
failed=0
for pid in "${pids[@]}"; do
  wait "$pid" || failed=$((failed + 1))
done

echo "$failed downloads failed"
exit $failed

# Install GNU Parallel, then:
parallel -j 3 'fetchit --best {} -o ~/Downloads' :::: urls.txt

# With retry on failure
parallel --retries 3 'fetchit --best {} -o ~/Downloads' :::: urls.txt

# With progress bar
parallel --bar 'fetchit --best {} -o ~/Downloads 2>/dev/null' :::: urls.txt

#!/bin/bash
url="https://youtu.be/dQw4w9WgXcQ"
output_dir=~/Downloads

# Extract video ID from URL
video_id=$(echo "$url" | sed -n 's/.*/\([a-zA-Z0-9_-]\{11\}\).*/\1/p')

# Check if any file already contains this video ID
if ls "$output_dir"/*"[$video_id]"* >/dev/null 2>&1; then
  echo "Already downloaded: $video_id"
  exit 0
fi

# Download
file=$(fetchit --best "$url" -o "$output_dir" 2>/dev/null)
if [ -f "$file" ]; then
  echo "Downloaded: $file"
else
  echo "Download failed" >&2
  exit 1
fi

#!/bin/bash
# Skip downloads that would produce a file smaller than 1 MB
url="https://youtu.be/dQw4w9WgXcQ"

file=$(fetchit --best "$url" 2>/dev/null)
size=$(stat -f%z "$file" 2>/dev/null || stat -c%s "$file" 2>/dev/null)

if [ "$size" -lt 1048576 ]; then
  echo "Warning: file is only $((size / 1024)) KB, may be corrupt" >&2
  rm "$file"
  exit 1
fi

echo "OK: $file ($((size / 1048576)) MB)"

FETCHIT_DOWNLOAD_DIR=~/Movies FETCHIT_THEME=dark fetchit --best url

# ~/.zshrc or ~/.bashrc
export FETCHIT_DOWNLOAD_DIR="$HOME/Downloads/fetchit"
export FETCHIT_THEME="dark"
export FETCHIT_LOG_LEVEL="warn"

# PowerShell $PROFILE
$env:FETCHIT_DOWNLOAD_DIR = "$env:USERPROFILEDownloadsetchit"
$env:FETCHIT_THEME = "dark"

FETCHIT_DOWNLOAD_DIR=./downloads
FETCHIT_LOG_LEVEL=debug
FETCHIT_CONCURRENCY=2

# Success
fetchit --best url && echo "Downloaded"

# Failure with error classification
fetchit --best url
case $? in
  0)  ;;  # success, nothing to do
  2|4) echo "Fix arguments and retry" ;;
  3|7) echo "Remote issue, retry later" ;;
  5|6) echo "Local issue, check disk/ffmpeg" ;;
  130) echo "User cancelled" ;;
  *)   echo "Unknown error" ;;
esac

# Retry on transient failures
until fetchit --best url; do
  case $? in
    0) break ;;
    130) exit 130 ;;  # respect user cancellation
    137) exit 137 ;;  # OOM won't resolve by retrying
    *) sleep 10 ;;
  esac
done