Push GitHub Leads to Front: Route Developer Signals to Your Shared Inbox

Front is the shared inbox platform that B2B SaaS teams use to manage customer conversations across email, chat, and social — with full CRM context attached. When a developer stars your repo, mentions a competitor in an issue, or drops a keyword signal on GitHub, that moment of intent is wasted if it sits in a dashboard no one checks. This guide shows you how to push GitLeads signals directly into Front so your team can act on developer intent in the same tool they use for every other customer conversation.

Why Front for GitHub Lead Routing

Most sales tools are built for outbound sequences. Front is different — it is built for conversations. When you route a GitHub signal into Front, it becomes a message thread your team can assign, discuss internally, and respond to with full context. This is ideal for developer-led sales where the first touch is often a reply to an existing conversation rather than a cold sequence enrollment.

• Assign developer signals to specific AEs or CSMs based on territory or account
• Add internal notes with GitHub profile context before reaching out
• See full conversation history if the developer has emailed you before
• Use Front sequences to send personalized follow-ups directly from shared inboxes
• Tag signals by type (stargazer vs keyword mention) for triage prioritization

What GitLeads Captures

GitLeads monitors GitHub continuously for two signal types. Stargazer signals fire when a developer stars a repo you are tracking — your own product repo, a competitor repo, or a category-defining OSS project. Keyword signals fire when your target keywords appear in GitHub Issues, Pull Requests, Discussions, commit messages, or code comments. Each signal includes the developer's GitHub username, public email (when available), bio, company, location, follower count, top languages, and the raw signal context that triggered the capture.

Option A: Webhook → Front Inbound Email Address

Every Front inbox has a unique inbound email address. You can send structured emails to that address programmatically, and Front will create conversations from them. Combine this with a lightweight webhook relay to transform GitLeads webhook payloads into emails routed to your Front inbox.

// Cloudflare Worker: GitLeads webhook → Front inbound email
export default {
  async fetch(request: Request): Promise<Response> {
    const lead = await request.json() as {
      github_username: string;
      email?: string;
      name?: string;
      company?: string;
      bio?: string;
      signal_type: 'stargazer' | 'keyword';
      signal_context: string;
      repo?: string;
      keyword?: string;
      followers: number;
      top_languages: string[];
      profile_url: string;
    };

    const subject = lead.signal_type === 'stargazer'
      ? `New stargazer: ${lead.github_username} (${lead.company ?? 'unknown company'})`
      : `Keyword signal: ${lead.keyword} — ${lead.github_username}`;

    const body = `
GitHub Signal from GitLeads
===========================
Type: ${lead.signal_type}
GitHub: ${lead.profile_url}
Name: ${lead.name ?? 'N/A'}
Email: ${lead.email ?? 'Not public'}
Company: ${lead.company ?? 'N/A'}
Bio: ${lead.bio ?? 'N/A'}
Followers: ${lead.followers}
Top Languages: ${lead.top_languages.join(', ')}

Signal Context:
${lead.signal_context}
${lead.repo ? `Repo: ${lead.repo}` : ''}
${lead.keyword ? `Keyword: ${lead.keyword}` : ''}
    `.trim();

    const FRONT_INBOUND_EMAIL = 'YOUR_INBOX@inbound.frontapp.com';

    await fetch('https://api.resend.com/emails', {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${RESEND_API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        from: 'gitleads-signals@yourdomain.com',
        to: FRONT_INBOUND_EMAIL,
        subject,
        text: body,
      }),
    });

    return new Response('ok', { status: 200 });
  },
};

Option B: GitLeads Webhook → Front API (Create Conversation)

The Front API lets you create conversations and messages programmatically with full metadata. This approach gives you more control over tagging, assignee routing, and custom attributes attached to the conversation.

// Create a Front conversation from a GitLeads signal
async function createFrontConversation(lead: GitLeadsLead) {
  const FRONT_API_TOKEN = process.env.FRONT_API_TOKEN!;
  const FRONT_INBOX_ID = process.env.FRONT_INBOX_ID!;

  const response = await fetch(
    `https://api2.frontapp.com/inboxes/${FRONT_INBOX_ID}/imported_messages`,
    {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${FRONT_API_TOKEN}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        sender: {
          name: lead.name ?? lead.github_username,
          handle: lead.email ?? `${lead.github_username}@github.noreply`,
        },
        to: ['signals@yourteam.com'],
        subject:
          lead.signal_type === 'stargazer'
            ? `[GitLeads] Stargazer: ${lead.github_username} — ${lead.company ?? ''}`
            : `[GitLeads] Keyword "${lead.keyword}": ${lead.github_username}`,
        body: `
<b>GitHub Signal — ${lead.signal_type === 'stargazer' ? 'New Stargazer' : 'Keyword Mention'}</b><br><br>
<b>Profile:</b> <a href="${lead.profile_url}">${lead.github_username}</a><br>
<b>Email:</b> ${lead.email ?? 'Not public'}<br>
<b>Company:</b> ${lead.company ?? 'N/A'}<br>
<b>Followers:</b> ${lead.followers}<br>
<b>Languages:</b> ${lead.top_languages.join(', ')}<br><br>
<b>Signal:</b> ${lead.signal_context}
        `.trim(),
        metadata: { is_inbound: true, created_at: Math.floor(Date.now() / 1000) },
        tags: ['github-signal', lead.signal_type, ...lead.top_languages.slice(0, 2)],
      }),
    }
  );

  return response.json();
}

Option C: GitLeads → Zapier → Front

GitLeads has a native Zapier integration. Set up a Zap: GitLeads (New Lead) → Front (Create Conversation or Send Message). Map signal_context to the message body so your sequence steps can reference the exact GitHub activity that triggered the lead.

Routing Rules in Front

Once signals are flowing into Front, use the rules engine to route intelligently:

• Tag "github-signal" → assign to Sales Development inbox
• Tag "stargazer" AND company matches known enterprise → assign to named AE
• Tag "keyword" AND language is "Go" or "Rust" → route to infrastructure-focused AE
• No email present → label "email-missing" and queue for enrichment
• Follower count > 1000 → route to DevRel or partnership team

Setup Checklist

1. Sign up at gitleads.app (free plan: 50 leads/month)
2. Add repos to track under Tracked Repos
3. Add keywords under Tracked Keywords
4. Go to Integrations → Webhook and paste your relay URL or Zapier webhook URL
5. Test with a sample payload to confirm Front conversations are being created