Push GitHub Leads to Affinity CRM — Relationship Intelligence for Developer Sales

Affinity CRM is built around relationship intelligence — it automatically captures every email, meeting, and interaction to give you a live view of your network. If your go-to-market motion is relationship-driven (common in enterprise developer tools, VC-backed B2B SaaS, and platform companies), GitLeads + Affinity is a natural pairing: GitLeads surfaces GitHub buying signals, and Affinity maps those signals to your existing relationship graph. When a developer who stars your competitor's repo also happens to be a second-degree connection of your VP of Sales, Affinity makes that visible immediately.

What GitLeads Sends to Affinity

When a developer triggers a GitHub signal — starring a tracked repo or matching a keyword in an Issue, PR, or Discussion — GitLeads captures and enriches their profile. The following data is available to push into Affinity:

• Full name and GitHub username
• Public email address (from commit metadata or GitHub profile)
• GitHub profile URL
• Company / organization affiliation
• Location (city, country)
• Follower count, star count, and top programming languages
• Signal type (star vs keyword) and signal context (which repo, which keyword)
• Signal timestamp for sequencing and relationship recency scoring

Integration Method 1: Zapier (No-Code)

The fastest path to GitLeads → Affinity is through Zapier. Affinity has an official Zapier integration that lets you create People and Organizations from any webhook payload.

1. In GitLeads, go to Integrations → Zapier and copy your unique inbound webhook URL.
2. In Zapier, create a new Zap: Trigger = "Webhooks by Zapier" (Catch Hook), paste the GitLeads webhook URL.
3. Add an Action: search Zapier for "Affinity" → select "Create or Update Person". Map name, email, and company from the GitLeads payload.
4. Add a second Action: "Create Note" on the Person record. Use the GitLeads signal context as the note body — e.g., "Starred vercel/next.js on 2026-05-04."
5. Test with a live GitLeads signal and confirm the Person appears in Affinity with the note attached.
6. Turn the Zap on. Every new GitHub signal now creates or enriches an Affinity contact automatically.

Integration Method 2: Affinity API via GitLeads Webhook

For production-grade workflows, use GitLeads' native webhook output with the Affinity REST API directly. This gives you full control over deduplication, list assignment, and custom field mapping.

// GitLeads webhook → Affinity CRM API
export async function POST(request: Request) {
  const lead = await request.json();

  const AFFINITY_API_KEY = process.env.AFFINITY_API_KEY!;
  const LIST_ID = process.env.AFFINITY_LIST_ID!; // your "GitHub Leads" list

  // 1. Create or find the Person
  const personRes = await fetch('https://api.affinity.co/persons', {
    method: 'POST',
    headers: {
      'Authorization': 'Basic ' + btoa(':' + AFFINITY_API_KEY),
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      first_name: lead.name?.split(' ')[0] ?? lead.githubUsername,
      last_name: lead.name?.split(' ').slice(1).join(' ') ?? '',
      emails: lead.email ? [lead.email] : [],
      primary_email: lead.email ?? null,
    }),
  });
  const person = await personRes.json();

  // 2. Add to a list entry
  await fetch(`https://api.affinity.co/lists/${LIST_ID}/list-entries`, {
    method: 'POST',
    headers: {
      'Authorization': 'Basic ' + btoa(':' + AFFINITY_API_KEY),
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ entity_id: person.id }),
  });

  // 3. Create a note with signal context
  await fetch('https://api.affinity.co/notes', {
    method: 'POST',
    headers: {
      'Authorization': 'Basic ' + btoa(':' + AFFINITY_API_KEY),
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      person_ids: [person.id],
      content: `GitLeads Signal: ${lead.signalType} — ${lead.signalContext}
GitHub: ${lead.githubProfileUrl}
Followers: ${lead.followers}
Languages: ${lead.topLanguages?.join(', ')}`,
    }),
  });

  return Response.json({ ok: true, personId: person.id });
}

Integration Method 3: n8n or Make

Both n8n and Make have HTTP request nodes that work with the Affinity API. Build a workflow: GitLeads webhook → parse payload → POST to Affinity Persons → POST to Affinity Notes. This is useful when you want to add extra enrichment steps (Clay, Clearbit, LinkedIn lookup) before the data hits Affinity.

Using Affinity's Relationship Graph with GitHub Signals

What makes Affinity powerful for developer tool sales is its automatic relationship mapping. Once a GitLeads signal creates a Person in Affinity, the platform's AI scans your team's email and calendar history to find existing connections. A developer who starred your competitor's repo today might be a second-degree connection of your CTO or someone your VP of Sales met at a conference last year. GitHub signals give you the trigger; Affinity gives you the warm path in.

GitHub Signal Types That Work Best for Affinity Users

• Competitor repo stars — high-intent developers actively evaluating alternatives
• Your own repo stars — warm inbound leads who found you organically on GitHub
• Keyword mentions in Issues/PRs — developers expressing pain points your product addresses
• Stars on ecosystem repos — developers in your target stack who are not yet aware of your product