WordPress + AI: The Complete Automation Pipeline for 2026

<?php
// Add to functions.php or custom plugin
add_action('rest_api_init', function () {
    register_rest_route('automation/v1', '/status', array(
        'methods' => 'GET',
        'callback' => 'automation_status_check',
        'permission_callback' => '__return_true'
    ));
});

function automation_status_check() {
    return array(
        'status' => 'ready',
        'wordpress_version' => get_bloginfo('version'),
        'abilities_api' => function_exists('wp_abilities_get_all'),
        'timestamp' => current_time('mysql')
    );
}

// Configure default AI settings
define('AI_ENGINE_DEFAULT_MODEL', 'gpt-4-turbo');
define('AI_ENGINE_MAX_TOKENS', 4000);
define('AI_ENGINE_TEMPERATURE', 0.7);

// Add to wp-config.php for security
define('OPENAI_API_KEY', 'sk-proj-xxxxx');
define('ANTHROPIC_API_KEY', 'sk-ant-xxxxx');

// Configure image generation
add_filter('ai_image_generator_settings', function($settings) {
    $settings['provider'] = 'openai'; // or 'leonardo', 'pollinations'
    $settings['style'] = 'photorealistic';
    $settings['size'] = '1792x1024';
    $settings['quality'] = 'hd';
    return $settings;
});

// Node.js example for n8n workflow
const generateFeaturedImage = async (articleTitle, keywords) => {
  const prompt = `Professional blog header image for article titled "${articleTitle}".
  Style: Modern, clean, tech-focused. Include subtle visual references to: ${keywords.join(', ')}.
  No text overlays. 16:9 aspect ratio.`;

  const response = await fetch('https://api.openai.com/v1/images/generations', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      model: "dall-e-3",
      prompt: prompt,
      size: "1792x1024",
      quality: "hd",
      n: 1
    })
  });

  const data = await response.json();
  return data.data[0].url;
};

{
  "name": "WordPress AI Publishing Pipeline",
  "nodes": [
    {
      "name": "Schedule Trigger",
      "type": "n8n-nodes-base.scheduleTrigger",
      "parameters": {
        "rule": {
          "interval": [{"field": "hours", "hoursInterval": 6}]
        }
      }
    },
    {
      "name": "Research Keywords",
      "type": "n8n-nodes-base.httpRequest",
      "parameters": {
        "url": "https://api.perplexity.ai/chat/completions",
        "method": "POST",
        "body": {
          "model": "sonar",
          "messages": [{
            "role": "user",
            "content": "Research trending topics in [YOUR NICHE] with high search volume"
          }]
        }
      }
    },
    {
      "name": "Generate Article",
      "type": "n8n-nodes-base.openAi",
      "parameters": {
        "resource": "chat",
        "model": "gpt-4-turbo",
        "messages": {
          "values": [{
            "role": "system",
            "content": "You are an expert SEO content writer. Create a comprehensive, well-structured article."
          }]
        }
      }
    },
    {
      "name": "Generate Featured Image",
      "type": "n8n-nodes-base.openAi",
      "parameters": {
        "resource": "image",
        "model": "dall-e-3",
        "size": "1792x1024"
      }
    },
    {
      "name": "Optimize SEO",
      "type": "n8n-nodes-base.httpRequest",
      "parameters": {
        "url": "{{$node['WordPress'].json['link']}}/wp-json/rankmath/v1/updateMeta"
      }
    },
    {
      "name": "Publish to WordPress",
      "type": "n8n-nodes-base.wordpress",
      "parameters": {
        "resource": "post",
        "operation": "create",
        "status": "publish"
      }
    }
  ],
  "connections": {
    "Schedule Trigger": {"main": [[{"node": "Research Keywords"}]]},
    "Research Keywords": {"main": [[{"node": "Generate Article"}]]},
    "Generate Article": {"main": [[{"node": "Generate Featured Image"}]]},
    "Generate Featured Image": {"main": [[{"node": "Publish to WordPress"}]]},
    "Publish to WordPress": {"main": [[{"node": "Optimize SEO"}]]}
  }
}

// AutoJourneyAI configuration
$config = array(
    'ai_model' => 'gpt-4-turbo',
    'schedule' => 'daily',
    'post_status' => 'draft', // or 'publish'
    'categories' => array('AI', 'Technology'),
    'featured_image' => true,
    'seo_optimization' => true,
    'internal_links' => true
);

// Rank Math API integration
function automate_rankmath_seo($post_id, $content) {
    $seo_data = array(
        'focus_keyword' => extract_primary_keyword($content),
        'meta_title' => generate_meta_title($content),
        'meta_description' => generate_meta_description($content),
        'schema_type' => 'Article',
        'internal_links' => find_internal_links($content)
    );

    update_post_meta($post_id, 'rank_math_focus_keyword', $seo_data['focus_keyword']);
    update_post_meta($post_id, 'rank_math_title', $seo_data['meta_title']);
    update_post_meta($post_id, 'rank_math_description', $seo_data['meta_description']);

    return $seo_data;
}

// Alt text for images
function generate_image_alt_text($image_url, $context) {
    $prompt = "Generate SEO-optimized alt text for this image in the context of: {$context}";
    return call_ai_api($prompt);
}

// Automatic Article schema
add_filter('rank_math/snippet/rich_snippet_article_entity', function($entity) {
    $entity['author'] = array(
        '@type' => 'Organization',
        'name' => get_bloginfo('name')
    );
    $entity['publisher'] = array(
        '@type' => 'Organization',
        'name' => get_bloginfo('name'),
        'logo' => array(
            '@type' => 'ImageObject',
            'url' => get_site_icon_url()
        )
    );
    return $entity;
});

// Quality scoring before publishing
const assessContentQuality = async (content) => {
  const checks = {
    wordCount: content.split(' ').length >= 1500,
    readability: calculateFleschScore(content) >= 60,
    keywordDensity: calculateKeywordDensity(content) <= 2.5,
    hasImages: content.includes('<img'),
    hasHeadings: content.includes('<h2>'),
    hasInternalLinks: content.includes('href="' + siteUrl),
    hasExternalLinks: content.match(/href="https?:\/\//g)?.length >= 3
  };

  const score = Object.values(checks).filter(Boolean).length / Object.keys(checks).length;

  return {
    score: score * 100,
    passed: score >= 0.85,
    checks: checks
  };
};

// Set to draft if quality score is below threshold
add_filter('ai_automation_post_status', function($status, $post_id) {
    $quality_score = get_post_meta($post_id, '_quality_score', true);

    if ($quality_score < 85) {
        return 'draft'; // Requires human review
    }

    return 'publish'; // Auto-publish high-quality content
}, 10, 2);

# Python example for image upload + attachment
import requests
import base64

def upload_featured_image(image_url, post_id, wp_url, username, app_password):
    # Download image
    img_data = requests.get(image_url).content

    # Upload to WordPress
    auth = base64.b64encode(f"{username}:{app_password}".encode()).decode()

    upload_response = requests.post(
        f"{wp_url}/wp-json/wp/v2/media",
        headers={
            "Authorization": f"Basic {auth}",
            "Content-Disposition": "attachment; filename=featured-image.jpg"
        },
        data=img_data
    )

    media_id = upload_response.json()['id']

    # Set as featured image
    requests.post(
        f"{wp_url}/wp-json/wp/v2/posts/{post_id}",
        headers={"Authorization": f"Basic {auth}"},
        json={"featured_media": media_id}
    )

    return media_id

// Batch update multiple posts
const batchUpdatePosts = async (posts, updates) => {
  const batch = posts.map(postId => ({
    method: 'POST',
    path: `/wp/v2/posts/${postId}`,
    body: updates
  }));

  const response = await fetch(`${wpUrl}/wp-json/batch/v1`, {
    method: 'POST',
    headers: {
      'Authorization': `Basic ${authToken}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ requests: batch })
  });

  return response.json();
};

// Debug REST API access
add_filter('rest_authentication_errors', function($result) {
    if (!empty($result)) {
        error_log('REST API Auth Error: ' . print_r($result, true));
    }
    return $result;
});

// Enable application passwords
add_filter('wp_is_application_passwords_available', '__return_true');

// Implement request throttling
function throttle_ai_requests($requests_per_minute = 10) {
    $cache_key = 'ai_request_count_' . get_current_user_id();
    $count = get_transient($cache_key) ?: 0;

    if ($count >= $requests_per_minute) {
        return new WP_Error('rate_limit', 'Too many requests. Please wait.');
    }

    set_transient($cache_key, $count + 1, MINUTE_IN_SECONDS);
    return true;
}

// Retry logic with exponential backoff
const retryWithBackoff = async (fn, maxRetries = 3) => {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (i === maxRetries - 1) throw error;
      await new Promise(resolve => setTimeout(resolve, Math.pow(2, i) * 1000));
    }
  }
};

// Model tiering strategy
function select_ai_model_by_task($task_type) {
    $models = array(
        'outline' => 'gpt-4o-mini',        // $0.15/1M tokens
        'draft' => 'claude-3-sonnet',       // $3/1M tokens
        'final' => 'gpt-4-turbo',           // $10/1M tokens
        'translation' => 'gemini-pro',      // $1.25/1M tokens
    );

    return $models[$task_type] ?? 'gpt-4o-mini';
}

// Restrict REST API access
add_filter('rest_authentication_errors', function($result) {
    if (!empty($result)) {
        return $result;
    }

    if (!is_user_logged_in()) {
        // Allow only specific endpoints for automation
        $allowed_routes = array('/wp/v2/posts', '/wp/v2/media');
        $current_route = $_SERVER['REQUEST_URI'];

        $is_allowed = false;
        foreach ($allowed_routes as $route) {
            if (strpos($current_route, $route) !== false) {
                $is_allowed = true;
                break;
            }
        }

        if (!$is_allowed) {
            return new WP_Error(
                'rest_not_allowed',
                'REST API access restricted',
                array('status' => 401)
            );
        }
    }

    return $result;
});

// API key rotation
function rotate_application_passwords() {
    // Automatically expire old application passwords
    $passwords = WP_Application_Passwords::get_user_application_passwords(get_current_user_id());

    foreach ($passwords as $password) {
        $created = strtotime($password['created']);
        $age_days = (time() - $created) / DAY_IN_SECONDS;

        if ($age_days > 90) {
            WP_Application_Passwords::delete_application_password(
                get_current_user_id(),
                $password['uuid']
            );
        }
    }
}
add_action('wp_scheduled_auto_delete', 'rotate_application_passwords');