Push GitHub Leads to Outreach.io — Developer Sequence Automation

Outreach.io is the most widely deployed sales engagement platform in mid-market and enterprise B2B. Its sequence engine, call logging, and revenue intelligence layer make it the system of record for SDR and AE workflows at developer tool companies. Connecting GitLeads to Outreach.io lets you turn GitHub developer intent signals — new repo stars, keyword mentions in issues and PRs — into Outreach prospects enrolled in sequences automatically, without manual list imports or CSV uploads.

Integration Architecture

1. GitLeads captures the GitHub signal and enriches the lead profile.
2. GitLeads fires a webhook to Zapier or Make with the enriched lead payload.
3. Zapier/Make creates or updates the prospect in Outreach.io via the Outreach API.
4. The prospect is enrolled in a pre-configured sequence targeting GitHub-sourced developer leads.
5. Signal context (e.g., "Starred competitor vercel/next.js") is written to a custom prospect field in Outreach for SDR personalization.

Setting Up via Zapier

1. In GitLeads, go to Settings → Integrations → Zapier and copy your webhook URL.
2. In Zapier, create a new Zap with "Webhooks by Zapier" as the trigger.
3. Add an Outreach.io action: "Create or Update Prospect". Map GitLeads fields to Outreach prospect attributes.
4. Add a second Outreach action: "Add Prospect to Sequence". Select your GitHub developer sequence.
5. Test with a live GitLeads signal, then activate.

Direct API Integration

const OUTREACH_API = 'https://api.outreach.io/api/v2';

async function pushLeadToOutreach(lead: any, sequenceId: string) {
  const headers = {
    'Authorization': `Bearer ${process.env.OUTREACH_API_KEY}`,
    'Content-Type': 'application/vnd.api+json',
  };

  // 1. Create prospect
  const prospectRes = await fetch(`${OUTREACH_API}/prospects`, {
    method: 'POST',
    headers,
    body: JSON.stringify({
      data: {
        type: 'prospect',
        attributes: {
          firstName: lead.name?.split(' ')[0],
          lastName: lead.name?.split(' ').slice(1).join(' '),
          emails: lead.email ? [lead.email] : [],
          custom1: lead.signal_context,
          custom2: lead.top_languages?.join(', '),
        },
      },
    }),
  });
  const { data: prospect } = await prospectRes.json();

  // 2. Enroll in sequence
  await fetch(`${OUTREACH_API}/sequenceStates`, {
    method: 'POST',
    headers,
    body: JSON.stringify({
      data: {
        type: 'sequenceState',
        attributes: { state: 'active' },
        relationships: {
          sequence: { data: { type: 'sequence', id: sequenceId } },
          prospect: { data: { type: 'prospect', id: prospect.id } },
        },
      },
    }),
  });
}

Sequence Design for GitHub Developer Leads

• Step 1 (Day 0, Email): Short personal email referencing the GitHub signal. 3-4 sentences max with specific CTA.
• Step 2 (Day 3, Email): Value-forward follow-up with a relevant case study or technical benchmark.
• Step 3 (Day 7, LinkedIn): Connection request with a note referencing their GitHub activity.
• Step 4 (Day 14, Email): Breakup email — "Worth a quick chat or should I close this out?"

Signal Context for Personalization at Scale

Store the GitLeads signal context in a custom prospect field (e.g., custom1) and reference it in your sequence templates using Outreach's dynamic variable syntax. This lets every email reference the exact GitHub activity that triggered the lead — no manual personalization required, but the recipient experiences warm, relevant outreach.