WP-CLI transforms bulk content operations from tedious manual work into fast, scriptable workflows. Update unlimited posts with one command, batch-assign taxonomies, transform content structure, and automate complex content management tasks.

In this guide, you’ll learn advanced WP-CLI techniques for bulk content operations used by high-volume WordPress publishers managing thousands of posts efficiently.

Why Bulk Content Operations Matter

WordPress content management at scale requires automation—manual operations don’t work beyond 50-100 posts.

Problems with Manual Bulk Editing

Time-consuming: Updating 1,000 posts manually takes weeks of repetitive work.

Error-prone: Manual operations introduce inconsistencies and mistakes.

Limited scope: Can’t perform complex transformations or conditional updates.

No validation: Can’t preview changes before executing them.

Not repeatable: Can’t reuse workflows or share processes with team.

WP-CLI Bulk Operation Advantages

Lightning fast: Update 10,000 posts in minutes instead of weeks.

Scriptable: Save complex operations as reusable scripts.

Conditional logic: Update only posts matching specific criteria.

Preview mode: Test operations before executing on production data.

Audit trails: Log all changes for compliance and debugging.

According to content management studies, sites with 1,000+ posts save 40+ hours monthly with automated bulk operations.

Bulk Post Status Operations

Manage post publication status at scale.

Bulk Status Changes

# Publish all drafts
wp post update $(wp post list --post_status=draft --format=ids) --post_status=publish

# Draft all scheduled posts
wp post update $(wp post list --post_status=future --format=ids) --post_status=draft

# Unpublish posts older than 2 years
wp post list --post_status=publish --before="2 years ago" --format=ids | xargs wp post update --post_status=draft

# Archive old posts (change status)
YEAR_AGO=$(date -d "1 year ago" +%Y-%m-%d)
wp post update $(wp post list --post_status=publish --before="$YEAR_AGO" --format=ids) --post_status=private

Conditional Status Updates

#!/bin/bash
# update-post-status-by-category.sh

CATEGORY_ID=5  # Posts in this category
TARGET_STATUS="draft"

# Get posts in specific category
POSTS=$(wp post list --category_id=$CATEGORY_ID --post_status=publish --format=ids)

if [ -z "$POSTS" ]; then
    echo "No posts found in category $CATEGORY_ID"
    exit 0
fi

# Count posts
COUNT=$(echo $POSTS | wc -w)
echo "Found $COUNT posts to update"

# Update status
wp post update $POSTS --post_status=$TARGET_STATUS

echo "✓ Updated $COUNT posts to $TARGET_STATUS status"

Learn more about WordPress post statuses.

Bulk Taxonomy Assignment

Assign categories, tags, and custom taxonomies in bulk.

Bulk Category Operations

# Add category to all posts
CATEGORY_ID=10
for post_id in $(wp post list --format=ids); do
    wp post term add $post_id category $CATEGORY_ID
done

# Remove category from all posts
for post_id in $(wp post list --format=ids); do
    wp post term remove $post_id category 3
done

# Replace category across posts
OLD_CAT=5
NEW_CAT=10
POSTS=$(wp post list --category=$OLD_CAT --format=ids)

for post_id in $POSTS; do
    wp post term remove $post_id category $OLD_CAT
    wp post term add $post_id category $NEW_CAT
done

echo "✓ Category replacement complete"

Bulk Tag Operations

# Add tags to all posts without tags
wp post list --format=ids | while read post_id; do
    TAG_COUNT=$(wp post term list $post_id post_tag --format=count)

    if [ "$TAG_COUNT" -eq 0 ]; then
        echo "Adding tags to post $post_id"
        wp post term add $post_id post_tag "general,uncategorized"
    fi
done

# Remove all tags from specific category
POSTS=$(wp post list --category_name="old-news" --format=ids)
for post_id in $POSTS; do
    wp post term remove $post_id post_tag --all
done

Smart Auto-Categorization

#!/bin/bash
# auto-categorize-by-keywords.sh - Assign categories based on content

# Define keyword-to-category mapping
declare -A KEYWORDS=(
    ["WordPress"]="5"
    ["security"]="8"
    ["performance"]="12"
    ["tutorial"]="15"
)

# Search for keywords and assign categories
for KEYWORD in "${!KEYWORDS[@]}"; do
    CAT_ID="${KEYWORDS[$KEYWORD]}"

    echo "Processing keyword: $KEYWORD → Category $CAT_ID"

    # Find posts containing keyword
    POSTS=$(wp post list --s="$KEYWORD" --post_status=publish --format=ids)

    for post_id in $POSTS; do
        # Check if category already assigned
        HAS_CAT=$(wp post term list $post_id category --field=term_id | grep -c "^${CAT_ID}
quot;)

        if [ "$HAS_CAT" -eq 0 ]; then
            echo "  Adding category $CAT_ID to post $post_id"
            wp post term add $post_id category $CAT_ID
        fi
    done
done

echo "✓ Auto-categorization complete"

Bulk Author Updates

Reassign post authorship in bulk.

Change Post Authors

# Reassign all posts from one author to another
OLD_AUTHOR_ID=5
NEW_AUTHOR_ID=1

wp post update $(wp post list --author=$OLD_AUTHOR_ID --format=ids) --post_author=$NEW_AUTHOR_ID

# Update posts by author email
OLD_EMAIL="old@example.com"
NEW_AUTHOR_ID=2

OLD_AUTHOR=$(wp user list --user_email=$OLD_EMAIL --field=ID)
wp post update $(wp post list --author=$OLD_AUTHOR --format=ids) --post_author=$NEW_AUTHOR_ID

Distribute Posts Across Authors

#!/bin/bash
# distribute-posts.sh - Evenly distribute posts across authors

AUTHORS=(2 5 8 12)  # Author IDs
POSTS=$(wp post list --post_status=publish --format=ids)

# Convert to array
POST_ARRAY=($POSTS)
TOTAL_POSTS=${#POST_ARRAY[@]}
AUTHOR_COUNT=${#AUTHORS[@]}

echo "Distributing $TOTAL_POSTS posts across $AUTHOR_COUNT authors..."

INDEX=0
for post_id in "${POST_ARRAY[@]}"; do
    AUTHOR_INDEX=$((INDEX % AUTHOR_COUNT))
    AUTHOR_ID=${AUTHORS[$AUTHOR_INDEX]}

    wp post update $post_id --post_author=$AUTHOR_ID

    ((INDEX++))
done

echo "✓ Post distribution complete"

Bulk Post Meta Operations

Add, update, or delete custom fields across posts.

Add Meta to All Posts

# Add custom field to all posts
for post_id in $(wp post list --format=ids); do
    wp post meta add $post_id featured_priority "normal"
done

# Add meta only to posts without it
for post_id in $(wp post list --format=ids); do
    if ! wp post meta get $post_id custom_field &>/dev/null; then
        wp post meta add $post_id custom_field "default_value"
    fi
done

Update Meta in Bulk

# Update meta for posts in specific category
POSTS=$(wp post list --category_name="premium" --format=ids)

for post_id in $POSTS; do
    wp post meta update $post_id access_level "premium"
    wp post meta update $post_id show_ads "false"
done

# Conditional meta update
for post_id in $(wp post list --format=ids); do
    OLD_VALUE=$(wp post meta get $post_id old_field 2>/dev/null)

    if [ -n "$OLD_VALUE" ]; then
        wp post meta add $post_id new_field "$OLD_VALUE"
        wp post meta delete $post_id old_field
    fi
done

Clean Orphaned Meta

#!/bin/bash
# clean-post-meta.sh - Remove meta from deleted posts

echo "Cleaning orphaned post meta..."

# SQL query to find orphaned meta
wp db query "
DELETE FROM wp_postmeta
WHERE post_id NOT IN (
    SELECT ID FROM wp_posts
)
"

echo "✓ Orphaned post meta cleaned"

Learn about WordPress custom fields.

Content Transformation Operations

Transform post content structure and format.

Bulk Content Search-Replace

# Replace text in all post content
wp search-replace "old company name" "new company name" wp_posts --dry-run
wp search-replace "old company name" "new company name" wp_posts

# Update image URLs
wp search-replace "http://oldcdn.com" "https://newcdn.com" wp_posts

# Fix broken shortcodes
wp search-replace "[old_shortcode" "[new_shortcode" wp_posts

Add Content Prefix/Suffix

#!/bin/bash
# add-content-notice.sh - Add notice to all posts

NOTICE='<div class="post-notice">This article was published over a year ago.</div>'

# Get posts older than 1 year
POSTS=$(wp post list --before="1 year ago" --post_status=publish --format=ids)

for post_id in $POSTS; do
    CONTENT=$(wp post get $post_id --field=post_content)

    # Check if notice already exists
    if [[ ! "$CONTENT" =~ "post-notice" ]]; then
        NEW_CONTENT="${NOTICE}${CONTENT}"

        wp post update $post_id --post_content="$NEW_CONTENT"
        echo "Added notice to post $post_id"
    fi
done

echo "✓ Content notices added"

Convert Post Types

# Convert posts to pages
for post_id in $(wp post list --post_type=post --format=ids); do
    wp post update $post_id --post_type=page
done

# Convert pages back to posts
for post_id in $(wp post list --post_type=page --format=ids); do
    wp post update $post_id --post_type=post --post_category=1
done

Bulk Post Cleanup

Remove unwanted content and maintain database health.

Delete Posts by Criteria

# Delete all drafts older than 6 months
wp post delete $(wp post list --post_status=draft --before="6 months ago" --format=ids) --force

# Delete empty posts
wp post delete $(wp post list --post_content="" --format=ids) --force

# Empty trash
wp post delete $(wp post list --post_status=trash --format=ids) --force

# Delete posts with specific meta
for post_id in $(wp post list --format=ids); do
    if wp post meta get $post_id spam_flag 2>/dev/null | grep -q "true"; then
        wp post delete $post_id --force
        echo "Deleted spam post: $post_id"
    fi
done

Clean Revisions

# Delete all revisions
wp post delete $(wp post list --post_type=revision --format=ids) --force

# Keep only last 5 revisions per post (requires custom logic)
#!/bin/bash
for post_id in $(wp post list --format=ids); do
    # Get revision IDs
    REVISIONS=$(wp post list --post_type=revision --post_parent=$post_id --orderby=date --order=DESC --format=ids)

    # Convert to array
    REV_ARRAY=($REVISIONS)

    # Delete all but first 5
    if [ ${#REV_ARRAY[@]} -gt 5 ]; then
        REVISIONS_TO_DELETE="${REV_ARRAY[@]:5}"
        wp post delete $REVISIONS_TO_DELETE --force
    fi
done

Scheduled Content Operations

Automate recurring bulk content tasks.

Auto-Publish Scheduled Script

#!/bin/bash
# auto-publish-oldest-draft.sh - Publish oldest draft daily

MAX_POSTS=${1:-1}

echo "Publishing up to $MAX_POSTS draft posts..."

DRAFTS=$(wp post list \
    --post_status=draft \
    --orderby=date \
    --order=ASC \
    --posts_per_page=$MAX_POSTS \
    --format=ids)

if [ -z "$DRAFTS" ]; then
    echo "No drafts available"
    exit 0
fi

for post_id in $DRAFTS; do
    TITLE=$(wp post get $post_id --field=post_title)
    echo "Publishing: $TITLE"

    wp post update $post_id \
        --post_status=publish \
        --post_date="$(date '+%Y-%m-%d %H:%M:%S')"
done

echo "✓ Publishing complete"

Schedule with cron:

# Publish 1 draft daily at 9 AM
0 9 * * * /usr/local/bin/auto-publish-oldest-draft.sh 1

Monthly Content Audit

#!/bin/bash
# monthly-content-audit.sh

REPORT="/tmp/content-audit-$(date +%Y%m).txt"

{
    echo "WordPress Content Audit Report"
    echo "Generated: $(date)"
    echo "=============================="
    echo ""

    echo "Total Posts: $(wp post list --post_type=post --format=count)"
    echo "Published: $(wp post list --post_status=publish --format=count)"
    echo "Drafts: $(wp post list --post_status=draft --format=count)"
    echo "Scheduled: $(wp post list --post_status=future --format=count)"
    echo ""

    echo "Posts by Category:"
    wp term list category --fields=name,count --format=table
    echo ""

    echo "Posts Without Categories:"
    wp post list --category=0 --format=count
    echo ""

    echo "Posts Without Tags:"
    for post_id in $(wp post list --format=ids | head -100); do
        TAG_COUNT=$(wp post term list $post_id post_tag --format=count)
        [ "$TAG_COUNT" -eq 0 ] && ((NO_TAGS++))
    done
    echo "${NO_TAGS:-0} posts"

} > "$REPORT"

# Email report
mail -s "Monthly Content Audit" admin@example.com < "$REPORT"

echo "✓ Audit report sent"

Next Steps

You now have advanced bulk content operation skills for WordPress at scale.

Recommended Learning Path

Week 1: Basic bulk operations

• Practice post status updates
• Master taxonomy assignments
• Update post authors

Week 2: Advanced transformations

• Content search-replace
• Meta field operations
• Post type conversions

Week 3: Cleanup automation

• Delete unwanted content
• Manage revisions
• Orphaned data cleanup

Week 4: Scheduled workflows

• Auto-publishing scripts
• Content audits
• Maintenance automation

Advanced Topics

1. Custom Post Type Bulk Operations – Advanced CPT management
2. Multi-Site Content Sync – Network-wide operations
3. AI Content Enhancement – Automated content improvements

Get More Resources

Download bulk operation scripts including:

• Complete automation toolkit
• Content transformation scripts
• Cleanup utilities

Join our email course for:

• Weekly WP-CLI tutorials
• Content management strategies
• Automation best practices

Conclusion

WP-CLI bulk content operations transform WordPress content management from manual drudgery into fast, automated workflows that handle any scale.

What we covered:

✅ Bulk post status and publication management
✅ Taxonomy assignment and reorganization
✅ Author reassignment and distribution
✅ Post meta bulk operations
✅ Content transformation and cleanup
✅ Scheduled and automated workflows

Master these techniques, and you’ll manage thousands of WordPress posts as easily as managing ten—whether publishing content at scale or maintaining large content archives.

Ready for more? Learn WordPress content migration or automated content workflows.

Questions about bulk content operations in WordPress? Drop a comment below!

Found this helpful? Share with other WordPress content managers.

The post Bulk Content Operations in WordPress: WP-CLI Advanced Techniques appeared first on WP-CLI Mastery.

Understanding WordPress Media Management

WordPress stores media files in the uploads directory while maintaining database records for each attachment. These records include metadata like file paths, dimensions, captions, alt text, and custom fields. Effective media automation requires managing both filesystem operations and database records simultaneously.

The media library grows rapidly on content-heavy sites. Manual management becomes impractical when dealing with bulk operations like regenerating thumbnails, updating metadata, or migrating files. WP-CLI provides the tools to automate these tasks efficiently.

Bulk Image Import and Upload

Traditional WordPress uploads through the dashboard are slow for large batches. WP-CLI enables efficient bulk imports from local directories or remote URLs.

# Import single image
wp media import /path/to/image.jpg --post_id=123 --title="Image Title" --alt="Alt text"

# Import all images from a directory
wp media import /path/to/images/*.jpg --porcelain

# Import images and assign to specific post
for file in /path/to/images/*.jpg; do
    wp media import "$file" --post_id=456 --featured_image
done

# Import from URL
wp media import https://example.com/image.jpg --title="Remote Image"

# Bulk import with metadata from CSV
while IFS=',' read -r filepath title alt caption; do
    wp media import "$filepath" --title="$title" --alt="$alt" --caption="$caption"
done < images.csv

Create a comprehensive bulk import script:

#!/bin/bash
# bulk-media-import.sh - Import media with metadata

set -euo pipefail

WP_PATH="/var/www/html"
IMPORT_DIR="/path/to/import"
LOG_FILE="/var/log/media-import-$(date +%Y%m%d).log"

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
}

# Check if import directory exists
if [ ! -d "$IMPORT_DIR" ]; then
    log "ERROR: Import directory does not exist: $IMPORT_DIR"
    exit 1
fi

log "Starting bulk media import from $IMPORT_DIR"

# Count files to process
TOTAL_FILES=$(find "$IMPORT_DIR" -type f \( -iname "*.jpg" -o -iname "*.jpeg" -o -iname "*.png" -o -iname "*.gif" \) | wc -l)
log "Found $TOTAL_FILES files to import"

IMPORTED=0
FAILED=0

# Process each image
find "$IMPORT_DIR" -type f \( -iname "*.jpg" -o -iname "*.jpeg" -o -iname "*.png" -o -iname "*.gif" \) | while read -r file; do
    FILENAME=$(basename "$file")
    log "Processing: $FILENAME"

    # Extract metadata from filename (example: product-123-description.jpg)
    if [[ "$FILENAME" =~ ^([^-]+)-([0-9]+)-(.+)\..+$ ]]; then
        TYPE="${BASH_REMATCH[1]}"
        POST_ID="${BASH_REMATCH[2]}"
        DESCRIPTION="${BASH_REMATCH[3]}"

        # Import with metadata
        if ATTACHMENT_ID=$(wp --path="$WP_PATH" media import "$file" \
            --post_id="$POST_ID" \
            --title="$DESCRIPTION" \
            --alt="$DESCRIPTION" \
            --porcelain 2>&1); then

            log "SUCCESS: Imported $FILENAME (ID: $ATTACHMENT_ID)"
            ((IMPORTED++))

            # Move processed file to archive
            mkdir -p "$IMPORT_DIR/processed"
            mv "$file" "$IMPORT_DIR/processed/"
        else
            log "ERROR: Failed to import $FILENAME: $ATTACHMENT_ID"
            ((FAILED++))
        fi
    else
        # Import without post association
        if ATTACHMENT_ID=$(wp --path="$WP_PATH" media import "$file" --porcelain 2>&1); then
            log "SUCCESS: Imported $FILENAME (ID: $ATTACHMENT_ID)"
            ((IMPORTED++))
            mv "$file" "$IMPORT_DIR/processed/"
        else
            log "ERROR: Failed to import $FILENAME"
            ((FAILED++))
        fi
    fi
done

log "Import completed. Imported: $IMPORTED, Failed: $FAILED"

Thumbnail Regeneration

Changing themes or image sizes requires regenerating thumbnails for existing images. WP-CLI makes this process efficient.

# Regenerate all thumbnails
wp media regenerate --yes

# Regenerate only missing thumbnails
wp media regenerate --only-missing --yes

# Regenerate for specific image sizes
wp media regenerate --image_size=thumbnail,medium --yes

# Regenerate images from specific year
wp media regenerate --yes $(wp post list --post_type=attachment --year=2024 --format=ids)

# Regenerate for specific attachment IDs
wp media regenerate 123 456 789 --yes

# Skip thumbnail generation (only register sizes)
wp media regenerate --skip-delete --yes

Automated thumbnail regeneration with progress tracking:

#!/bin/bash
# regenerate-thumbnails.sh - Regenerate with progress tracking

WP_PATH="/var/www/html"

# Get total attachment count
TOTAL=$(wp --path="$WP_PATH" post list --post_type=attachment --post_mime_type=image --format=count)
echo "Total images to process: $TOTAL"

# Process in batches
BATCH_SIZE=50
PROCESSED=0

while [ $PROCESSED -lt $TOTAL ]; do
    echo "Processing batch: $PROCESSED to $((PROCESSED + BATCH_SIZE))"

    # Get batch of attachment IDs
    IDS=$(wp --path="$WP_PATH" post list \
        --post_type=attachment \
        --post_mime_type=image \
        --posts_per_page=$BATCH_SIZE \
        --offset=$PROCESSED \
        --format=ids)

    if [ -n "$IDS" ]; then
        wp --path="$WP_PATH" media regenerate $IDS --yes
    fi

    PROCESSED=$((PROCESSED + BATCH_SIZE))
    echo "Progress: $PROCESSED / $TOTAL ($(( PROCESSED * 100 / TOTAL ))%)"

    # Sleep to avoid overloading server
    sleep 2
done

echo "Thumbnail regeneration completed"

Image Optimization

Optimize images to reduce file sizes and improve site performance.

# Install optimization plugin
wp plugin install ewww-image-optimizer --activate

# Configure optimization settings
wp option update ewww_image_optimizer_auto true
wp option update ewww_image_optimizer_jpg_level 30
wp option update ewww_image_optimizer_png_level 10

# Optimize all existing images
wp ewwwio optimize all

# Optimize specific images
wp media regenerate --yes --image_size=full

Alternative optimization with ImageMagick:

#!/bin/bash
# optimize-images.sh - Optimize images using ImageMagick

WP_PATH="/var/www/html"
UPLOADS_DIR="$WP_PATH/wp-content/uploads"
QUALITY=85

echo "Optimizing images in $UPLOADS_DIR"

# Find and optimize JPG files
find "$UPLOADS_DIR" -type f -iname "*.jpg" -o -iname "*.jpeg" | while read -r file; do
    echo "Optimizing: $file"

    # Create backup
    cp "$file" "$file.backup"

    # Optimize with ImageMagick
    convert "$file" -strip -interlace Plane -quality $QUALITY "$file"

    # Check if optimization saved space
    ORIGINAL_SIZE=$(stat -f%z "$file.backup" 2>/dev/null || stat -c%s "$file.backup")
    NEW_SIZE=$(stat -f%z "$file" 2>/dev/null || stat -c%s "$file")

    if [ "$NEW_SIZE" -lt "$ORIGINAL_SIZE" ]; then
        SAVED=$((ORIGINAL_SIZE - NEW_SIZE))
        echo "Saved: $SAVED bytes"
        rm "$file.backup"
    else
        # Restore if no improvement
        mv "$file.backup" "$file"
    fi
done

# Optimize PNG files
find "$UPLOADS_DIR" -type f -iname "*.png" | while read -r file; do
    echo "Optimizing: $file"
    optipng -o2 "$file"
done

echo "Image optimization completed"

Metadata Management

Update alt text, captions, titles, and descriptions programmatically.

# Update alt text for specific attachment
wp post meta update 123 _wp_attachment_image_alt "New alt text"

# Update attachment title
wp post update 123 --post_title="New Title"

# Update caption
wp post update 123 --post_excerpt="New caption"

# Update description
wp post update 123 --post_content="New description"

# Bulk update alt text based on filename
for id in $(wp post list --post_type=attachment --format=ids); do
    FILENAME=$(wp post get $id --field=post_title)
    # Generate alt text from filename
    ALT_TEXT=$(echo "$FILENAME" | sed 's/-/ /g' | sed 's/\.[^.]*$//')
    wp post meta update $id _wp_attachment_image_alt "$ALT_TEXT"
    echo "Updated alt text for ID $id: $ALT_TEXT"
done

Comprehensive metadata update script:

#!/bin/bash
# update-media-metadata.sh - Bulk metadata updates

WP_PATH="/var/www/html"
CSV_FILE="media-metadata.csv"

# CSV format: attachment_id,title,alt,caption,description

while IFS=',' read -r id title alt caption description; do
    # Skip header row
    if [ "$id" == "attachment_id" ]; then
        continue
    fi

    echo "Updating attachment ID: $id"

    # Update title
    if [ -n "$title" ]; then
        wp --path="$WP_PATH" post update "$id" --post_title="$title"
    fi

    # Update alt text
    if [ -n "$alt" ]; then
        wp --path="$WP_PATH" post meta update "$id" _wp_attachment_image_alt "$alt"
    fi

    # Update caption
    if [ -n "$caption" ]; then
        wp --path="$WP_PATH" post update "$id" --post_excerpt="$caption"
    fi

    # Update description
    if [ -n "$description" ]; then
        wp --path="$WP_PATH" post update "$id" --post_content="$description"
    fi

    echo "Metadata updated for attachment $id"
done < "$CSV_FILE"

echo "Bulk metadata update completed"

Media Library Cleanup

Remove unused, broken, or duplicate media files.

# Find unattached media (not assigned to any post)
wp post list --post_type=attachment --post_parent=0 --format=ids

# Delete unattached media
wp post delete $(wp post list --post_type=attachment --post_parent=0 --format=ids) --force

# Find and remove broken attachments (missing files)
for id in $(wp post list --post_type=attachment --format=ids); do
    FILE=$(wp post meta get $id _wp_attached_file)
    FULL_PATH="/var/www/html/wp-content/uploads/$FILE"

    if [ ! -f "$FULL_PATH" ]; then
        echo "Missing file for attachment $id: $FILE"
        wp post delete $id --force
    fi
done

# Find duplicate images by hash
find /var/www/html/wp-content/uploads -type f -exec md5sum {} + | \
    sort | \
    uniq -w32 -D

Automated cleanup script:

#!/bin/bash
# media-cleanup.sh - Clean up media library

set -euo pipefail

WP_PATH="/var/www/html"
DRY_RUN=false

if [ "${1:-}" == "--dry-run" ]; then
    DRY_RUN=true
    echo "Running in dry-run mode (no changes will be made)"
fi

echo "=== Media Library Cleanup ==="

# Find orphaned attachments (older than 30 days, never used)
echo "Finding orphaned attachments..."
ORPHANED_IDS=$(wp --path="$WP_PATH" post list \
    --post_type=attachment \
    --post_parent=0 \
    --post_status=inherit \
    --format=ids \
    --date_query='[{"before":"30 days ago"}]')

if [ -n "$ORPHANED_IDS" ]; then
    ORPHANED_COUNT=$(echo "$ORPHANED_IDS" | wc -w)
    echo "Found $ORPHANED_COUNT orphaned attachments"

    if [ "$DRY_RUN" == false ]; then
        echo "Deleting orphaned attachments..."
        wp --path="$WP_PATH" post delete $ORPHANED_IDS --force
    else
        echo "Would delete: $ORPHANED_IDS"
    fi
else
    echo "No orphaned attachments found"
fi

# Check for broken file links
echo "Checking for broken file links..."
UPLOADS_DIR="$WP_PATH/wp-content/uploads"
BROKEN_COUNT=0

for id in $(wp --path="$WP_PATH" post list --post_type=attachment --format=ids); do
    FILE=$(wp --path="$WP_PATH" post meta get $id _wp_attached_file)
    FULL_PATH="$UPLOADS_DIR/$FILE"

    if [ ! -f "$FULL_PATH" ]; then
        echo "Broken attachment $id: $FILE"
        ((BROKEN_COUNT++))

        if [ "$DRY_RUN" == false ]; then
            wp --path="$WP_PATH" post delete $id --force
        fi
    fi
done

echo "Found $BROKEN_COUNT broken attachments"

# Remove unused image sizes
echo "Cleaning up unused image sizes..."
find "$UPLOADS_DIR" -type f -regextype posix-extended \
    -regex '.*-[0-9]+x[0-9]+\.(jpg|jpeg|png|gif)$' \
    -mtime +90 | head -10

echo "Media cleanup completed"

Featured Image Management

Automate featured image assignment across posts.

# Set featured image for specific post
wp post meta set 123 _thumbnail_id 456

# Assign first attached image as featured image
for post_id in $(wp post list --post_type=post --format=ids); do
    # Get first attachment
    ATTACHMENT_ID=$(wp post list --post_type=attachment --post_parent=$post_id --posts_per_page=1 --format=ids)

    if [ -n "$ATTACHMENT_ID" ]; then
        wp post meta set $post_id _thumbnail_id $ATTACHMENT_ID
        echo "Set featured image for post $post_id"
    fi
done

# Download and set featured image from URL
URL="https://example.com/image.jpg"
POST_ID=123

ATTACHMENT_ID=$(wp media import "$URL" --post_id=$POST_ID --porcelain)
wp post meta set $POST_ID _thumbnail_id $ATTACHMENT_ID

File Organization and Migration

Reorganize uploads directory or migrate media between sites.

#!/bin/bash
# organize-uploads.sh - Organize uploads by year/month

WP_PATH="/var/www/html"
UPLOADS_DIR="$WP_PATH/wp-content/uploads"

# Enable year/month organization
wp --path="$WP_PATH" option update uploads_use_yearmonth_folders 1

# Migrate existing files to year/month structure
for id in $(wp --path="$WP_PATH" post list --post_type=attachment --format=ids); do
    # Get attachment date
    DATE=$(wp --path="$WP_PATH" post get $id --field=post_date)
    YEAR=$(date -d "$DATE" +%Y 2>/dev/null || echo "")
    MONTH=$(date -d "$DATE" +%m 2>/dev/null || echo "")

    if [ -n "$YEAR" ] && [ -n "$MONTH" ]; then
        # Get current file path
        FILE=$(wp --path="$WP_PATH" post meta get $id _wp_attached_file)

        # Skip if already organized
        if [[ "$FILE" =~ ^[0-9]{4}/[0-9]{2}/ ]]; then
            continue
        fi

        # Create target directory
        TARGET_DIR="$UPLOADS_DIR/$YEAR/$MONTH"
        mkdir -p "$TARGET_DIR"

        # Move file
        BASENAME=$(basename "$FILE")
        if [ -f "$UPLOADS_DIR/$FILE" ]; then
            mv "$UPLOADS_DIR/$FILE" "$TARGET_DIR/$BASENAME"

            # Update database
            NEW_PATH="$YEAR/$MONTH/$BASENAME"
            wp --path="$WP_PATH" post meta update $id _wp_attached_file "$NEW_PATH"

            echo "Moved: $FILE -> $NEW_PATH"
        fi
    fi
done

echo "Upload organization completed"

Media Export and Backup

Create backups of media library with metadata.

#!/bin/bash
# backup-media.sh - Backup media library

WP_PATH="/var/www/html"
BACKUP_DIR="/backups/media"
TIMESTAMP=$(date +%Y%m%d-%H%M%S)
BACKUP_PATH="$BACKUP_DIR/media-backup-$TIMESTAMP"

mkdir -p "$BACKUP_PATH"

echo "Starting media backup..."

# Export attachment metadata
wp --path="$WP_PATH" post list \
    --post_type=attachment \
    --format=json > "$BACKUP_PATH/attachments-metadata.json"

# Backup uploads directory
tar -czf "$BACKUP_PATH/uploads.tar.gz" \
    -C "$WP_PATH/wp-content" \
    uploads/

# Get backup size
BACKUP_SIZE=$(du -sh "$BACKUP_PATH" | cut -f1)
echo "Backup completed: $BACKUP_SIZE at $BACKUP_PATH"

# Clean old backups (keep last 7)
ls -t "$BACKUP_DIR" | tail -n +8 | xargs -I {} rm -rf "$BACKUP_DIR/{}"

Related Links

• WP-CLI Media Commands
• WordPress Media Library Guide
• Image Optimization Best Practices
• WordPress Attachment Metadata
• EWWW Image Optimizer Documentation

The post WordPress Media Library Automation with WP-CLI: Complete Guide appeared first on WP-CLI Mastery.