AI Lead Scoring with CHAMP

curl -X POST https://spideriq.di-atomic.com/api/v1/jobs/spiderSite/submit \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "payload": {
      "url": "https://target-company.com",
      "max_pages": 20,
      "extract_company_info": true,
      "extract_team": true,
      "extract_pain_points": true,
      "product_description": "AI-powered customer support automation platform that reduces ticket resolution time by 60%...",
      "icp_description": "B2B SaaS companies with 50-500 employees, experiencing rapid growth..."
    },
    "priority": 8
  }'

import requests
import time
from typing import Dict, List, Optional

class LeadQualifier:
    def __init__(self, api_key: str, product_desc: str, icp_desc: str):
        self.api_key = api_key
        self.base_url = "https://spideriq.di-atomic.com/api/v1"
        self.headers = {"Authorization": f"Bearer {api_key}"}
        self.product_description = product_desc
        self.icp_description = icp_desc

    def submit_job(self, payload: Dict, priority: int = 0) -> str:
        """Submit job and return job_id"""
        response = requests.post(
            f"{self.base_url}/jobs/spiderSite/submit",
            headers=self.headers,
            json={"payload": payload, "priority": priority}
        )
        response.raise_for_status()
        return response.json()['job_id']

    def get_results(self, job_id: str, timeout: int = 120) -> Dict:
        """Poll for results"""
        url = f"{self.base_url}/jobs/{job_id}/results"

        for _ in range(timeout // 3):
            response = requests.get(url, headers=self.headers)

            if response.status_code == 200:
                return response.json()
            elif response.status_code == 202:
                time.sleep(3)
            elif response.status_code == 410:
                raise Exception(response.json()['error_message'])

        raise TimeoutError(f"Job {job_id} timeout")

    def stage1_basic(self, url: str) -> Optional[Dict]:
        """Stage 1: Basic contact extraction (0 tokens)"""
        print(f"Stage 1: {url}")

        job_id = self.submit_job({"url": url, "max_pages": 10})
        results = self.get_results(job_id)
        data = results['data']

        # Qualification criteria
        has_contacts = len(data['emails']) > 0 or len(data['phones']) > 0
        has_linkedin = data.get('linkedin') is not None

        if not (has_contacts and has_linkedin):
            print(f"  ✗ Failed Stage 1: No contacts or LinkedIn")
            return None

        print(f"  ✓ Passed Stage 1: {len(data['emails'])} emails, LinkedIn found")
        return data

    def stage2_company(self, url: str) -> Optional[Dict]:
        """Stage 2: Company analysis (~500 tokens)"""
        print(f"Stage 2: {url}")

        job_id = self.submit_job({
            "url": url,
            "max_pages": 15,
            "extract_company_info": True
        }, priority=5)

        results = self.get_results(job_id)
        data = results['data']

        # Qualification criteria
        company = data.get('company_vitals')
        if not company:
            print(f"  ✗ Failed Stage 2: No company info extracted")
            return None

        # Check industry match (example logic)
        target_keywords = ['saas', 'software', 'b2b', 'tech']
        industry_match = any(kw in company['industry'].lower() for kw in target_keywords)

        if not industry_match:
            print(f"  ✗ Failed Stage 2: Industry mismatch ({company['industry']})")
            return None

        print(f"  ✓ Passed Stage 2: {company['name']}, {company['industry']}")
        return data

    def stage3_champ(self, url: str) -> Dict:
        """Stage 3: Full CHAMP analysis (~3,000 tokens)"""
        print(f"Stage 3: {url}")

        job_id = self.submit_job({
            "url": url,
            "max_pages": 20,
            "extract_company_info": True,
            "extract_team": True,
            "extract_pain_points": True,
            "product_description": self.product_description,
            "icp_description": self.icp_description
        }, priority=8)

        results = self.get_results(job_id, timeout=180)
        data = results['data']

        icp_score = data.get('lead_scoring', {}).get('icp_fit_score', 0)
        print(f"  ✓ CHAMP Complete: ICP Score = {icp_score:.2f}")

        return data

    def qualify_lead(self, url: str) -> Optional[Dict]:
        """Progressive qualification pipeline"""
        # Stage 1: Basic (0 tokens)
        data = self.stage1_basic(url)
        if not data:
            return None

        # Stage 2: Company (~500 tokens)
        data = self.stage2_company(url)
        if not data:
            return None

        # Stage 3: Full CHAMP (~3,000 tokens)
        data = self.stage3_champ(url)

        return data


# Usage Example
qualifier = LeadQualifier(
    api_key="YOUR_API_KEY",
    product_desc="AI-powered customer support automation platform...",
    icp_desc="B2B SaaS companies with 50-500 employees..."
)

# Process list of prospects
prospects = [
    "https://prospect1.com",
    "https://prospect2.com",
    "https://prospect3.com"
]

qualified_leads = []

for url in prospects:
    try:
        lead_data = qualifier.qualify_lead(url)
        if lead_data:
            qualified_leads.append({
                'url': url,
                'data': lead_data
            })
    except Exception as e:
        print(f"Error processing {url}: {e}")

# Export high-fit leads
import json
high_fit = [
    lead for lead in qualified_leads
    if lead['data'].get('lead_scoring', {}).get('icp_fit_score', 0) >= 0.70
]

with open('qualified_leads.json', 'w') as f:
    json.dump(high_fit, f, indent=2)

print(f"\n✓ Qualified {len(high_fit)}/{len(prospects)} leads (ICP fit ≥0.70)")