Automate Investor Outreach 🚀

# Email deliverability best practices
import sendgrid
from sendgrid.helpers.mail import Mail

class DeliverabilityManager:
    def __init__(self):
        self.sg = sendgrid.SendGridAPIClient(api_key=os.environ.get('SENDGRID_API_KEY'))
        self.daily_limit = self.get_current_daily_limit()
        self.sent_today = self.get_sent_count_today()
    
    def can_send_email(self) -> bool:
        """Check if we're within daily sending limits"""
        return self.sent_today < self.daily_limit
    
    def get_current_daily_limit(self) -> int:
        """Gradual warm-up schedule"""
        days_since_start = (datetime.now() - self.start_date).days
        
        if days_since_start < 7:
            return 10  # Week 1: 10 emails/day
        elif days_since_start < 14:
            return 25  # Week 2: 25 emails/day
        elif days_since_start < 21:
            return 50  # Week 3: 50 emails/day
        else:
            return 100  # Week 4+: 100 emails/day
    
    def send_with_tracking(self, to_email, subject, body):
        """Send with proper headers and tracking"""
        message = Mail(
            from_email='founders@yourstartup.com',
            to_emails=to_email,
            subject=subject,
            html_content=body
        )
        
        # Enable click/open tracking
        message.tracking_settings = TrackingSettings(
            click_tracking=ClickTracking(enable=True),
            open_tracking=OpenTracking(enable=True)
        )
        
        # Custom headers to improve deliverability
        message.add_header('X-Priority', '3')
        message.add_header('X-MSMail-Priority', 'Normal')
        
        response = self.sg.send(message)
        self.sent_today += 1
        
        return response

// LinkedIn automation with rate limiting
import axios from 'axios';
import { setTimeout } from 'timers/promises';

class LinkedInAutomation {
  private actionsToday: number = 0;
  private readonly MAX_ACTIONS_PER_DAY = 25;
  private readonly MIN_DELAY_MS = 30000; // 30 seconds
  private readonly MAX_DELAY_MS = 90000; // 90 seconds

  async sendConnectionRequest(
    profileUrl: string,
    personalizedNote: string
  ): Promise<void> {
    // Check daily limit
    if (this.actionsToday >= this.MAX_ACTIONS_PER_DAY) {
      throw new Error('Daily LinkedIn action limit reached');
    }

    // Random delay to avoid detection
    const delay =
      Math.random() * (this.MAX_DELAY_MS - this.MIN_DELAY_MS) +
      this.MIN_DELAY_MS;
    await setTimeout(delay);

    // Use Sales Navigator API (not scraping)
    await axios.post(
      'https://api.linkedin.com/v2/invitations',
      {
        invitee: { profileUrl },
        message: personalizedNote,
      },
      {
        headers: {
          Authorization: `Bearer ${process.env.LINKEDIN_ACCESS_TOKEN}`,
        },
      }
    );

    this.actionsToday++;
    console.log(`Sent connection request (${this.actionsToday}/${this.MAX_ACTIONS_PER_DAY} today)`);
  }

  resetDailyCounter(): void {
    // Call this at midnight
    this.actionsToday = 0;
  }
}

# Cross-reference multiple data sources
import requests
from datetime import datetime, timedelta

def verify_investor_current_firm(investor_name: str, firm_name: str) -> dict:
    """Cross-check investor's current firm across multiple sources"""
    
    # Source 1: Crunchbase
    cb_data = fetch_crunchbase(investor_name)
    cb_firm = cb_data.get('current_organization')
    cb_updated = cb_data.get('last_updated')
    
    # Source 2: LinkedIn (via API or scraping)
    linkedin_data = fetch_linkedin(investor_name)
    linkedin_firm = linkedin_data.get('current_company')
    linkedin_updated = linkedin_data.get('profile_updated')
    
    # Source 3: Firm website team page
    firm_website = f"https://{firm_name.lower().replace(' ', '')}.com/team"
    firm_team_page = requests.get(firm_website).text
    on_firm_website = investor_name.lower() in firm_team_page.lower()
    
    # Determine most reliable source
    sources_agree = (cb_firm == firm_name and linkedin_firm == firm_name)
    data_is_fresh = (
        datetime.now() - datetime.fromisoformat(cb_updated) < timedelta(days=90)
    )
    
    return {
        'investor_name': investor_name,
        'claimed_firm': firm_name,
        'crunchbase_firm': cb_firm,
        'linkedin_firm': linkedin_firm,
        'on_firm_website': on_firm_website,
        'sources_agree': sources_agree,
        'data_is_fresh': data_is_fresh,
        'confidence': 'high' if (sources_agree and data_is_fresh) else 'low',
        'last_verified': datetime.now().isoformat()
    }

# Usage: Skip outreach if confidence is low
verification = verify_investor_current_firm('Sarah Chen', 'Accel Partners')
if verification['confidence'] == 'low':
    print(f"Skipping {investor_name} - stale data (last verified: {verification['last_verified']})")

# CAN-SPAM compliant email template
def build_compliant_email(investor_email: str, subject: str, body: str) -> str:
    """Add required CAN-SPAM elements to email"""
    
    # Generate unique unsubscribe token
    unsubscribe_token = generate_unsubscribe_token(investor_email)
    unsubscribe_url = f"https://yourstartup.com/unsubscribe?token={unsubscribe_token}"
    
    # Add footer with required elements
    footer = f"""
    <hr>
    <p style="font-size: 11px; color: #666;">
    You're receiving this because you're a VC investor in B2B SaaS.<br>
    If you'd prefer not to receive these emails, <a href="{unsubscribe_url}">unsubscribe here</a>.<br><br>
    
    YourStartup Inc.<br>
    123 Main Street<br>
    San Francisco, CA 94105
    </p>
    """
    
    compliant_body = body + footer
    
    return compliant_body

# Unsubscribe handler
def handle_unsubscribe(token: str):
    """Process unsubscribe request"""
    investor_email = verify_unsubscribe_token(token)
    
    # Add to suppression list
    add_to_suppression_list(investor_email)
    
    # Remove from all active sequences
    stop_all_sequences(investor_email)
    
    # Update CRM
    update_crm_status(investor_email, status='unsubscribed')
    
    # Log for compliance
    log_unsubscribe(investor_email, timestamp=datetime.now())
    
    return {"status": "unsubscribed", "email": investor_email}

# Check suppression list before sending
def is_suppressed(email: str) -> bool:
    """Check if email is on suppression list"""
    suppression_list = load_suppression_list()
    return email in suppression_list

// Detect and classify investor responses
import { gmail_v1, google } from 'googleapis';
import Anthropic from '@anthropic-ai/sdk';

interface EmailResponse {
  messageId: string;
  from: string;
  subject: string;
  body: string;
  isAutoReply: boolean;
  classification?: 'interested' | 'not_interested' | 'ask_later' | 'other';
}

class ResponseHandler {
  private gmail: gmail_v1.Gmail;
  private anthropic: Anthropic;

  constructor() {
    const auth = new google.auth.GoogleAuth({
      scopes: ['https://www.googleapis.com/auth/gmail.readonly'],
    });
    this.gmail = google.gmail({ version: 'v1', auth });
    this.anthropic = new Anthropic({
      apiKey: process.env.ANTHROPIC_API_KEY!,
    });
  }

  async checkForReplies(investorEmail: string): Promise<EmailResponse[]> {
    // Search for replies from investor
    const response = await this.gmail.users.messages.list({
      userId: 'me',
      q: `from:${investorEmail} is:unread`,
    });

    const messages = response.data.messages || [];
    const replies: EmailResponse[] = [];

    for (const message of messages) {
      const fullMessage = await this.gmail.users.messages.get({
        userId: 'me',
        id: message.id!,
        format: 'full',
      });

      const headers = fullMessage.data.payload?.headers || [];
      const body = this.extractBody(fullMessage.data);

      // Check if auto-reply
      const isAutoReply = this.isAutoReply(headers);

      if (!isAutoReply) {
        // Classify response with AI
        const classification = await this.classifyResponse(body);

        replies.push({
          messageId: message.id!,
          from: investorEmail,
          subject: this.getHeader(headers, 'Subject'),
          body,
          isAutoReply: false,
          classification,
        });

        // Stop follow-up sequence
        await this.stopSequence(investorEmail);
      }
    }

    return replies;
  }

  private isAutoReply(headers: any[]): boolean {
    // Check for auto-reply headers
    const autoReplyHeaders = [
      'X-Autoreply',
      'X-Autorespond',
      'Auto-Submitted',
      'X-Auto-Response-Suppress',
    ];

    return headers.some((header) =>
      autoReplyHeaders.includes(header.name || '')
    );
  }

  private async classifyResponse(body: string): Promise<string> {
    const response = await this.anthropic.messages.create({
      model: 'claude-3-5-sonnet-20241022',
      max_tokens: 256,
      messages: [
        {
          role: 'user',
          content: `Classify this investor response:

"${body}"

Categories:
- interested: wants to meet, asks for more info, positive signal
- not_interested: clear no, not a fit, not investing now
- ask_later: timing is off, check back in X months
- other: unclear or needs human review

Output JSON: {classification: string, confidence: float, reasoning: string}`,
        },
      ],
    });

    const content = response.content[0];
    if (content.type !== 'text') throw new Error('Invalid response');
    const result = JSON.parse(content.text);

    return result.classification;
  }

  private async stopSequence(investorEmail: string): Promise<void> {
    // Remove from all active email sequences
    // Update CRM with response received
    console.log(`Stopped sequence for ${investorEmail}`);
  }

  private getHeader(headers: any[], name: string): string {
    const header = headers.find((h) => h.name === name);
    return header?.value || '';
  }

  private extractBody(message: any): string {
    // Extract email body (simplified)
    const parts = message.payload?.parts || [];
    const textPart = parts.find((p: any) => p.mimeType === 'text/plain');
    return textPart?.body?.data
      ? Buffer.from(textPart.body.data, 'base64').toString()
      : '';
  }
}

// Usage
const handler = new ResponseHandler();
const replies = await handler.checkForReplies('schen@accel.com');
console.log(`Found ${replies.length} real replies (filtered out auto-replies)`);