Market Research & Competitive Intelligence

// Example: Market research analysis using URL categorization
class MarketIntelligenceAnalyzer {
    constructor(apiKey) {
        this.urlDb = new URLCategorization({ apiKey });
    }

    async analyzeIndustryLandscape(category, options = {}) {
        // Get all domains in the target category
        const domains = await this.urlDb.getDomainsByCategory(category, {
            minPopularityRank: options.minRank || '100K',
            includeSubcategories: true
        });

        // Segment by popularity tier
        const segments = {
            leaders: domains.filter(d => d.popularity_rank <= 1000),
            challengers: domains.filter(d => d.popularity_rank > 1000 && d.popularity_rank <= 10000),
            niche: domains.filter(d => d.popularity_rank > 10000 && d.popularity_rank <= 100000),
            longTail: domains.filter(d => d.popularity_rank > 100000)
        };

        // Analyze category distribution
        const subcategoryBreakdown = this.analyzeSubcategories(domains);

        // Identify multi-category players
        const diversifiedPlayers = domains.filter(
            d => d.categories.length > 2
        ).map(d => ({
            domain: d.domain,
            categories: d.categories,
            diversificationScore: d.categories.length
        }));

        return {
            totalPlayers: domains.length,
            segments: segments,
            subcategoryBreakdown: subcategoryBreakdown,
            diversifiedPlayers: diversifiedPlayers,
            marketConcentration: this.calculateConcentration(segments)
        };
    }

    async trackCompetitor(competitorDomain) {
        const data = await this.urlDb.lookup(competitorDomain);

        return {
            domain: competitorDomain,
            primaryCategories: data.categories,
            marketPositioning: data.iab_categories,
            targetAudiences: data.personas,
            popularityTrend: data.popularity_rank,
            relatedDomains: await this.findRelatedDomains(data.categories)
        };
    }

    async detectEmergingTrends(timeframeDays = 90) {
        // Get categories with highest growth in new domains
        const categoryGrowth = await this.urlDb.getCategoryGrowthStats(timeframeDays);

        return categoryGrowth
            .sort((a, b) => b.growthRate - a.growthRate)
            .slice(0, 20)
            .map(cat => ({
                category: cat.name,
                growthRate: cat.growthRate,
                newDomains: cat.newDomainCount,
                trendSignal: cat.growthRate > 0.5 ? 'HOT' : cat.growthRate > 0.2 ? 'GROWING' : 'STABLE'
            }));
    }
}

// Example usage
const analyzer = new MarketIntelligenceAnalyzer(API_KEY);

// Analyze the fintech market
const fintechAnalysis = await analyzer.analyzeIndustryLandscape('fintech');
console.log(`Total fintech players: ${fintechAnalysis.totalPlayers}`);
console.log(`Market leaders: ${fintechAnalysis.segments.leaders.length}`);