AI Content + Affiliate Links = ₹₹₹ — Here’s How to Automate It in 2025

import requests
import json
import os
import pandas as pd

# Replace with your actual SerpAPI key (get one from serpapi.com)
SERPAPI_KEY = os.environ.get("SERPAPI_KEY", "YOUR_SERPAPI_KEY")

def get_related_searches(query):
    """Fetches related searches for a given query using SerpAPI."""
    url = "https://serpapi.com/search"
    params = {
        "engine": "google",
        "q": query,
        "api_key": SERPAPI_KEY
    }
    response = requests.get(url, params=params)
    data = response.json()

    related_searches = []
    if "related_searches" in data:
        for item in data["related_searches"]:
            related_searches.append(item["query"])
    return related_searches

def get_trending_topics(geo="US", timeframe="today 24-h"):
    """
    Fetches trending searches from Google Trends via SerpAPI.
    Note: Direct Google Trends API is limited. SerpAPI provides a workaround.
    """
    url = "https://serpapi.com/search"
    params = {
        "engine": "google_trends",
        "q": "trending searches", # This is a SerpAPI specific query for trends
        "geo": geo,
        "timeframe": timeframe,
        "api_key": SERPAPI_KEY
    }
    response = requests.get(url, params=params)
    data = response.json()

    trends = []
    if "trends" in data:
        for trend_item in data["trends"]:
            trends.append(trend_item["title"])
    return trends

if __name__ == "__main__":
    initial_topic = "AI content tools 2025"
    print(f"Finding related searches for: '{initial_topic}'")
    related = get_related_searches(initial_topic)
    print(f"Related searches: {related}\n")

    print(f"Fetching trending topics for US (past 24h):")
    trending = get_trending_topics(geo="US")
    print(f"Trending topics: {trending}\n")

    # Example: Create a DataFrame for analysis
    all_keywords = list(set(related + trending)) # Combine and deduplicate
    df = pd.DataFrame(all_keywords, columns=['Keyword'])
    print("Combined Keywords DataFrame Head:")
    print(df.head())
    df.to_csv("keywords_for_ai_content.csv", index=False)
    print("\nKeywords saved to keywords_for_ai_content.csv")

import openai
import os
import json
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import StrOutputParser

# Set your OpenAI API key
os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"

# Initialize GPT-5 model (assuming 'gpt-5-turbo' is the flagship by 2025)
llm = ChatOpenAI(model="gpt-5-turbo", temperature=0.7)

# Load affiliate products mapping
# Example: {"keyword": "product_name", "link": "affiliate_link"}
AFFILIATE_PRODUCTS = {
    "AI writing tool": {"product": "WriterGPT Pro", "link": "https://example.com/writergpt-pro-affiliate"},
    "SEO analyzer": {"product": "RankMate AI", "link": "https://example.com/rankmate-ai-affiliate"},
    "Content automation platform": {"product": "AutoBlogX Suite", "link": "https://example.com/autoblogx-suite-affiliate"}
}

def generate_article_outline(topic: str) -> str:
    """Generates a detailed article outline for a given topic."""
    prompt = ChatPromptTemplate.from_messages([
        ("system", "You are an expert SEO content strategist. Generate a comprehensive and SEO-friendly article outline for the given topic, including an introduction, 3-5 main sections with 2-3 sub-headings each, and a conclusion. Suggest a catchy title too."),
        ("user", "Topic: {topic}")
    ])
    chain = prompt | llm | StrOutputParser()
    return chain.invoke({"topic": topic})

def generate_article_section(topic: str, section_heading: str, outline: str, existing_content: str = "") -> str:
    """Generates a specific section of an article, referencing the overall outline."""
    prompt = ChatPromptTemplate.from_messages([
        ("system", f"You are an expert content writer. Write a detailed and engaging section titled '{section_heading}' for an article about '{topic}'. Ensure it flows well with the provided outline and previous content. Incorporate relevant information naturally. Max 500 words."),
        ("user", f"Overall outline:\n{outline}\n\nPrevious content context (if any):\n{existing_content}\n\nWrite the section for: {section_heading}")
    ])
    chain = prompt | llm | StrOutputParser()
    return chain.invoke({"topic": topic, "section_heading": section_heading, "outline": outline, "existing_content": existing_content})

def inject_affiliate_links(content: str) -> str:
    """Injects affiliate links into the content based on predefined keywords."""
    modified_content = content
    for keyword, data in AFFILIATE_PRODUCTS.items():
        # Simple string replacement for demonstration.
        # For more robust replacement (e.g., avoiding partial words), use regex.
        modified_content = modified_content.replace(data["product"], f"[{data['product']}]({data['link']})")
    return modified_content

if __name__ == "__main__":
    article_topic = "Automating Niche Content Creation with AI in 2025"
    print(f"Generating outline for: '{article_topic}'")
    outline = generate_article_outline(article_topic)
    print("\n--- Generated Outline ---")
    print(outline)

    # Parse outline to get section headings (simple regex or LLM call)
    # For this example, let's manually pick a section for demo
    example_section_heading = "Leveraging AI for Scalable Content Drafting"
    print(f"\n--- Generating section: '{example_section_heading}' ---")
    section_content = generate_article_section(article_topic, example_section_heading, outline)
    print(section_content)

    print("\n--- Injecting Affiliate Links ---")
    final_content = inject_affiliate_links(section_content)
    print(final_content)

    with open("draft_article.md", "w") as f:
        f.write(f"# {article_topic}\n\n" + outline + "\n\n" + final_content)
    print("\nDraft article saved to draft_article.md")

import os
from wordpress_xmlrpc import Client, WordPressPost
from wordpress_xmlrpc.methods.posts import NewPost
from wordpress_xmlrpc.methods.media import UploadFile
from wordpress_xmlrpc.compat import xmlrpc_client
import mimetypes

# Your WordPress site details
WP_URL = os.environ.get("WP_URL", "https://yourblog.com/xmlrpc.php")
WP_USERNAME = os.environ.get("WP_USERNAME", "your_wordpress_username")
WP_PASSWORD = os.environ.get("WP_PASSWORD", "your_wordpress_password")

def upload_image(client, image_path):
    """Uploads an image to WordPress media library and returns its URL."""
    data = {
        'name': os.path.basename(image_path),
        'type': mimetypes.guess_type(image_path)[0] # e.g. 'image/jpeg'
    }
    with open(image_path, 'rb') as img:
        data['bits'] = xmlrpc_client.Binary(img.read())

    response = client.call(UploadFile(data))
    return response['url']

def publish_wordpress_post(title, content, tags=None, categories=None, status='publish', featured_image_url=None):
    """Publishes a new post to WordPress."""
    client = Client(WP_URL, WP_USERNAME, WP_PASSWORD)
    post = WordPressPost()
    post.title = title
    post.content = content
    post.post_status = status # 'publish', 'draft', 'pending'

    if tags:
        post.terms_names = {'post_tag': tags}
    if categories:
        post.terms_names['category'] = categories
    if featured_image_url:
        # For simplicity, we assume the URL is already on your server or accessible
        # For direct upload, use upload_image function first.
        post.thumbnail = featured_image_url # This might require custom fields or specific WP plugins if not default

    try:
        post_id = client.call(NewPost(post))
        print(f"Post '{title}' published successfully with ID: {post_id}")
        return post_id
    except Exception as e:
        print(f"Error publishing post: {e}")
        return None

if __name__ == "__main__":
    # --- Example Usage ---
    post_title = "The Future of Content: AI Automation & Affiliate Income in 2025"
    post_content = """
    This is the automated content generated by our AI, complete with embedded affiliate links.
    We discussed how [WriterGPT Pro](https://example.com/writergpt-pro-affiliate) can revolutionize your writing workflow
    and how [AutoBlogX Suite](https://example.com/autoblogx-suite-affiliate) provides an end-to-end solution.
    Stay tuned for more insights!
    """
    post_tags = ['AI Blogging 2025', 'Affiliate Marketing', 'Content Automation']
    post_categories = ['Monetization', 'AI Tools']
    
    # Placeholder for a featured image. In a real scenario, you'd upload one or use a stock image API.
    # featured_img_url = "https://yourblog.com/wp-content/uploads/2025/04/ai-content-automation.jpg"

    print("Attempting to publish post...")
    # For a real run, uncomment the image upload and pass the returned URL
    # img_url = upload_image(Client(WP_URL, WP_USERNAME, WP_PASSWORD), "path/to/your/image.jpg")
    # published_id = publish_wordpress_post(post_title, post_content, post_tags, post_categories, featured_image_url=img_url)

    published_id = publish_wordpress_post(post_title, post_content, post_tags, post_categories)

    if published_id:
        print(f"Check your blog: {WP_URL.replace('/xmlrpc.php', '')}/?p={published_id}")