Competitive intelligence

import requests
from datetime import datetime

MONITORING_PROMPTS = [
    # Direct brand queries
    "What is [Your Company]?",
    "Tell me about [Your Product]",
    
    # Competitive queries
    "Compare [Your Product] vs [Competitor Product]",
    "What are the best [product category] solutions?",
    
    # Industry queries
    "What are the leading companies in [your industry]?",
    "How to choose a [product category] provider?",
    
    # Problem-solution queries
    "How to solve [problem your product addresses]?",
    "Best practices for [use case your product serves]"
]

def monitor_brand_visibility(prompts):
    """Monitor brand visibility across multiple prompts."""
    
    results = []
    
    for prompt in prompts:
        payload = {
            'prompt': prompt,
            'include': {
                'markdown': True,
                'searchQueries': True
            }
        }
        
        response = requests.post(
            'https://api.cloro.dev/v1/monitor/chatgpt',
            headers={'Authorization': 'Bearer YOUR_API_KEY'},
            json=payload,
            timeout=180
        )
        
        data = response.json()
        
        results.append({
            'prompt': prompt,
            'response': data['result']['text'],
            'markdown': data['result'].get('markdown', ''),
            'model': data['result']['model'],
            'search_queries': data['result'].get('searchQueries', []),
            'timestamp': datetime.now().isoformat()
        })
    
    return results

# Run monitoring
monitoring_data = monitor_brand_visibility(MONITORING_PROMPTS)

import json

def analyze_brand_mentions(results, brand_name):
    """Analyze how often and in what context your brand is mentioned."""
    
    analysis = {
        'total_prompts': len(results),
        'mentions': 0,
        'mention_contexts': [],
        'sentiment_indicators': [],
        'product_mentions': []
    }
    
    for result in results:
        response_text = result['response'].lower()
        brand_lower = brand_name.lower()
        
        # Check for brand mentions
        if brand_lower in response_text:
            analysis['mentions'] += 1
            
            # Extract context around mention
            sentences = response_text.split('.')
            for sentence in sentences:
                if brand_lower in sentence:
                    analysis['mention_contexts'].append(sentence.strip())
    
    # Calculate mention rate
    analysis['mention_rate'] = analysis['mentions'] / analysis['total_prompts']
    
    return analysis

# Analyze results
brand_analysis = analyze_brand_mentions(monitoring_data, 'Your Company')
print(f"Brand mentioned in {brand_analysis['mention_rate']:.1%} of responses")

def compare_competitors(prompts, brands):
    """Compare mention rates across multiple brands."""
    
    # Collect data for competitive prompts
    results = monitor_brand_visibility(prompts)
    
    comparison = {}
    
    for brand in brands:
        analysis = analyze_brand_mentions(results, brand)
        comparison[brand] = {
            'mention_rate': analysis['mention_rate'],
            'total_mentions': analysis['mentions'],
            'contexts': analysis['mention_contexts'][:3]  # Top 3 contexts
        }
    
    return comparison

# Compare your brand vs competitors
competitive_prompts = [
    "What are the best [product category] tools?",
    "Compare top [industry] solutions",
    "Which [product category] should I choose?"
]

brands_to_track = ['Your Company', 'Competitor A', 'Competitor B']

comparison = compare_competitors(competitive_prompts, brands_to_track)

# Display comparison
for brand, metrics in comparison.items():
    print(f"\n{brand}:")
    print(f"  Mention rate: {metrics['mention_rate']:.1%}")
    print(f"  Total mentions: {metrics['total_mentions']}")

def analyze_shopping_visibility(prompt):
    """Analyze product visibility in shopping card results."""
    
    payload = {'prompt': prompt}
    
    response = requests.post(
        'https://api.cloro.dev/v1/monitor/chatgpt',
        headers={'Authorization': 'Bearer YOUR_API_KEY'},
        json=payload
    )
    
    data = response.json()
    
    # Analyze shopping cards
    if 'shoppingCards' in data['result']:
        products_found = []
        
        for card in data['result']['shoppingCards']:
            for product in card['products']:
                products_found.append({
                    'title': product['title'],
                    'price': product['price'],
                    'rating': product.get('rating'),
                    'merchant': product.get('merchant'),
                    'position': len(products_found) + 1
                })
        
        return products_found
    
    return []

# Monitor product recommendations
product_query = "Best wireless headphones under $200"
products = analyze_shopping_visibility(product_query)

print(f"Found {len(products)} products")
for i, product in enumerate(products[:5], 1):
    print(f"{i}. {product['title']} - {product['price']}")

def analyze_query_fanout(prompts):
    """Analyze what queries ChatGPT uses to research your industry."""
    
    all_queries = []
    
    for prompt in prompts:
        payload = {
            'prompt': prompt,
            'include': {'searchQueries': True}
        }
        
        response = requests.post(
            'https://api.cloro.dev/v1/monitor/chatgpt',
            headers={'Authorization': 'Bearer YOUR_API_KEY'},
            json=payload
        )
        
        data = response.json()
        
        if 'searchQueries' in data['result']:
            all_queries.extend(data['result']['searchQueries'])
    
    # Analyze query patterns
    query_insights = {
        'total_queries': len(all_queries),
        'unique_queries': len(set(all_queries)),
        'common_terms': extract_common_terms(all_queries)
    }
    
    return query_insights

def extract_common_terms(queries):
    """Extract common terms from search queries."""
    from collections import Counter
    
    all_words = []
    for query in queries:
        words = query.lower().split()
        all_words.extend(words)
    
    # Return top 10 most common terms
    return Counter(all_words).most_common(10)

# Monitor industry topics over time
industry_prompts = [
    "What are the latest trends in [your industry]?",
    "What innovations are shaping [your industry]?",
    "What are the biggest challenges in [your industry]?"
]

# Run monthly and compare results
trends_january = monitor_brand_visibility(industry_prompts)
trends_february = monitor_brand_visibility(industry_prompts)

# Analyze changes

regions = ['US', 'GB', 'DE']

for region in regions:
    payload = {
        'prompt': 'Best [product category] companies',
        'country': region
    }
    # Analyze regional differences