Mini Audit API

const API_KEY = 'YOUR_API_KEY';
const API_BASE = 'https://api.getmint.ai/api';
const POLL_INTERVAL_MS = 3000;
const MAX_POLL_ATTEMPTS = 60; // ~3 minutes at a 3s interval

/**
 * Poll a job endpoint until it is completed, surfacing HTTP and job errors
 * and giving up after MAX_POLL_ATTEMPTS instead of looping forever.
 */
async function pollJob(url, label) {
  for (let attempt = 0; attempt < MAX_POLL_ATTEMPTS; attempt++) {
    const res = await fetch(url, { headers: { 'X-API-Key': API_KEY } });
    if (!res.ok) throw new Error(`Polling ${label} failed: HTTP ${res.status}`);
    const job = await res.json();
    if (job.status === 'completed') return job;
    if (job.status === 'failed') throw new Error(job.error || job.errorMessage || `${label} failed`);
    console.log(`Status: ${job.status}...`);
    await new Promise(r => setTimeout(r, POLL_INTERVAL_MS));
  }
  throw new Error(`Timed out waiting for ${label} to complete`);
}

/**
 * Complete Mini Audit flow:
 * 1. Analyze domain to get brand info and suggested topics
 * 2. Generate prompts for the selected topic
 * 3. Start report generation job
 * 4. Poll for results
 */
async function runCompleteMiniAudit(websiteUrl, market = 'United States', language = 'en') {
  // Step 1: Analyze domain (async) — returns a jobId, then poll /analyze/:jobId for the result
  const analyzeStart = await fetch(`${API_BASE}/domains/analyze`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'X-API-Key': API_KEY },
    body: JSON.stringify({ url: websiteUrl, market, language })
  });
  if (!analyzeStart.ok) throw new Error(`Analyze failed: HTTP ${analyzeStart.status}`);
  const { jobId: analyzeJobId } = await analyzeStart.json();

  const analyzeJob = await pollJob(`${API_BASE}/domains/analyze/${analyzeJobId}`, 'analysis');
  const domainInfo = analyzeJob.result;

  // Use first suggested topic (or choose one)
  const topic = domainInfo.suggestedTopics[0];
  console.log(`Analyzing topic: ${topic.name}`);

  // Step 2: Generate prompts for the topic
  const promptsRes = await fetch(`${API_BASE}/domains/mini-audit/generate-prompts`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'X-API-Key': API_KEY },
    body: JSON.stringify({
      domainInfo: {
        url: websiteUrl,
        name: domainInfo.name,
        market,
        primaryLanguageCode: language,
        keyBrandAttributes: domainInfo.keyBrandAttributes // Pass brand attributes for alignment prompts
      },
      topicInfo: {
        name: topic.name,
        keywords: topic.keywords,
        language,
        market
      }
    })
  });
  if (!promptsRes.ok) throw new Error(`Generate prompts failed: HTTP ${promptsRes.status}`);
  const generatedPrompts = await promptsRes.json();

  // Step 3: Start report generation job
  const jobRes = await fetch(`${API_BASE}/domains/mini-audit/generate-report`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'X-API-Key': API_KEY },
    body: JSON.stringify({
      topicName: topic.name,
      name: domainInfo.name,
      websiteUrl,
      market,
      projectLanguage: language,
      prompts: {
        visibility: generatedPrompts.visibilityPrompts,
        sentiment: generatedPrompts.sentimentPrompts,
        competition: generatedPrompts.competitionPrompts,
        alignment: generatedPrompts.alignmentPrompts
      },
      competitors: topic.competitors.map((c) => ({
        name: c.name,
        websiteUrl: c.urls?.[0]
      }))
    })
  });
  if (!jobRes.ok) throw new Error(`Generate report failed: HTTP ${jobRes.status}`);
  const { jobId } = await jobRes.json();
  console.log(`Job started: ${jobId}`);

  // Step 4: Poll until complete
  const reportJob = await pollJob(`${API_BASE}/domains/mini-audit/jobs/${jobId}`, 'report');
  console.log('Report complete!');
  return reportJob.result;
}

// Usage
const report = await runCompleteMiniAudit('https://stripe.com', 'United States', 'en');
console.log(`Visibility: ${report.metrics.visibility.value}%`);
console.log(`Sentiment: ${report.metrics.sentiment.value}`);
console.log(`Alignment: ${report.metrics.alignment.value}`);

import requests
import time

API_KEY = 'YOUR_API_KEY'
API_BASE = 'https://api.getmint.ai/api'
POLL_INTERVAL_SECONDS = 3
MAX_POLL_ATTEMPTS = 60  # ~3 minutes at a 3s interval


def poll_job(url, label):
    """Poll a job endpoint until completed, raising on HTTP/job errors and giving
    up after MAX_POLL_ATTEMPTS instead of looping forever."""
    for _ in range(MAX_POLL_ATTEMPTS):
        res = requests.get(url, headers={'X-API-Key': API_KEY})
        res.raise_for_status()
        job = res.json()
        status = job.get('status')
        if status == 'completed':
            return job
        if status == 'failed':
            raise Exception(job.get('error') or job.get('errorMessage') or f'{label} failed')
        print(f"Status: {status}...")
        time.sleep(POLL_INTERVAL_SECONDS)
    raise Exception(f'Timed out waiting for {label} to complete')


def run_complete_mini_audit(website_url, market='United States', language='en'):
    """
    Complete Mini Audit flow:
    1. Analyze domain to get brand info and suggested topics
    2. Generate prompts for the selected topic
    3. Start report generation job
    4. Poll for results
    """
    headers = {'Content-Type': 'application/json', 'X-API-Key': API_KEY}

    # Step 1: Analyze domain (async) — returns a jobId, then poll /analyze/:jobId for the result
    analyze_start = requests.post(
        f'{API_BASE}/domains/analyze',
        headers=headers,
        json={'url': website_url, 'market': market, 'language': language}
    )
    analyze_start.raise_for_status()
    analyze_job_id = analyze_start.json()['jobId']

    domain_info = poll_job(f'{API_BASE}/domains/analyze/{analyze_job_id}', 'analysis')['result']

    # Use first suggested topic (or choose one)
    topic = domain_info['suggestedTopics'][0]
    print(f"Analyzing topic: {topic['name']}")

    # Step 2: Generate prompts for the topic
    prompts_res = requests.post(
        f'{API_BASE}/domains/mini-audit/generate-prompts',
        headers=headers,
        json={
            'domainInfo': {
                'url': website_url,
                'name': domain_info['name'],
                'market': market,
                'primaryLanguageCode': language,
                'keyBrandAttributes': domain_info['keyBrandAttributes']  # Pass brand attributes for alignment prompts
            },
            'topicInfo': {
                'name': topic['name'],
                'keywords': topic['keywords'],
                'language': language,
                'market': market
            }
        }
    )
    prompts_res.raise_for_status()
    generated_prompts = prompts_res.json()

    # Step 3: Start report generation job
    job_res = requests.post(
        f'{API_BASE}/domains/mini-audit/generate-report',
        headers=headers,
        json={
            'topicName': topic['name'],
            'name': domain_info['name'],
            'websiteUrl': website_url,
            'market': market,
            'projectLanguage': language,
            'prompts': {
                'visibility': generated_prompts['visibilityPrompts'],
                'sentiment': generated_prompts['sentimentPrompts'],
                'competition': generated_prompts['competitionPrompts'],
                'alignment': generated_prompts['alignmentPrompts']
            },
            'competitors': [
                {'name': c['name'], 'websiteUrl': (c.get('urls') or [None])[0]}
                for c in topic['competitors']
            ]
        }
    )
    job_res.raise_for_status()
    job_id = job_res.json()['jobId']
    print(f"Job started: {job_id}")

    # Step 4: Poll until complete
    report_job = poll_job(f'{API_BASE}/domains/mini-audit/jobs/{job_id}', 'report')
    print('Report complete!')
    return report_job['result']

# Usage
report = run_complete_mini_audit('https://stripe.com', 'United States', 'en')
print(f"Visibility: {report['metrics']['visibility']['value']}%")
print(f"Sentiment: {report['metrics']['sentiment']['value']}")
print(f"Alignment: {report['metrics']['alignment']['value']}")