Push GitHub Developer Leads to Kixie PowerCall

Why Push GitHub Leads into Kixie

Kixie PowerCall is a sales calling platform with a power dialer, SMS automation, and CRM integrations built for B2B sales teams. If your team uses Kixie for developer outreach, you can push GitHub-sourced developer leads directly into Kixie contacts — complete with GitHub signal context, company, and language stack — so reps call developers who just showed buying intent on GitHub.

GitLeads captures developer signals from GitHub (new repo stargazers, keyword mentions in issues and PRs) and pushes enriched profiles via webhook. This guide shows how to route those signals into Kixie as new contacts, optionally via your CRM sync.

Architecture: GitLeads → Webhook → Kixie

GitLeads fires a POST webhook for each new lead. Your endpoint receives the enriched profile, filters for relevant signals, and creates a contact in Kixie via their REST API or through a CRM sync.

• **Direct Kixie REST API** — Create contacts and trigger call tasks via the Kixie contact API
• **Via HubSpot** — Push to HubSpot first; Kixie's native HubSpot integration syncs contacts and enables click-to-call with GitHub lead properties visible in the dialer
• **Via Pipedrive** — Push to Pipedrive persons; Kixie Pipedrive integration syncs and enables power dialer sequences
• **Via Zapier** — Use the Zapier webhook trigger and Kixie Zap to create contacts without custom code

Pushing GitHub Leads to Kixie via REST API

// GitLeads → Kixie PowerCall integration
import express from 'express';

const app = express();
app.use(express.json());

const KIXIE_API_KEY = process.env.KIXIE_API_KEY!;
const KIXIE_BUSINESS_ID = process.env.KIXIE_BUSINESS_ID!;

async function createKixieContact(lead: {
  name?: string;
  email?: string;
  company?: string;
  githubUsername?: string;
  followers?: number;
  topLanguages?: string[];
  bio?: string;
}, signalContext: string) {
  const [firstName, ...rest] = (lead.name || 'Unknown').split(' ');
  const lastName = rest.join(' ') || lead.githubUsername || '';

  const response = await fetch('https://app.kixie.com/api/v1/contact', {
    method: 'POST',
    headers: {
      'x-api-key': KIXIE_API_KEY,
      'x-business-id': KIXIE_BUSINESS_ID,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      firstName,
      lastName,
      email: lead.email,
      company: lead.company,
      notes: [
        `GitHub: https://github.com/${lead.githubUsername}`,
        `Signal: ${signalContext}`,
        `Top Languages: ${lead.topLanguages?.join(', ')}`,
        `Followers: ${lead.followers}`,
      ].join('\n'),
      tags: ['github-lead', 'developer', 'gitleads'],
    }),
  });

  if (!response.ok) throw new Error(`Kixie error: ${await response.text()}`);
  return response.json();
}

app.post('/webhook/gitleads', async (req, res) => {
  const { lead, signal } = req.body;

  // Only push leads with an email (required for Kixie contact creation)
  if (!lead.email) return res.sendStatus(200);

  try {
    await createKixieContact(lead, signal.context || signal.repoName);
  } catch (err) {
    console.error('Kixie push failed:', err);
  }

  res.sendStatus(200);
});

Pushing GitHub Leads to Kixie via HubSpot Sync

If your team already uses Kixie's HubSpot integration, push GitHub leads to HubSpot contacts and Kixie will sync them automatically. This approach gives your reps full GitHub context inside Kixie's power dialer when they call.

// GitLeads → HubSpot → Kixie (via native sync)
app.post('/webhook/gitleads', async (req, res) => {
  const { lead, signal } = req.body;

  if (!lead.email) return res.sendStatus(200);

  // Create HubSpot contact — Kixie syncs automatically
  await fetch('https://api.hubapi.com/crm/v3/objects/contacts', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${process.env.HUBSPOT_TOKEN}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      properties: {
        email: lead.email,
        firstname: lead.name?.split(' ')[0],
        lastname: lead.name?.split(' ').slice(1).join(' '),
        company: lead.company,
        github_username: lead.githubUsername,
        github_signal: signal.context || signal.repoName,
        top_languages: lead.topLanguages?.join(', '),
        github_followers: String(lead.followers || 0),
        leadsource: 'GitLeads',
      },
    }),
  });

  res.sendStatus(200);
});

Filtering GitHub Signals Before Pushing to Kixie

Not all GitHub leads are worth a phone call. Filter before pushing to Kixie to keep your calling queue focused on high-intent developers:

• **Require email** — Kixie is a calling platform, but email is needed for contact creation and follow-up sequencing
• **Filter by follower count** — Developers with 100+ GitHub followers are typically more senior and decision-adjacent
• **Filter by company** — Prioritize developers from identifiable companies over personal accounts
• **Signal type** — Keyword mentions in issues/PRs are higher intent than simple repo stars
• **Language stack match** — Match the lead's top languages to your ICP before queueing a call