Push GitHub Developer Leads to June

Why Route GitHub Leads to June

June is product analytics built for B2B SaaS — company-level metrics, activation funnels, feature adoption. If your ICP is developers, the gap in June is pre-signup intent data: you can track users once they are in your product, but not before. GitLeads fills that gap. It captures developer intent signals from GitHub (repo stars, keyword mentions) and pushes them as identify + track events into June, letting you see who is interested before they ever create an account.

The result: your June workspace includes a pre-signup cohort of developers who showed GitHub intent signals. You can measure which signals correlate with eventual conversion, build outreach sequences triggered by activation patterns, and give sales full context on every developer in your funnel.

How It Works: GitLeads → June

GitLeads fires a webhook payload for every new lead. You use a small serverless function (or n8n/Make/Zapier) to transform that payload into June API calls: one identify call to create the user, one track call to record the signal event. June then groups users into companies automatically.

// Vercel Edge Function: GitLeads webhook → June
import { NextRequest, NextResponse } from 'next/server';
import crypto from 'crypto';

interface GitLeadsPayload {
  event: string;
  lead: {
    github_username: string;
    name?: string;
    email?: string;
    company?: string;
    location?: string;
    bio?: string;
    signal_type: 'stargazer' | 'keyword';
    signal_context: string;
    repo_name?: string;
    keyword?: string;
  };
}

const JUNE_API_KEY = process.env.JUNE_WRITE_KEY!;
const JUNE_BASE = 'https://api.june.so/sdk';

async function juneRequest(path: string, body: object) {
  const res = await fetch(`${JUNE_BASE}${path}`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Basic ${Buffer.from(`${JUNE_API_KEY}:`).toString('base64')}`,
    },
    body: JSON.stringify(body),
  });
  if (!res.ok) throw new Error(`June API error: ${res.status}`);
  return res.json();
}

export async function POST(req: NextRequest) {
  const sig = req.headers.get('x-gitleads-signature');
  const rawBody = await req.text();

  // Verify HMAC signature
  const expected = crypto
    .createHmac('sha256', process.env.GITLEADS_WEBHOOK_SECRET!)
    .update(rawBody)
    .digest('hex');
  if (sig !== `sha256=${expected}`) {
    return NextResponse.json({ error: 'Invalid signature' }, { status: 401 });
  }

  const payload: GitLeadsPayload = JSON.parse(rawBody);
  const { lead } = payload;
  const userId = `github:${lead.github_username}`;

  // Identify the user in June
  await juneRequest('/identify', {
    userId,
    traits: {
      name: lead.name ?? lead.github_username,
      email: lead.email,
      username: lead.github_username,
      company: lead.company,
      location: lead.location,
      bio: lead.bio,
      profile_url: `https://github.com/${lead.github_username}`,
      source: 'gitleads_github',
    },
    context: { source: 'gitleads' },
  });

  // Track the signal event
  await juneRequest('/track', {
    userId,
    event: lead.signal_type === 'stargazer'
      ? 'GitHub Repo Starred'
      : 'GitHub Keyword Signal',
    properties: {
      signal_type: lead.signal_type,
      signal_context: lead.signal_context,
      repo_name: lead.repo_name,
      keyword: lead.keyword,
      source: 'gitleads',
    },
    context: { source: 'gitleads' },
  });

  return NextResponse.json({ ok: true });
}

Setting Up the June Integration

1. Create a June workspace at june.so and copy your Write Key from Settings → API Keys
2. In GitLeads dashboard, go to Integrations → Webhook and add your serverless function URL
3. Deploy the function above with JUNE_WRITE_KEY and GITLEADS_WEBHOOK_SECRET as environment variables
4. Add tracked repos or keywords in GitLeads to start capturing signals
5. In June, create a "GitHub Signal" segment: users with event "GitHub Repo Starred" or "GitHub Keyword Signal"
6. Build a funnel: GitHub Signal → Signed Up → Activated — measure conversion by signal type

Useful June Analyses for GitHub Lead Data

• Signal-to-signup conversion: what % of GitHub signals eventually create an account?
• Company-level intent: which companies have 3+ developers showing GitHub signals?
• Signal velocity: are certain repos/keywords producing higher-converting leads?
• Cohort analysis: do keyword signal leads activate faster than stargazer leads?
• Lead scoring: combine June company traits with GitLeads signal recency in Clay

No-Code Alternative: GitLeads → n8n → June

If you prefer no-code, use n8n with a Webhook trigger node → HTTP Request node to the June /identify and /track endpoints. The data flow is identical; no serverless function required. The GitLeads webhook sends JSON with the same lead fields, so the n8n mapping is straightforward.