AI-powered content generation with WP-CLI automates WordPress publishing—generate articles from prompts, create variations, translate content, optimize for SEO, and publish directly to WordPress. Combine Claude API or OpenAI with WP-CLI for scalable content workflows.

In this guide, you’ll learn to build AI content generation systems for WordPress using WP-CLI, with ethical guidelines, API integration patterns, and automation workflows for responsible AI-assisted publishing.

AI Content Generation Ethics

Before building AI content systems, understand ethical implications and responsible use.

Ethical Considerations

Transparency: Disclose AI-generated content to readers when appropriate.

Quality control: Review and edit AI output before publishing.

Originality: Ensure content doesn’t plagiarize or duplicate existing work.

Accuracy: Verify facts, statistics, and claims in AI-generated content.

Human value: Use AI to augment human creativity, not replace it entirely.

Responsible AI Content Guidelines

# Best practices for AI-generated WordPress content

1. Human oversight required
   - Review all AI content before publishing
   - Edit for accuracy, tone, and brand voice
   - Add human expertise and insights

2. Disclosure when appropriate
   - Consider adding AI disclosure for transparency
   - Follow FTC guidelines for automated content

3. Quality over quantity
   - Don't publish low-quality AI content at scale
   - Maintain editorial standards

4. Respect copyrights
   - Don't train on or reproduce copyrighted material
   - Verify AI output is original

5. Value to readers
   - Ensure content serves reader needs
   - Provide genuine value, not just SEO filler

Learn about AI content ethics from the FTC.

Claude API Integration

Integrate Anthropic’s Claude API with WP-CLI for content generation.

Claude API Setup

# Install dependencies
pip install anthropic

# Set API key
export ANTHROPIC_API_KEY="your-api-key-here"

# Test connection
python -c "import anthropic; client = anthropic.Anthropic(); print('Connected')"

Generate Content with Claude

#!/usr/bin/env python3
# generate-with-claude.py

import anthropic
import sys
import os

def generate_article(topic, target_words=1000):
    client = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))

    prompt = f"""Write a {target_words}-word informative blog post about: {topic}

Include:
- Engaging introduction
- 3-5 main sections with H2 headings
- Practical examples
- Conclusion with key takeaways

Format in markdown."""

    message = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=4096,
        messages=[
            {"role": "user", "content": prompt}
        ]
    )

    return message.content[0].text

if __name__ == "__main__":
    topic = sys.argv[1] if len(sys.argv) > 1 else "WordPress automation"

    print(generate_article(topic))

Usage:

python generate-with-claude.py "WP-CLI best practices" > article.md

Publish to WordPress

#!/bin/bash
# ai-to-wordpress.sh - Generate and publish AI content

TOPIC="$1"
CATEGORY_ID="${2:-1}"

if [ -z "$TOPIC" ]; then
    echo "Usage: $0 <topic> [category_id]"
    exit 1
fi

echo "Generating content for: $TOPIC"

# Generate content with Claude
CONTENT=$(python generate-with-claude.py "$TOPIC")

# Create WordPress post as draft for review
POST_ID=$(wp post create \
    --post_title="$TOPIC" \
    --post_content="$CONTENT" \
    --post_status=draft \
    --post_category=$CATEGORY_ID \
    --porcelain)

echo "✓ Draft created: Post ID $POST_ID"
echo "Review at: $(wp option get siteurl)/wp-admin/post.php?post=$POST_ID&action=edit"

Learn about Claude API.

OpenAI Integration

Use OpenAI’s GPT models for WordPress content generation.

OpenAI Setup

# Install OpenAI library
pip install openai

# Set API key
export OPENAI_API_KEY="your-api-key-here"

Generate with GPT-4

#!/usr/bin/env python3
# generate-with-openai.py

from openai import OpenAI
import sys
import os

def generate_article(topic, model="gpt-4"):
    client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))

    response = client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": "You are a professional content writer creating high-quality WordPress blog posts."},
            {"role": "user", "content": f"Write a comprehensive 1000-word blog post about: {topic}. Include clear headings, practical examples, and actionable takeaways. Format in markdown."}
        ],
        temperature=0.7,
        max_tokens=2000
    )

    return response.choices[0].message.content

if __name__ == "__main__":
    topic = sys.argv[1] if len(sys.argv) > 1 else "WordPress development"
    print(generate_article(topic))

Batch Content Generation

#!/bin/bash
# batch-generate-content.sh - Generate multiple posts

TOPICS_FILE="$1"

if [ ! -f "$TOPICS_FILE" ]; then
    echo "Usage: $0 <topics-file>"
    echo "Topics file should contain one topic per line"
    exit 1
fi

while read -r TOPIC; do
    echo "Generating: $TOPIC"

    # Generate content
    CONTENT=$(python generate-with-claude.py "$TOPIC")

    # Create draft post
    POST_ID=$(wp post create \
        --post_title="$TOPIC" \
        --post_content="$CONTENT" \
        --post_status=draft \
        --porcelain)

    echo "✓ Created draft: $POST_ID"

    # Rate limiting
    sleep 2
done < "$TOPICS_FILE"

echo "✓ Batch generation complete"

Content Enhancement

Use AI to improve existing WordPress content.

SEO Optimization

#!/usr/bin/env python3
# optimize-for-seo.py

import anthropic
import sys
import os

def optimize_content(original_content, focus_keyword):
    client = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))

    prompt = f"""Optimize this content for SEO targeting the keyword: {focus_keyword}

Original content:
{original_content}

Improve:
- Keyword density (natural placement)
- Meta description suggestion
- H2/H3 headings with keyword variations
- Internal linking opportunities

Provide the optimized version."""

    message = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=4096,
        messages=[{"role": "user", "content": prompt}]
    )

    return message.content[0].text

if __name__ == "__main__":
    if len(sys.argv) < 3:
        print("Usage: optimize-for-seo.py <post_id> <focus_keyword>")
        sys.exit(1)

    post_id = sys.argv[1]
    keyword = sys.argv[2]

    # Get original content (would use wp-cli here)
    content = sys.stdin.read()

    print(optimize_content(content, keyword))

Content Expansion

#!/bin/bash
# expand-content.sh - Expand short posts with AI

MIN_WORDS=300
TARGET_WORDS=1000

# Find short posts
SHORT_POSTS=$(wp post list \
    --post_status=publish \
    --format=ids \
    --fields=ID,post_content \
    | while read POST_ID; do
        WORD_COUNT=$(wp post get $POST_ID --field=post_content | wc -w)
        if [ "$WORD_COUNT" -lt "$MIN_WORDS" ]; then
            echo "$POST_ID"
        fi
    done)

for POST_ID in $SHORT_POSTS; do
    echo "Expanding post: $POST_ID"

    TITLE=$(wp post get $POST_ID --field=post_title)
    CONTENT=$(wp post get $POST_ID --field=post_content)

    # Generate expanded version
    EXPANDED=$(python -c "
import anthropic, os
client = anthropic.Anthropic(api_key=os.environ.get('ANTHROPIC_API_KEY'))
message = client.messages.create(
    model='claude-3-5-sonnet-20241022',
    max_tokens=2048,
    messages=[{
        'role': 'user',
        'content': f'''Expand this article to approximately $TARGET_WORDS words while maintaining quality:

Title: $TITLE

Current content:
$CONTENT

Add more detail, examples, and value while staying on topic.'''
    }]
)
print(message.content[0].text)
")

    # Save as revision (create new draft for review)
    wp post create \
        --post_title="$TITLE (Expanded)" \
        --post_content="$EXPANDED" \
        --post_status=draft

    echo "✓ Expanded version created for review"
done

Automated Publishing Workflows

Build complete AI-powered content pipelines.

Daily Auto-Publish System

#!/bin/bash
# daily-ai-content.sh - Generate and publish content daily

TOPICS=(
    "WordPress security best practices"
    "WP-CLI productivity tips"
    "WordPress performance optimization"
    "Content management automation"
)

# Select random topic
TOPIC="${TOPICS[$RANDOM % ${#TOPICS[@]}]}"

echo "Generating daily content: $TOPIC"

# Generate with AI
CONTENT=$(python generate-with-claude.py "$TOPIC")

# Add disclaimer
DISCLAIMER="<em>Note: This article was generated with AI assistance and reviewed by our editorial team.</em>"

FULL_CONTENT="${CONTENT}


${DISCLAIMER}"

# Create post
POST_ID=$(wp post create \
    --post_title="$TOPIC" \
    --post_content="$FULL_CONTENT" \
    --post_status=draft \
    --post_category=5 \
    --tags_input="ai-generated,automation" \
    --porcelain)

# Set featured image (from Unsplash API - separate integration)
# Add meta fields for tracking
wp post meta add $POST_ID ai_generated "true"
wp post meta add $POST_ID generation_date "$(date +%Y-%m-%d)"

echo "✓ Draft created: $POST_ID"
echo "Review and publish at: $(wp option get siteurl)/wp-admin/post.php?post=$POST_ID&action=edit"

Schedule with cron:

# Run daily at 8 AM
0 8 * * * /usr/local/bin/daily-ai-content.sh

Content Translation

#!/usr/bin/env python3
# translate-post.py - Translate WordPress posts with AI

import anthropic
import sys
import os

def translate_content(content, target_language):
    client = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))

    message = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=4096,
        messages=[{
            "role": "user",
            "content": f"Translate this content to {target_language}. Maintain formatting and structure:\n\n{content}"
        }]
    )

    return message.content[0].text

if __name__ == "__main__":
    if len(sys.argv) < 3:
        print("Usage: translate-post.py <post_id> <language>")
        sys.exit(1)

    post_id = sys.argv[1]
    language = sys.argv[2]

    # Read from stdin
    content = sys.stdin.read()

    print(translate_content(content, language))

Usage:

# Translate post to Spanish
wp post get 123 --field=post_content | python translate-post.py 123 "Spanish" | \
wp post create --post_title="Translated Post" --post_content=-

Quality Control

Implement checks to ensure AI content quality.

Content Review Checklist

#!/bin/bash
# review-ai-content.sh - Quality check for AI posts

POST_ID="$1"

echo "Reviewing AI-generated post: $POST_ID"

# Check word count
WORD_COUNT=$(wp post get $POST_ID --field=post_content | wc -w)
echo "Word count: $WORD_COUNT"

if [ "$WORD_COUNT" -lt 300 ]; then
    echo "⚠ Content too short"
fi

# Check for common AI phrases
CONTENT=$(wp post get $POST_ID --field=post_content)

AI_PHRASES=(
    "as an AI"
    "I don't have"
    "I cannot"
    "my knowledge cutoff"
)

for PHRASE in "${AI_PHRASES[@]}"; do
    if echo "$CONTENT" | grep -qi "$PHRASE"; then
        echo "⚠ Found AI artifact: '$PHRASE'"
    fi
done

# Check readability
TITLE=$(wp post get $POST_ID --field=post_title)
if [ ${#TITLE} -gt 60 ]; then
    echo "⚠ Title too long for SEO"
fi

# Check for images
IMAGE_COUNT=$(echo "$CONTENT" | grep -c '<img')
if [ "$IMAGE_COUNT" -eq 0 ]; then
    echo "⚠ No images in content"
fi

echo "✓ Review complete"

Cost Management

Track and control AI API costs.

API Usage Tracking

#!/bin/bash
# track-ai-costs.sh

LOG_FILE="/var/log/ai-content-costs.log"

log_generation() {
    local model="$1"
    local tokens="$2"
    local cost="$3"

    echo "$(date +%Y-%m-%d),$(date +%H:%M:%S),$model,$tokens,$cost" >> "$LOG_FILE"
}

# After each generation
log_generation "claude-3-sonnet" "2048" "0.06"

# Monthly report
generate_cost_report() {
    echo "AI Content Generation Cost Report"
    echo "Month: $(date +%Y-%m)"
    echo "=================================="

    TOTAL_COST=$(awk -F',' '{sum += $5} END {print sum}' "$LOG_FILE")
    TOTAL_POSTS=$(wc -l < "$LOG_FILE")

    echo "Total generations: $TOTAL_POSTS"
    echo "Total cost: \$$TOTAL_COST"
    echo "Average per post: \$$(echo "scale=2; $TOTAL_COST / $TOTAL_POSTS" | bc)"
}

Next Steps

You now have AI-powered content generation capabilities for WordPress.

Recommended Learning Path

Week 1: Basic integration

• Set up Claude/OpenAI APIs
• Generate test content
• Publish to WordPress

Week 2: Automation

• Build generation scripts
• Schedule automated publishing
• Implement quality checks

Week 3: Enhancement

• Add SEO optimization
• Implement translations
• Create content variations

Week 4: Production

• Cost tracking
• Quality control systems
• Editorial workflows

Advanced Topics

1. Fine-tuning Models – Custom AI models for your brand
2. Multi-modal Content – Generate images with text
3. Content Personalization – AI-driven user targeting

Get More Resources

Download AI integration scripts including:

• Complete generation system
• Quality control tools
• Cost tracking utilities

Join our email course for:

• Weekly WP-CLI tutorials
• AI content strategies
• Automation best practices

Conclusion

AI-powered content generation with WP-CLI enables scalable WordPress publishing while maintaining quality through human oversight and ethical practices.

What we covered:

✅ Ethical AI content guidelines
✅ Claude and OpenAI API integration
✅ Automated content generation workflows
✅ Content enhancement and optimization
✅ Quality control and review systems
✅ Cost tracking and management

Use AI responsibly as a tool to augment human creativity—review all content, ensure accuracy, provide genuine value to readers, and maintain editorial standards.

Ready for more? Learn content strategy or SEO automation.

Questions about AI content generation for WordPress? Drop a comment below!

Found this helpful? Share responsibly with other content creators.

The post Automate WordPress Content with AI APIs and WP-CLI (Claude, OpenAI) appeared first on WP-CLI Mastery.

WP-CLI combined with curl and REST API gives you complete WordPress automation—create posts from external systems, sync content between sites, integrate with third-party services, and build powerful API-driven workflows from your terminal.

In this guide, you’ll learn to leverage WordPress REST API with WP-CLI for automated content management, headless WordPress setups, and integration workflows used by modern WordPress applications.

Why Combine WordPress REST API with WP-CLI?

WordPress REST API provides HTTP endpoints for WordPress data, while WP-CLI offers direct database access—together they’re unstoppable.

WordPress REST API Limitations Alone

Authentication complexity: Setting up OAuth or application passwords is tedious.

Rate limiting: API requests can be throttled during bulk operations.

Debugging difficulty: Hard to see what’s happening inside WordPress during API calls.

No direct database: Can’t bypass API to directly manipulate data when needed.

Testing challenges: Need external tools to test endpoints during development.

Combined WP-CLI + REST API Advantages

Fast prototyping: Use WP-CLI to create test data for API development.

Hybrid workflows: Use API for external integration, WP-CLI for direct operations.

Better debugging: Check database state with WP-CLI while testing API calls.

Authentication bypass: Use WP-CLI for admin tasks, API for user-facing features.

Complete automation: Build complex workflows combining both tools.

According to WordPress API usage statistics, REST API adoption has grown 300% since 2020, making API skills essential.

WordPress REST API Basics

Understand WordPress REST API fundamentals before automation.

Test API Endpoints with curl

# Get site information
curl https://example.com/wp-json/

# List all posts
curl https://example.com/wp-json/wp/v2/posts

# Get specific post
curl https://example.com/wp-json/wp/v2/posts/123

# List users
curl https://example.com/wp-json/wp/v2/users

# Get categories
curl https://example.com/wp-json/wp/v2/categories

Pretty Print JSON Responses

# Install jq for JSON formatting
apt-get install jq

# Pretty print API response
curl -s https://example.com/wp-json/wp/v2/posts | jq '.'

# Extract specific fields
curl -s https://example.com/wp-json/wp/v2/posts | jq '.[].title.rendered'

# Get post count
curl -s https://example.com/wp-json/wp/v2/posts | jq 'length'

Verify REST API is Enabled

# Check if REST API responds
curl -I https://example.com/wp-json/

# Should return: HTTP/1.1 200 OK

# Use WP-CLI to check REST API status
wp rest

# List all available REST routes
wp rest route list

Learn more in the WordPress REST API handbook.

REST API Authentication

Authenticate API requests for write operations.

Application Passwords (Recommended)

# Create application password with WP-CLI
wp user application-password create admin "API Automation" --porcelain

# Returns: password_hash

# Use in curl request
curl -u admin:password_hash \
    https://example.com/wp-json/wp/v2/posts

# Test authentication
curl -u admin:password_hash \
    https://example.com/wp-json/wp/v2/users/me

Best Practice: Store credentials in environment variables, never hardcode in scripts.

# Set environment variables
export WP_USER="admin"
export WP_APP_PASSWORD="xxxx xxxx xxxx xxxx"

# Use in scripts
curl -u "$WP_USER:$WP_APP_PASSWORD" \
    https://example.com/wp-json/wp/v2/posts

Basic Authentication (Development Only)

# Install Basic Auth plugin (development only!)
wp plugin install https://github.com/WP-API/Basic-Auth/archive/master.zip --activate

# Use with curl
curl -u username:password \
    https://example.com/wp-json/wp/v2/posts

# NEVER use Basic Auth on production (insecure over HTTP)

Creating Content via REST API

Automate content creation using API endpoints.

Create Posts with curl

# Create simple post
curl -X POST \
    -u admin:app_password \
    -H "Content-Type: application/json" \
    -d '{
        "title": "New Post via API",
        "content": "This post was created via REST API",
        "status": "publish"
    }' \
    https://example.com/wp-json/wp/v2/posts

# Create post with categories and tags
curl -X POST \
    -u admin:app_password \
    -H "Content-Type: application/json" \
    -d '{
        "title": "Categorized Post",
        "content": "Post content here",
        "status": "publish",
        "categories": [1, 5],
        "tags": [10, 15, 20]
    }' \
    https://example.com/wp-json/wp/v2/posts

Create Posts from External Data

#!/bin/bash
# import-from-api.sh - Import content from external API

EXTERNAL_API="https://api.example.com/articles"
WP_SITE="https://mysite.com"
WP_USER="admin"
WP_PASS="app_password"

# Fetch external content
curl -s "$EXTERNAL_API" | jq -c '.[]' | while read article; do
    TITLE=$(echo "$article" | jq -r '.title')
    CONTENT=$(echo "$article" | jq -r '.content')

    echo "Importing: $TITLE"

    # Create WordPress post
    curl -X POST \
        -u "$WP_USER:$WP_PASS" \
        -H "Content-Type: application/json" \
        -d "{
            \"title\": \"$TITLE\",
            \"content\": \"$CONTENT\",
            \"status\": \"draft\"
        }" \
        "$WP_SITE/wp-json/wp/v2/posts"
done

echo "✓ Import complete"

Use Case: Sync content from headless CMS, import RSS feeds, or aggregate content from multiple sources.

Update Posts

# Update post title
curl -X POST \
    -u admin:app_password \
    -H "Content-Type: application/json" \
    -d '{"title": "Updated Title"}' \
    https://example.com/wp-json/wp/v2/posts/123

# Update post content
curl -X POST \
    -u admin:app_password \
    -H "Content-Type: application/json" \
    -d '{"content": "New content here"}' \
    https://example.com/wp-json/wp/v2/posts/123

# Change post status
curl -X POST \
    -u admin:app_password \
    -H "Content-Type: application/json" \
    -d '{"status": "publish"}' \
    https://example.com/wp-json/wp/v2/posts/123

WP-CLI REST Commands

Use WP-CLI’s built-in REST functionality for testing.

List REST Routes

# Show all REST routes
wp rest route list

# Show specific namespace
wp rest route list --namespace=wp/v2

# Filter routes
wp rest route list | grep posts

Execute REST Requests with WP-CLI

# GET request
wp rest get /wp/v2/posts

# GET specific post
wp rest get /wp/v2/posts/123

# POST request (create content)
wp rest post /wp/v2/posts \
    --title="New Post" \
    --content="Post content" \
    --status=publish

# DELETE request
wp rest delete /wp/v2/posts/123 --force=true

Advantage: WP-CLI REST commands bypass authentication—perfect for local development and testing.

Hybrid WP-CLI + REST API Workflows

Combine WP-CLI and REST API for powerful automation.

Content Sync Between Sites

#!/bin/bash
# sync-content-between-sites.sh

SOURCE_SITE="https://source.com"
TARGET_SITE="/var/www/target-site"
WP_USER="admin"
WP_PASS="app_password"

# Export posts from source via API
curl -s "$SOURCE_SITE/wp-json/wp/v2/posts?per_page=100" > /tmp/posts.json

# Import to target with WP-CLI
cd "$TARGET_SITE"

cat /tmp/posts.json | jq -c '.[]' | while read post; do
    TITLE=$(echo "$post" | jq -r '.title.rendered')
    CONTENT=$(echo "$post" | jq -r '.content.rendered')

    echo "Importing: $TITLE"

    # Use WP-CLI for faster import
    wp post create \
        --post_title="$TITLE" \
        --post_content="$CONTENT" \
        --post_status=publish
done

rm /tmp/posts.json
echo "✓ Content sync complete"

Headless WordPress Content Publishing

#!/bin/bash
# headless-publish.sh - Publish to headless WordPress

WP_API="https://headless-wp.com/wp-json/wp/v2"
WP_USER="admin"
WP_PASS="app_password"

# Create content locally with WP-CLI
wp post create \
    --post_title="Headless Post" \
    --post_content="Content here" \
    --post_status=draft \
    --porcelain > /tmp/post_id.txt

POST_ID=$(cat /tmp/post_id.txt)

# Export post data
POST_DATA=$(wp post get $POST_ID --format=json)

# Publish via REST API to headless instance
curl -X POST \
    -u "$WP_USER:$WP_PASS" \
    -H "Content-Type: application/json" \
    -d "$POST_DATA" \
    "$WP_API/posts"

echo "✓ Published to headless WordPress"

Automated Content Moderation

#!/bin/bash
# moderate-content.sh - Auto-moderate spam content

WP_SITE="/var/www/html"
API_URL="https://example.com/wp-json/wp/v2"
WP_USER="admin"
WP_PASS="app_password"

cd "$WP_SITE"

# Find posts with spam keywords using WP-CLI
SPAM_POSTS=$(wp post list \
    --s="viagra" \
    --post_status=publish \
    --format=ids)

for POST_ID in $SPAM_POSTS; do
    echo "Trashing spam post: $POST_ID"

    # Move to trash via REST API
    curl -X DELETE \
        -u "$WP_USER:$WP_PASS" \
        "$API_URL/posts/$POST_ID"
done

echo "✓ Spam moderation complete"

API Testing and Development

Test custom REST API endpoints during development.

Register Custom Endpoint

// In theme functions.php or plugin
add_action('rest_api_init', function () {
    register_rest_route('custom/v1', '/data', array(
        'methods' => 'GET',
        'callback' => 'custom_api_callback',
        'permission_callback' => '__return_true'
    ));
});

function custom_api_callback() {
    return array('status' => 'success', 'data' => 'Custom API response');
}

Test Custom Endpoint

# Test with curl
curl https://example.com/wp-json/custom/v1/data

# Test with WP-CLI
wp rest get /custom/v1/data

# Validate response
wp rest get /custom/v1/data | jq '.status'

Automated API Testing Script

#!/bin/bash
# test-api-endpoints.sh

API_BASE="https://example.com/wp-json/wp/v2"

echo "Testing WordPress REST API endpoints..."

# Test posts endpoint
HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" "$API_BASE/posts")
if [ "$HTTP_CODE" -eq 200 ]; then
    echo "✓ Posts endpoint: OK"
else
    echo "✗ Posts endpoint: FAILED ($HTTP_CODE)"
fi

# Test users endpoint
HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" "$API_BASE/users")
if [ "$HTTP_CODE" -eq 200 ]; then
    echo "✓ Users endpoint: OK"
else
    echo "✗ Users endpoint: FAILED ($HTTP_CODE)"
fi

# Test categories endpoint
HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" "$API_BASE/categories")
if [ "$HTTP_CODE" -eq 200 ]; then
    echo "✓ Categories endpoint: OK"
else
    echo "✗ Categories endpoint: FAILED ($HTTP_CODE)"
fi

echo "API testing complete"

Learn about REST API best practices for production.

Next Steps

You now have WordPress REST API and WP-CLI integration skills for powerful automation workflows.

Recommended Learning Path

Week 1: API fundamentals

• Test endpoints with curl
• Set up authentication
• Create/update content via API

Week 2: WP-CLI REST commands

• Use wp rest commands
• Build hybrid workflows
• Test custom endpoints

Week 3: Advanced integration

• Content synchronization
• Headless WordPress setup
• API-driven automation

Week 4: Production deployment

• Build content pipelines
• Implement error handling
• Create monitoring systems

Advanced Topics

1. Headless WordPress Architecture – Complete decoupled setup
2. Custom REST API Endpoints – Build custom APIs
3. GraphQL + WP-CLI – Alternative API approach

Get More Resources

Download API automation scripts including:

• Content sync workflows
• API testing suite
• Authentication helpers

Join our email course for:

• Weekly WP-CLI tutorials
• API integration patterns
• Modern WordPress architecture

Conclusion

WordPress REST API combined with WP-CLI creates a powerful automation ecosystem for modern WordPress development, from headless setups to complex content workflows.

What we covered:

✅ WordPress REST API basics and authentication
✅ Creating and updating content via API
✅ WP-CLI REST commands for testing
✅ Hybrid WP-CLI + REST API workflows
✅ Content sync and automation patterns
✅ API testing and development workflows

Master these techniques, and you’ll build sophisticated WordPress automation that integrates with any external system or service.

Ready for more? Learn WordPress GraphQL integration or headless WordPress architecture.

Questions about WordPress REST API and WP-CLI? Drop a comment below!

Found this helpful? Share with other WordPress developers.

The post WordPress REST API + WP-CLI: Complete Automation Integration Guide appeared first on WP-CLI Mastery.

What if you could automatically fetch relevant images from Unsplash and set them as featured images—all from the command line?

In this tutorial, you’ll learn to integrate the Unsplash API with WordPress using WP-CLI and Bash. You’ll build a complete automation system that searches for images, downloads them, imports to WordPress media library, sets featured images, and handles proper attribution automatically.

This is a key component of the automated blog publishing pipeline you’ll build in WPCLI Mastery.

Why Automate Images with Unsplash?

The Manual Image Problem

Typical workflow:

1. Search Unsplash for relevant image (2 min)
2. Download image (30 sec)
3. Upload to WordPress (1 min)
4. Set as featured image (30 sec)
5. Add attribution in caption/alt text (1 min)

Total: ~5 minutes per post

For 20 posts/month = 100 minutes wasted

Automated Solution

With WP-CLI + Unsplash API:

# One command, 5 seconds
wp unsplash set-featured 123 --query="technology"

Result:

• Image downloaded
• Imported to media library
• Set as featured image
• Attribution added
• Alt text optimized

Unsplash Benefits

High Quality: Professional photography, all free Huge Library: Over 3 million images Legal Safety: Completely free for commercial use Developer-Friendly: Well-documented API SEO Value: Proper attribution builds credibility

According to Unsplash, images are downloaded over 10 billion times per year. It’s the go-to source for professional content creators.

Prerequisites

Before integrating Unsplash API, ensure you have:

Required Software

• WP-CLI installed – Installation guide
• curl – For API requests
• jq – JSON parsing tool
• Bash – Shell scripting knowledge

Install missing tools:

# Ubuntu/Debian
sudo apt-get install curl jq

# macOS
brew install curl jq

WordPress Requirements

• WordPress site with WP-CLI access
• Write permissions for uploads directory
• Basic understanding of WordPress media library

Bash Knowledge

Helpful background:

• Bash functions for WordPress
• API requests with curl
• JSON parsing basics

Getting Unsplash API Access

Step 1: Create Unsplash Account

1. Visit Unsplash.com
2. Sign up for free account
3. Verify your email

Step 2: Register Your Application

1. Go to Unsplash Developers
2. Click “Register as a Developer”
3. Accept the API terms
4. Click “New Application”

Step 3: Create API Application

Fill in application details:

• Application name: “WordPress Blog Automation”
• Description: “Automated featured image fetching for WordPress blog”
• Callback URLs: (not needed for this use case)

Important: Accept the API Guidelines

Step 4: Get API Keys

After creating your app, you’ll receive:

• Access Key: Public key for API requests (Demo: Limited to 50 requests/hour)
• Secret Key: Keep private (not needed for basic usage)

Demo vs Production:

• Demo: 50 requests/hour (good for testing)
• Production: 5,000 requests/hour (requires app approval by Unsplash)

For most blogs, demo limits are sufficient. Production approval takes 1-2 business days.

Step 5: Store API Key Securely

Never hardcode API keys in scripts.

Store in environment variable:

# Add to ~/.bashrc or ~/.bash_profile
export UNSPLASH_ACCESS_KEY="your_access_key_here"

# Reload
source ~/.bashrc

Or use a config file:

# Create config file
nano ~/.unsplash-config

# Add key
UNSPLASH_ACCESS_KEY=your_access_key_here

# Secure it
chmod 600 ~/.unsplash-config

Understanding Unsplash API

API Endpoints

Search Photos:

GET https://api.unsplash.com/search/photos

Get Random Photo:

GET https://api.unsplash.com/photos/random

Get Specific Photo:

GET https://api.unsplash.com/photos/{id}

Basic API Request

curl -H "Authorization: Client-ID YOUR_ACCESS_KEY" \
	"https://api.unsplash.com/photos/random?query=nature"

Response Format

Unsplash returns JSON:

{
	"id": "abc123",
	"urls": {
		"raw": "https://images.unsplash.com/photo-...",
		"full": "https://images.unsplash.com/photo-...",
		"regular": "https://images.unsplash.com/photo-...",
		"small": "https://images.unsplash.com/photo-..."
	},
	"user": {
		"name": "John Doe",
		"username": "johndoe",
		"links": {
			"html": "https://unsplash.com/@johndoe"
		}
	},
	"description": "Beautiful sunset over mountains",
	"alt_description": "orange sunset"
}

Key fields:

• urls.regular: Best for WordPress featured images (1080px wide)
• user.name: For attribution
• user.links.html: Link to photographer’s profile
• alt_description: Good for alt text

Read full docs: Unsplash API Documentation

Fetching Images with curl

Search for Images

#!/bin/bash

UNSPLASH_KEY="your_access_key"
QUERY="technology"

# Search for images
response=$(curl -s -H "Authorization: Client-ID ${UNSPLASH_KEY}" \
	"https://api.unsplash.com/search/photos?query=${QUERY}&per_page=1")

# Parse response with jq
image_url=$(echo "$response" | jq -r '.results[0].urls.regular')
photo_id=$(echo "$response" | jq -r '.results[0].id')
photographer=$(echo "$response" | jq -r '.results[0].user.name')
photographer_url=$(echo "$response" | jq -r '.results[0].user.links.html')
alt_text=$(echo "$response" | jq -r '.results[0].alt_description')

echo "Image URL: ${image_url}"
echo "Photographer: ${photographer}"
echo "Alt Text: ${alt_text}"

Get Random Image

get_random_image() {
		local query=$1
		local orientation=${2:-landscape}  # landscape, portrait, squarish

		local response=$(curl -s -H "Authorization: Client-ID ${UNSPLASH_KEY}" \
			"https://api.unsplash.com/photos/random?query=${query}&orientation=${orientation}")

		echo "$response"
}

# Usage
response=$(get_random_image "coding" "landscape")
image_url=$(echo "$response" | jq -r '.urls.regular')

Search Parameters

Common parameters:

# Search with pagination
?query=nature&page=2&per_page=10

# Filter by orientation
?query=laptop&orientation=landscape

# Filter by color
?query=sunset&color=orange

# Combine filters
?query=workspace&orientation=landscape&color=black_and_white

Orientation options:

• landscape – Horizontal (best for featured images)
• portrait – Vertical
• squarish – Square-ish

Color options:

• black_and_white, black, white, yellow, orange, red, purple, magenta, green, teal, blue

Downloading Images

Download Image to Filesystem

download_image() {
		local image_url=$1
		local output_file=$2

		if curl -s -o "$output_file" "$image_url"; then
				echo "Downloaded: ${output_file}"
				return 0
		else
				echo "Error: Download failed" >&2
				return 1
		fi
}

# Usage
image_url="https://images.unsplash.com/photo-xyz?w=1080"
output="/tmp/unsplash-image.jpg"

download_image "$image_url" "$output"

Generate Unique Filename

generate_filename() {
		local query=$1
		local timestamp=$(date +%Y%m%d_%H%M%S)
		local random=$(head /dev/urandom | tr -dc A-Za-z0-9 | head -c 6)

		# Sanitize query (remove spaces, special chars)
		local clean_query=$(echo "$query" | tr ' ' '-' | tr -cd '[:alnum:]-')

		echo "unsplash-${clean_query}-${timestamp}-${random}.jpg"
}

# Usage
filename=$(generate_filename "mountain landscape")
# Output: unsplash-mountain-landscape-20250325_143022-aB3xY9.jpg

Complete Download Function

fetch_and_download() {
		local query=$1
		local output_dir=${2:-/tmp}

		# Fetch image data
		local response=$(curl -s -H "Authorization: Client-ID ${UNSPLASH_KEY}" \
			"https://api.unsplash.com/photos/random?query=${query}&orientation=landscape")

		# Parse response
		local image_url=$(echo "$response" | jq -r '.urls.regular')
		local photo_id=$(echo "$response" | jq -r '.id')

		if [ "$image_url" = "null" ] || [ -z "$image_url" ]; then
				echo "Error: No image found for query '${query}'" >&2
				return 1
		fi

		# Generate filename
		local filename=$(generate_filename "$query")
		local filepath="${output_dir}/${filename}"

		# Download image
		if curl -s -o "$filepath" "$image_url"; then
				echo "$filepath"
				return 0
		else
				echo "Error: Download failed" >&2
				return 1
		fi
}

# Usage
image_file=$(fetch_and_download "workspace" "/tmp")
echo "Image saved: ${image_file}"

Importing to WordPress Media Library

WP-CLI Media Import

WP-CLI provides wp media import for adding images to media library.

Basic import:

wp media import /tmp/image.jpg --title="My Image"

With metadata:

wp media import /tmp/image.jpg \
	--title="Mountain Landscape" \
	--alt="Beautiful mountain sunset" \
	--caption="Photo by John Doe on Unsplash" \
	--porcelain  # Returns attachment ID only

Import Function with Metadata

import_to_wordpress() {
		local image_file=$1
		local title=$2
		local alt_text=$3
		local caption=$4

		# Import and get attachment ID
		local attachment_id=$(wp media import "$image_file" \
				--title="$title" \
				--alt="$alt_text" \
				--caption="$caption" \
				--porcelain)

		if [ -n "$attachment_id" ]; then
				echo "Imported as attachment ID: ${attachment_id}"
				echo "$attachment_id"
				return 0
		else
				echo "Error: Import failed" >&2
				return 1
		fi
}

# Usage
attachment_id=$(import_to_wordpress \
		"/tmp/image.jpg" \
		"Tech Workspace" \
		"Modern laptop on wooden desk" \
		"Photo by Jane Smith on Unsplash")

Complete Fetch and Import

fetch_and_import() {
		local query=$1

		# Fetch image from Unsplash
		local response=$(curl -s -H "Authorization: Client-ID ${UNSPLASH_KEY}" \
			"https://api.unsplash.com/photos/random?query=${query}&orientation=landscape")

		# Parse metadata
		local image_url=$(echo "$response" | jq -r '.urls.regular')
		local photographer=$(echo "$response" | jq -r '.user.name')
		local photographer_url=$(echo "$response" | jq -r '.user.links.html')
		local alt_text=$(echo "$response" | jq -r '.alt_description')
		local description=$(echo "$response" | jq -r '.description // .alt_description')

		# Download to temp file
		local temp_file="/tmp/unsplash-$(date +%s).jpg"
		curl -s -o "$temp_file" "$image_url"

		# Prepare metadata
		local title="$description"
		local caption="Photo by ${photographer} on Unsplash (${photographer_url})"

		# Import to WordPress
		local attachment_id=$(wp media import "$temp_file" \
				--title="$title" \
				--alt="$alt_text" \
				--caption="$caption" \
				--porcelain)

		# Clean up temp file
		rm -f "$temp_file"

		echo "$attachment_id"
}

# Usage
attachment_id=$(fetch_and_import "coffee shop")
echo "Imported image: ${attachment_id}"

Setting Featured Images

Set Featured Image for Post

wp post meta update POST_ID _thumbnail_id ATTACHMENT_ID

Example:

# Post ID 123, Attachment ID 456
wp post meta update 123 _thumbnail_id 456

Complete Function

set_featured_image() {
		local post_id=$1
		local attachment_id=$2

		if wp post meta update "$post_id" _thumbnail_id "$attachment_id" &>/dev/null; then
				echo "Featured image set for post ${post_id}"
				return 0
		else
				echo "Error: Failed to set featured image" >&2
				return 1
		fi
}

# Usage
set_featured_image 123 456

One-Command Solution

Combine everything:

set_unsplash_featured() {
		local post_id=$1
		local query=$2

		echo "Fetching image for: ${query}"

		# Fetch and import
		local attachment_id=$(fetch_and_import "$query")

		if [ -z "$attachment_id" ]; then
				echo "Error: Failed to fetch/import image" >&2
				return 1
		fi

		# Set as featured
		if set_featured_image "$post_id" "$attachment_id"; then
				echo "✓ Featured image set successfully"
				echo "Post ID: ${post_id}"
				echo "Attachment ID: ${attachment_id}"
				return 0
		else
				return 1
		fi
}

# Usage
set_unsplash_featured 123 "technology workspace"

Handling Attribution

Unsplash Attribution Requirements

Per Unsplash License:

Required:

• Credit photographer by name
• Link to photographer’s Unsplash profile

Good attribution:

“Photo by Photographer Name on Unsplash”

Bad attribution:

“From Unsplash” (missing photographer credit)

Add Attribution to Caption

create_attribution() {
		local photographer=$1
		local photographer_url=$2

		echo "Photo by ${photographer} on Unsplash (${photographer_url})"
}

# Usage
photographer="John Doe"
url="https://unsplash.com/@johndoe"
caption=$(create_attribution "$photographer" "$url")
# Output: Photo by John Doe on Unsplash (https://unsplash.com/@johndoe)

Add Attribution to Post Content

Optionally add attribution directly in post content:

add_attribution_to_post() {
		local post_id=$1
		local photographer=$2
		local photographer_url=$3

		# Get current content
		local content=$(wp post get "$post_id" --field=content)

		# Append attribution
		local attribution="<p><em>Featured image by <a href=\"${photographer_url}\">${photographer}</a> on <a href=\"https://unsplash.com\">Unsplash</a></em></p>"

		local new_content="${content}\n\n${attribution}"

		# Update post
		wp post update "$post_id" --post_content="$new_content"
}

Trigger Download Tracking

Unsplash requires triggering download endpoint for analytics:

trigger_download() {
		local download_url=$1

		curl -s -H "Authorization: Client-ID ${UNSPLASH_KEY}" "$download_url" > /dev/null
}

# Get download URL from API response
download_url=$(echo "$response" | jq -r '.links.download_location')
trigger_download "$download_url"

Important: This is required by Unsplash API guidelines.

Complete Automation Script

Here’s the full production-ready script:

#!/bin/bash
#
# Unsplash WordPress Integration Script
# Fetches images from Unsplash and sets as WordPress featured images
#

set -euo pipefail

#############################################
# CONFIGURATION
#############################################

# Load API key from config file
if [ -f ~/.unsplash-config ]; then
		source ~/.unsplash-config
fi

UNSPLASH_KEY="${UNSPLASH_ACCESS_KEY:-}"
TEMP_DIR="/tmp/unsplash-wp"

#############################################
# FUNCTIONS
#############################################

check_dependencies() {
		local missing=()

		command -v curl &>/dev/null || missing+=("curl")
		command -v jq &>/dev/null || missing+=("jq")
		command -v wp &>/dev/null || missing+=("wp-cli")

		if [  then
				echo "Error: Missing dependencies: ${missing[*]}" >&2
				exit 1
		fi

		if [ -z "$UNSPLASH_KEY" ]; then
				echo "Error: UNSPLASH_ACCESS_KEY not set" >&2
				echo "Set it in ~/.unsplash-config or environment" >&2
				exit 1
		fi
}

fetch_unsplash_image() {
		local query=$1
		local orientation=${2:-landscape}

		local url="https://api.unsplash.com/photos/random"
		url="${url}?query=${query}&orientation=${orientation}"

		local response=$(curl -s -H "Authorization: Client-ID ${UNSPLASH_KEY}" "$url")

		# Check for errors
		local errors=$(echo "$response" | jq -r '.errors // empty')
		if [ -n "$errors" ]; then
				echo "API Error: $errors" >&2
				return 1
		fi

		echo "$response"
}

download_image() {
		local image_url=$1
		local output_file=$2

		if curl -s -L -o "$output_file" "$image_url"; then
				return 0
		else
				return 1
		fi
}

import_to_media_library() {
		local image_file=$1
		local metadata=$2

		local title=$(echo "$metadata" | jq -r '.title')
		local alt=$(echo "$metadata" | jq -r '.alt')
		local caption=$(echo "$metadata" | jq -r '.caption')

		local attachment_id=$(wp media import "$image_file" \
				--title="$title" \
				--alt="$alt" \
				--caption="$caption" \
				--porcelain 2>/dev/null)

		echo "$attachment_id"
}

set_featured_image_for_post() {
		local post_id=$1
		local attachment_id=$2

		wp post meta update "$post_id" _thumbnail_id "$attachment_id" &>/dev/null
}

trigger_download_endpoint() {
		local download_url=$1

		curl -s -H "Authorization: Client-ID ${UNSPLASH_KEY}" "$download_url" > /dev/null
}

#############################################
# MAIN FUNCTION
#############################################

set_unsplash_featured() {
		local post_id=$1
		local query=$2
		local orientation=${3:-landscape}

		echo "================================================"
		echo "Unsplash Featured Image Automation"
		echo "================================================"
		echo "Post ID: ${post_id}"
		echo "Query: ${query}"
		echo "Orientation: ${orientation}"
		echo "================================================"

		# Verify post exists
		if ! wp post get "$post_id" &>/dev/null; then
				echo "Error: Post ${post_id} not found" >&2
				return 1
		fi

		# Fetch image from Unsplash
		echo "Fetching image from Unsplash..."
		local response=$(fetch_unsplash_image "$query" "$orientation")

		if [ $? -ne 0 ]; then
				echo "Error: Failed to fetch image" >&2
				return 1
		fi

		# Parse response
		local image_url=$(echo "$response" | jq -r '.urls.regular')
		local photographer=$(echo "$response" | jq -r '.user.name')
		local photographer_url=$(echo "$response" | jq -r '.user.links.html')
		local alt_text=$(echo "$response" | jq -r '.alt_description // "Image from Unsplash"')
		local description=$(echo "$response" | jq -r '.description // .alt_description')
		local download_endpoint=$(echo "$response" | jq -r '.links.download_location')

		echo "Found: ${description}"
		echo "By: ${photographer}"

		# Create temp directory
		mkdir -p "$TEMP_DIR"

		# Download image
		local temp_file="${TEMP_DIR}/unsplash-$(date +%s).jpg"
		echo "Downloading image..."

		if ! download_image "$image_url" "$temp_file"; then
				echo "Error: Download failed" >&2
				return 1
		fi

		# Prepare metadata
		local caption="Photo by <a href=\"${photographer_url}\">${photographer}</a> on <a href=\"https://unsplash.com\">Unsplash</a>"

		local metadata=$(jq -n \
				--arg title "$description" \
				--arg alt "$alt_text" \
				--arg caption "$caption" \
				'{title: $title, alt: $alt, caption: $caption}')

		# Import to WordPress
		echo "Importing to media library..."
		local attachment_id=$(import_to_media_library "$temp_file" "$metadata")

		if [ -z "$attachment_id" ]; then
				echo "Error: Import failed" >&2
				rm -f "$temp_file"
				return 1
		fi

		echo "Imported as attachment ${attachment_id}"

		# Set as featured image
		echo "Setting as featured image..."
		if set_featured_image_for_post "$post_id" "$attachment_id"; then
				echo "✓ Featured image set successfully"
		else
				echo "Error: Failed to set featured image" >&2
				rm -f "$temp_file"
				return 1
		fi

		# Trigger download tracking (required by Unsplash)
		trigger_download_endpoint "$download_endpoint"

		# Clean up
		rm -f "$temp_file"

		echo "================================================"
		echo "SUCCESS!"
		echo "Post: ${post_id}"
		echo "Attachment: ${attachment_id}"
		echo "Photographer: ${photographer}"
		echo "================================================"

		return 0
}

#############################################
# SCRIPT ENTRY POINT
#############################################

# Check dependencies
check_dependencies

# Parse arguments
if [ $# -lt 2 ]; then
		echo "Usage: $0 <post_id> <search_query> [orientation]"
		echo ""
		echo "Examples:"
		echo "  $0 123 'technology workspace'"
		echo "  $0 456 'coffee shop' portrait"
		echo ""
		exit 1
fi

POST_ID=$1
QUERY=$2
ORIENTATION=${3:-landscape}

# Run main function
set_unsplash_featured "$POST_ID" "$QUERY" "$ORIENTATION"

exit $?

Usage

# Save as unsplash-wp.sh
chmod +x unsplash-wp.sh

# Set featured image for post
./unsplash-wp.sh 123 "technology workspace"

# Portrait orientation
./unsplash-wp.sh 456 "coffee shop interior" portrait

# Multiple keywords
./unsplash-wp.sh 789 "mountain sunset landscape"

Advanced Features

Bulk Set Featured Images

Process multiple posts:

# Get all posts without featured images
posts=$(wp post list --post_type=post --meta_key=_thumbnail_id --meta_compare=NOT EXISTS --field=ID)

for post_id in $posts; do
		# Get post title or category for query
		title=$(wp post get $post_id --field=title)

		# Set featured image
		./unsplash-wp.sh $post_id "$title"

		sleep 2  # Rate limiting
done

Smart Query from Post Content

Extract keywords from post:

get_query_from_post() {
		local post_id=$1

		# Get post title
		local title=$(wp post get $post_id --field=title)

		# Get first category
		local category=$(wp post term list $post_id category --field=name --format=csv | head -1)

		# Combine for better results
		echo "${category} ${title}"
}

# Usage
query=$(get_query_from_post 123)
./unsplash-wp.sh 123 "$query"

Fallback to Default Images

set_featured_with_fallback() {
		local post_id=$1
		local query=$2
		local fallback_query="abstract background"

		if ! ./unsplash-wp.sh $post_id "$query"; then
				echo "Primary query failed, trying fallback..."
				./unsplash-wp.sh $post_id "$fallback_query"
		fi
}

Error Handling

API Error Responses

Handle common errors:

handle_api_response() {
		local response=$1

		# Check for rate limit
		local rate_limit=$(echo "$response" | jq -r '.errors[0] // empty' | grep -i "rate limit")
		if [ -n "$rate_limit" ]; then
				echo "Error: API rate limit reached" >&2
				echo "Wait 1 hour or upgrade to production API" >&2
				return 1
		fi

		# Check for invalid query
		local invalid=$(echo "$response" | jq -r '.errors[0] // empty')
		if [ -n "$invalid" ]; then
				echo "Error: $invalid" >&2
				return 1
		fi

		return 0
}

Network Errors

download_with_retry() {
		local url=$1
		local output=$2
		local max_attempts=3
		local attempt=1

		while [ $attempt -le $max_attempts ]; do
				echo "Download attempt ${attempt}/${max_attempts}"

				if curl -s -L -o "$output" --connect-timeout 10 "$url"; then
						return 0
				fi

				attempt=$((attempt + 1))
				sleep 2
		done

		echo "Error: Download failed after ${max_attempts} attempts" >&2
		return 1
}

Rate Limiting

Unsplash Rate Limits

• Demo: 50 requests/hour
• Production: 5,000 requests/hour

Implement Rate Limiting

check_rate_limit() {
		local last_request_file="/tmp/unsplash-last-request"
		local min_interval=72  # 50 requests/hour = 72 seconds between requests

		if [ -f "$last_request_file" ]; then
				local last_request=$(cat "$last_request_file")
				local now=$(date +%s)
				local elapsed=$((now - last_request))

				if [ $elapsed -lt $min_interval ]; then
						local wait=$((min_interval - elapsed))
						echo "Rate limiting: waiting ${wait} seconds..."
						sleep $wait
				fi
		fi

		# Update last request time
		date +%s > "$last_request_file"
}

# Call before API requests
check_rate_limit

Monitor Usage

Check remaining requests:

response=$(curl -I -H "Authorization: Client-ID ${UNSPLASH_KEY}" \
	"https://api.unsplash.com/photos/random")

remaining=$(echo "$response" | grep -i "X-Ratelimit-Remaining" | cut -d: -f2 | tr -d ' \r')

echo "Remaining requests: ${remaining}"

Integration with Publishing Pipeline

Automated Blog Publishing

Combine with content automation:

publish_post_with_image() {
		local title=$1
		local content=$2
		local query=$3

		# Create post
		local post_id=$(wp post create \
				--post_title="$title" \
				--post_content="$content" \
				--post_status=publish \
				--porcelain)

		# Set featured image from Unsplash
		./unsplash-wp.sh $post_id "$query"

		echo "Published post: ${post_id}"
}

# Usage
publish_post_with_image \
		"10 Best Productivity Tools" \
		"Content here..." \
		"productivity workspace"

Integration with AI Content

# Get AI-generated content
content=$(call_ai_api "Write about productivity tools")

# Extract keywords for image
keywords=$(echo "$content" | extract_keywords)  # Custom function

# Create post
post_id=$(wp post create --post_title="..." --post_content="$content" --porcelain)

# Set Unsplash featured image
./unsplash-wp.sh $post_id "$keywords"

Learn more: Automated Blog Publishing with AI

Troubleshooting

Issue 1: “jq: command not found”

Solution:

# Ubuntu/Debian
sudo apt-get install jq

# macOS
brew install jq

# CentOS
sudo yum install jq

Issue 2: “401 Unauthorized”

Problem: Invalid API key

Solutions:

1. Verify API key is correct
2. Check environment variable is set:

echo $UNSPLASH_ACCESS_KEY

3. Regenerate API key in Unsplash dashboard

Issue 3: No Images Found

Problem: Query returns no results

Solutions:

1. Simplify query (use broader terms)
2. Try different keywords
3. Check query isn’t too specific

# Too specific (may fail)
query="red ferrari on mountain road at sunset"

# Better (broader)
query="sports car"

Issue 4: Rate Limit Exceeded

Problem: “Rate Limit Exceeded” error

Solutions:

1. Wait 1 hour for demo API reset
2. Apply for production API (5,000 req/hour)
3. Implement rate limiting in your script

Issue 5: Import Failed

Problem: wp media import fails

Solutions:

1. Check file permissions:

ls -la /tmp/image.jpg
chmod 644 /tmp/image.jpg

2. Verify uploads directory is writable:

wp media regenerate --dry-run

3. Check file size (Unsplash regular = ~500KB, should be fine)

Next Steps

Congratulations! You’ve built a complete Unsplash + WordPress automation system.

Enhance Your Integration

1. Automated Blog Publishing Pipeline – Combine with AI content
2. Custom WP-CLI Commands – Build wp unsplash command
3. Bash Functions – Refactor into reusable library

Related Guides

• WordPress REST API Integration – Advanced API techniques
• AI Content Generation – Complete publishing automation
• WordPress Automation – More automation examples

Build the Complete Pipeline

This Unsplash integration is one piece of a complete automated publishing system:

1. Generate content with AI
2. Fetch featured image from Unsplash ← You just learned this
3. Schedule and publish post
4. Optimize SEO automatically

Join WPCLI Mastery to build the complete system:

• Full automated blog publishing pipeline
• AI + Unsplash + WP-CLI integration
• Production-ready scripts and templates
• Early bird pricing ($99 vs $199)

Conclusion

Automating featured images with Unsplash API and WP-CLI saves hours of manual work while ensuring every post has professional, high-quality imagery. The script you built today can process thousands of posts automatically.

Key takeaways:

• Unsplash API provides free, high-quality images
• curl + jq makes API integration simple
• WP-CLI media import handles WordPress integration
• Proper attribution is required (and easy to automate)
• Rate limiting prevents API issues
• Integration with publishing pipelines creates powerful automation

The image automation you built today becomes even more powerful when combined with AI content generation for a complete hands-free publishing system.

Ready to implement? Start with the complete script and customize for your workflow.

Questions about Unsplash + WordPress automation? Drop a comment below!

Found this helpful? Share with WordPress developers automating content.

Next: Build a complete WordPress CI/CD pipeline with GitHub Actions that includes automated image fetching.

The post Integrate Unsplash API with WordPress Using WP-CLI and Bash appeared first on WP-CLI Mastery.