List Leads

async function getLeadAnalytics() {
  const statuses = ["new", "contacted", "replied", "converted", "cold"];
  const analytics = {};

  for (const status of statuses) {
    const response = await fetch(
      `https://api.buena.ai/api/v2/leads?status=${status}&limit=1`,
      {
        headers: { "x-api-key": process.env.BUENA_API_KEY },
      }
    );

    const data = await response.json();
    analytics[status] = data.data.pagination.total;
  }

  console.log("Lead Analytics:", analytics);

  // Calculate conversion rate
  const total = Object.values(analytics).reduce((sum, count) => sum + count, 0);
  const conversionRate = ((analytics.converted / total) * 100).toFixed(1);

  console.log(`Conversion Rate: ${conversionRate}%`);

  return analytics;
}

import requests
from datetime import datetime, timedelta

def find_leads_needing_followup():
    """Find contacted leads that haven't been followed up in 7 days"""

    seven_days_ago = (datetime.now() - timedelta(days=7)).isoformat() + 'Z'

    response = requests.get(
        'https://api.buena.ai/api/v2/leads',
        headers={'x-api-key': os.getenv('BUENA_API_KEY')},
        params={
            'status': 'contacted',
            'lastContactedBefore': seven_days_ago,
            'sortBy': 'lastContactedAt',
            'sortOrder': 'asc',
            'limit': 100
        }
    )

    data = response.json()
    followup_leads = data['data']['leads']

    print(f"Found {len(followup_leads)} leads needing follow-up:")

    for lead in followup_leads:
        last_contacted = datetime.fromisoformat(lead['lastContactedAt'].replace('Z', '+00:00'))
        days_ago = (datetime.now() - last_contacted).days

        print(f"- {lead['firstName']} {lead['lastName']} ({lead['company']}) - {days_ago} days ago")

    return followup_leads

async function exportAllLeads() {
  const allLeads = [];
  let page = 1;
  let hasMore = true;

  while (hasMore) {
    const response = await fetch(
      `https://api.buena.ai/api/v2/leads?page=${page}&limit=100&sortBy=createdAt&sortOrder=asc`,
      {
        headers: { "x-api-key": process.env.BUENA_API_KEY },
      }
    );

    const data = await response.json();
    allLeads.push(...data.data.leads);

    hasMore = data.data.pagination.hasNextPage;
    page++;

    console.log(`Exported page ${page - 1} (${data.data.leads.length} leads)`);

    // Rate limiting
    await new Promise((resolve) => setTimeout(resolve, 100));
  }

  console.log(`Total leads exported: ${allLeads.length}`);

  // Save to file or send to backup service
  require("fs").writeFileSync(
    `leads-backup-${new Date().toISOString().split("T")[0]}.json`,
    JSON.stringify(allLeads, null, 2)
  );

  return allLeads;
}

def segment_leads_by_engagement():
    """Segment leads based on engagement patterns"""

    segments = {
        'hot_prospects': [],      # Recent activity, high engagement
        'warm_leads': [],         # Some activity, needs nurturing
        'cold_prospects': [],     # No recent activity
        'converted': []           # Successful conversions
    }

    # Get all leads with recent activity
    response = requests.get(
        'https://api.buena.ai/api/v2/leads',
        headers={'x-api-key': os.getenv('BUENA_API_KEY')},
        params={
            'limit': 100,
            'sortBy': 'lastContactedAt',
            'sortOrder': 'desc'
        }
    )

    leads = response.json()['data']['leads']

    for lead in leads:
        if lead['status'] == 'converted':
            segments['converted'].append(lead)
        elif lead['status'] == 'replied' and lead['lastContactedAt']:
            # Recent reply = hot prospect
            last_contact = datetime.fromisoformat(lead['lastContactedAt'].replace('Z', '+00:00'))
            if (datetime.now() - last_contact).days <= 7:
                segments['hot_prospects'].append(lead)
            else:
                segments['warm_leads'].append(lead)
        elif lead['status'] == 'contacted':
            segments['warm_leads'].append(lead)
        else:
            segments['cold_prospects'].append(lead)

    # Print segment summary
    for segment, leads in segments.items():
        print(f"{segment.replace('_', ' ').title()}: {len(leads)} leads")

    return segments

function calculateLeadScore(lead) {
  let score = 0;

  // Company size scoring
  if (lead.customFields?.employeeCount) {
    const sizeMap = {
      "1-10": 1,
      "11-50": 2,
      "51-200": 3,
      "201-1000": 4,
      "1000+": 5,
    };
    score += sizeMap[lead.customFields.employeeCount] || 0;
  }

  // Title scoring
  const seniorTitles = ["ceo", "cto", "vp", "director", "head", "senior"];
  if (seniorTitles.some((title) => lead.title?.toLowerCase().includes(title))) {
    score += 3;
  }

  // Engagement scoring
  if (lead.status === "replied") score += 5;
  else if (lead.status === "contacted") score += 2;

  // Source scoring
  if (lead.source === "referral") score += 4;
  else if (lead.source === "linkedin") score += 2;

  // Recency scoring
  if (lead.lastContactedAt) {
    const daysSinceContact = Math.floor(
      (new Date() - new Date(lead.lastContactedAt)) / (1000 * 60 * 60 * 24)
    );

    if (daysSinceContact <= 7) score += 3;
    else if (daysSinceContact <= 30) score += 1;
  }

  return Math.min(score, 20); // Cap at 20
}

async function scoreAllLeads() {
  let page = 1;
  const scoredLeads = [];

  while (true) {
    const response = await fetch(
      `https://api.buena.ai/api/v2/leads?page=${page}&limit=100`,
      {
        headers: { "x-api-key": process.env.BUENA_API_KEY },
      }
    );

    const data = await response.json();
    const leads = data.data.leads;

    if (leads.length === 0) break;

    leads.forEach((lead) => {
      const score = calculateLeadScore(lead);
      scoredLeads.push({ ...lead, score });
    });

    page++;
  }

  // Sort by score descending
  scoredLeads.sort((a, b) => b.score - a.score);

  console.log("Top 10 highest scoring leads:");
  scoredLeads.slice(0, 10).forEach((lead, index) => {
    console.log(
      `${index + 1}. ${lead.firstName} ${lead.lastName} (${
        lead.company
      }) - Score: ${lead.score}`
    );
  });

  return scoredLeads;
}

{
  "error": true,
  "code": "UNAUTHORIZED",
  "message": "Invalid API key",
  "version": "2.0",
  "timestamp": "2024-01-20T15:30:00Z"
}

{
  "error": true,
  "code": "PERMISSION_DENIED",
  "message": "Insufficient permissions for reading leads",
  "version": "2.0",
  "timestamp": "2024-01-20T15:30:00Z",
  "permissionHelp": {
    "required": "leads:read",
    "available": ["linkedin:read"],
    "documentation": "https://docs.buena.ai/authentication"
  }
}

{
  "error": true,
  "code": "VALIDATION_ERROR",
  "message": "Invalid query parameters",
  "version": "2.0",
  "timestamp": "2024-01-20T15:30:00Z",
  "details": {
    "invalidParams": {
      "limit": "Must be between 1 and 100",
      "status": "Must be one of: new, contacted, replied, converted, cold"
    }
  }
}