Google Trends Is a Goldmine for Bloggers—Here’s the AI Script to Tap It

pip install pytrends pandas

# trend_discovery.py
from pytrends.request import TrendReq
import pandas as pd
import datetime

def get_daily_trends(geo='US'):
    """Fetches daily trending searches for a specific geography."""
    pytrends = TrendReq(hl='en-US', tz=360) # tz is time zone offset (e.g., 360 for US central)
    df = pytrends.trending_searches(pn=geo)
    return df

if __name__ == "__main__":
    print("Fetching daily trends for the US...")
    trends_df = get_daily_trends(geo='US')

    if not trends_df.empty:
        print("--- Top 5 Daily Trends (US) ---")
        print(trends_df.head())
        # Example: Save to CSV for later analysis
        trends_df.to_csv(f"daily_trends_US_{datetime.date.today().isoformat()}.csv", index=False)
        print(f"Trends saved to daily_trends_US_{datetime.date.today().isoformat()}.csv")
    else:
        print("No trends found or an error occurred.")

# Example: Get related queries for a specific term (e.g., 'AI in healthcare')
# pytrends.build_payload(kw_list=['AI in healthcare'], cat=0, timeframe='today 1-m', geo='')
# related_queries = pytrends.related_queries()
# print("\nRelated Queries for 'AI in healthcare':")
# print(related_queries['AI in healthcare']['top'])

pip install google-search-results

# serp_analysis.py
from serpapi import GoogleSearch
import os

# Set your SerpAPI_API_KEY as an environment variable or hardcode it (not recommended for production)
# os.environ["SERPAPI_API_KEY"] = "YOUR_SERPAPI_API_KEY"

def analyze_keyword(keyword, api_key):
    """Analyzes a keyword using SerpAPI to get search results, volume, and related queries."""
    try:
        params = {
            "api_key": api_key,
            "engine": "google",
            "q": keyword,
            "hl": "en",
            "gl": "us",
            "tbm": "serp" # Specifies standard web search
        }
        search = GoogleSearch(params)
        results = search.get_dict()

        # Basic competition check (count top organic results)
        organic_results = results.get("organic_results", [])
        competition_score = len(organic_results)

        # Look for related searches
        related_searches = [s['query'] for s in results.get("related_searches", [])]

        # Note: SerpAPI provides estimated search volume via some integrations, or you can infer from ads.
        # For precise volume, you'd usually combine with another tool's API (e.g., Ahrefs, Semrush).
        # For simplicity here, we'll focus on competition and related searches.

        return {
            "keyword": keyword,
            "competition": competition_score,
            "top_results_titles": [res.get('title') for res in organic_results[:3]],
            "related_searches": related_searches
        }
    except Exception as e:
        print(f"Error analyzing keyword '{keyword}': {e}")
        return None

if __name__ == "__main__":
    SERPAPI_API_KEY = os.getenv("SERPAPI_API_KEY") # Make sure to set this env var!
    if not SERPAPI_API_KEY:
        print("Error: SERPAPI_API_KEY environment variable not set. Please set it.")
        exit()

    target_keyword = "AI-powered personal finance"
    analysis_data = analyze_keyword(target_keyword, SERPAPI_API_KEY)

    if analysis_data:
        print(f"\n--- Analysis for '{analysis_data['keyword']}' ---")
        print(f"Competition (Top Organic Results): {analysis_data['competition']}")
        print("Top 3 Result Titles:")
        for title in analysis_data['top_results_titles']:
            print(f"- {title}")
        print("\nRelated Searches:")
        for query in analysis_data['related_searches'][:5]: # Show top 5
            print(f"- {query}")

pip install openai

# content_generation.py
import openai
import os

# Set your OPENAI_API_KEY as an environment variable
# os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"

def generate_blog_post(topic, target_keywords, api_key):
    """Generates a comprehensive blog post using GPT-5."""
    openai.api_key = api_key

    # Crafting a robust prompt for GPT-5
    prompt = f"""
    You are an expert blogger specializing in clear, engaging, and SEO-optimized content.
    Your task is to write a detailed blog post on the topic: "{topic}".

    **Key Requirements:**
    1.  **Catchy Title**: A compelling title that encourages clicks.
    2.  **Introduction**: Hook the reader, define the topic.
    3.  **Main Sections**: Break down the topic into 3-5 logical, well-structured sections with subheadings.
    4.  **Integration**: Naturally integrate the following target keywords throughout the content: {', '.join(target_keywords)}.
    5.  **Practical Value**: Offer actionable insights, tips, or examples.
    6.  **Conclusion**: Summarize key takeaways and provide a call to action (e.g., "What are your thoughts?").
    7.  **Tone**: Energetic, smart, informative, and engaging.
    8.  **Format**: Use Markdown for headings, bold text, lists, etc.
    9.  **Word Count**: Aim for 800-1200 words.

    Start directly with the title.
    """

    try:
        response = openai.chat.completions.create(
            model="gpt-5-turbo" if os.getenv("OPENAI_GPT_5_AVAILABLE") else "gpt-4-turbo", # Assuming GPT-5 or latest GPT-4 is available
            messages=[
                {"role": "system", "content": "You are a highly skilled blog post writer."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.7, # Controls creativity (0.0-1.0)
            max_tokens=2000 # Enough tokens for a detailed post
        )
        return response.choices[0].message.content
    except Exception as e:
        print(f"Error generating content: {e}")
        return None

if __name__ == "__main__":
    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
    if not OPENAI_API_KEY:
        print("Error: OPENAI_API_KEY environment variable not set. Please set it.")
        exit()

    blog_topic = "AI-powered personal finance"
    blog_keywords = ["AI finance apps", "AI financial advisor", "budgeting AI", "financial planning with AI"]

    print(f"Generating blog post on '{blog_topic}'...")
    generated_content = generate_blog_post(blog_topic, blog_keywords, OPENAI_API_KEY)

    if generated_content:
        print("\n--- Generated Blog Post (Excerpt) ---")
        print(generated_content[:500] + "...") # Print first 500 characters
        with open("generated_blog_post.md", "w", encoding="utf-8") as f:
            f.write(generated_content)
        print("\nFull post saved to generated_blog_post.md")
    else:
        print("Failed to generate blog post.")

pip install python-wordpress-xmlrpc

# auto_publish.py
from wordpress_xmlrpc import Client, WordPressPost
from wordpress_xmlrpc.methods.posts import NewPost
from wordpress_xmlrpc.methods.media import UploadFile
import os
import mimetypes

# WordPress credentials and blog URL
WORDPRESS_URL = "https://yourblog.com/xmlrpc.php"
WORDPRESS_USERNAME = os.getenv("WORDPRESS_USERNAME")
WORDPRESS_PASSWORD = os.getenv("WORDPRESS_PASSWORD")

def publish_post(title, content, categories=[], tags=[], status='publish'):
    """Publishes a new post to WordPress."""
    try:
        if not all([WORDPRESS_URL, WORDPRESS_USERNAME, WORDPRESS_PASSWORD]):
            raise ValueError("WordPress credentials not fully set. Check env vars.")

        client = Client(WORDPRESS_URL, WORDPRESS_USERNAME, WORDPRESS_PASSWORD)

        post = WordPressPost()
        post.title = title
        post.content = content
        post.post_status = status # 'publish', 'draft', 'pending'
        post.categories = categories
        post.tags = tags

        post_id = client.call(NewPost(post))
        print(f"Successfully published post with ID: {post_id}")
        return post_id
    except Exception as e:
        print(f"Error publishing post to WordPress: {e}")
        return None

if __name__ == "__main__":
    if not (WORDPRESS_USERNAME and WORDPRESS_PASSWORD):
        print("Error: WORDPRESS_USERNAME or WORDPRESS_PASSWORD environment variable not set. Please set them.")
        exit()

    # Load the generated content
    try:
        with open("generated_blog_post.md", "r", encoding="utf-8") as f:
            blog_content = f.read()
            # Extract title from the first line if it's a Markdown heading
            blog_title = blog_content.split('\n')[0].replace('#', '').strip()
    except FileNotFoundError:
        print("Error: generated_blog_post.md not found. Please run content_generation.py first.")
        exit()
    except Exception as e:
        print(f"Error reading generated content: {e}")
        exit()

    # Example usage
    categories_for_post = ['AI', 'Finance', 'Technology']
    tags_for_post = ['AI finance apps', 'personal finance', 'AI financial advisor', '2025']

    print(f"Attempting to publish '{blog_title}' to WordPress...")
    new_post_id = publish_post(blog_title, blog_content, categories_for_post, tags_for_post)

    if new_post_id:
        print(f"Post '{blog_title}' published successfully! Check your WordPress dashboard.")
    else:
        print("Failed to publish post.")

# master_automation.py
import os
import sys
import time

# Add script directories to path if they are not in the same directory
# sys.path.append('/path/to/your/scripts') # Uncomment if needed

from trend_discovery import get_daily_trends
from serp_analysis import analyze_keyword
from content_generation import generate_blog_post
from auto_publish import publish_post

def run_automation():
    print("--- Starting Content Automation Workflow ---")

    # --- Configuration ---
    SERPAPI_API_KEY = os.getenv("SERPAPI_API_KEY")
    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
    WORDPRESS_USERNAME = os.getenv("WORDPRESS_USERNAME")
    WORDPRESS_PASSWORD = os.getenv("WORDPRESS_PASSWORD")
    WORDPRESS_URL = "https://yourblog.com/xmlrpc.php" # IMPORTANT: Update this!

    if not all([SERPAPI_API_KEY, OPENAI_API_KEY, WORDPRESS_USERNAME, WORDPRESS_PASSWORD, WORDPRESS_URL]):
        print("Error: Missing one or more API keys or WordPress credentials. Please set environment variables and WordPress URL.")
        return

    # --- 1. Trend Discovery ---
    print("\n[STEP 1/4] Discovering daily trends...")
    trends_df = get_daily_trends(geo='US')
    if trends_df.empty:
        print("No new trends found. Exiting.")
        return

    # Process only the top trend for this example
    top_trend = trends_df.iloc[0, 0]
    print(f"Top trend identified: '{top_trend}'")

    # --- 2. Opportunity Analysis ---
    print(f"\n[STEP 2/4] Analyzing opportunity for '{top_trend}'...")
    analysis_data = analyze_keyword(top_trend, SERPAPI_API_KEY)

    if not analysis_data or analysis_data['competition'] > 20: # Example threshold
        print(f"Trend '{top_trend}' is too competitive or no data. Skipping.")
        return

    print(f"Competition score: {analysis_data['competition']}. Related searches: {analysis_data['related_searches'][:3]}...")
    
    # Use top 5 related searches as target keywords for content generation
    target_keywords = [top_trend] + analysis_data['related_searches'][:5]

    # --- 3. Content Generation ---
    print(f"\n[STEP 3/4] Generating blog post for '{top_trend}'...")
    generated_content = generate_blog_post(top_trend, target_keywords, OPENAI_API_KEY)

    if not generated_content:
        print("Failed to generate content. Exiting.")
        return

    # Extract title from generated content
    blog_title = generated_content.split('\n')[0].replace('#', '').strip()
    print(f"Content generated successfully. Title: '{blog_title}'")

    # Save content to a temporary file
    with open("temp_generated_post.md", "w", encoding="utf-8") as f:
        f.write(generated_content)

    # --- 4. Automated Publishing ---
    print(f"\n[STEP 4/4] Publishing '{blog_title}' to WordPress...")
    categories_for_post = ['AI', 'Trends', 'Technology'] # Customize these!
    tags_for_post = list(set([kw.lower() for kw in target_keywords[:5]] + [top_trend.lower(), '2025'])) # Ensure unique and lowercase tags

    new_post_id = publish_post(blog_title, generated_content, categories_for_post, tags_for_post, status='draft') # Start as 'draft' for review!

    if new_post_id:
        print(f"Workflow completed! Post '{blog_title}' created as a DRAFT (ID: {new_post_id}). Please review and publish.")
    else:
        print("Workflow completed with publishing errors.")

    # Clean up temporary file
    if os.path.exists("temp_generated_post.md"):
        os.remove("temp_generated_post.md")

    print("\n--- Content Automation Workflow Finished ---")

if __name__ == "__main__":
    run_automation()