Push GitHub Leads to Grain

What Is Grain and Why Connect It to GitHub Leads

Grain is a meeting intelligence platform that records, transcribes, and highlights sales calls. It automatically syncs call recordings, notes, and AI-generated summaries to your CRM. When you connect GitLeads to Grain, your sales team gets GitHub context alongside every call — knowing that the prospect starred your competitor's repo last week, or that they mentioned your technology in a GitHub issue, transforms cold outreach into warm conversations.

GitLeads captures intent signals from GitHub — stargazers on tracked repos, keyword mentions in issues/PRs/discussions/code — and delivers enriched lead profiles. Grain is where your sales team works during and after calls. The connection between the two means your reps know exactly why a developer is worth calling before they pick up the phone.

Integration Architecture: GitLeads to Grain

Grain does not expose a direct lead ingestion API, so the integration typically flows through a shared CRM (HubSpot or Salesforce) or via Zapier/n8n. Here are the two main patterns:

Pattern 1: GitLeads to HubSpot to Grain

This is the most common setup. GitLeads pushes enriched leads to HubSpot as contacts. Grain syncs automatically with HubSpot, pulling contact records into meeting notes. When a rep records a call with a GitHub lead, Grain shows the HubSpot contact data — including the GitLeads signal context written into custom properties.

1. In GitLeads, connect your HubSpot workspace as a destination
2. Map GitLeads lead fields to HubSpot contact properties: GitHub username, signal type, signal context, top languages
3. Create a HubSpot custom property "GitHub Signal" to store the signal context string
4. In Grain, connect your HubSpot workspace — Grain will auto-link contacts to recorded calls
5. When your rep records a call, Grain will display the HubSpot contact card including the GitHub signal

Pattern 2: GitLeads Webhook to n8n to Grain

If you want GitHub signal to appear directly in Grain meeting notes, use a webhook automation:

// n8n webhook node receiving GitLeads signal
// Then uses Grain API to annotate or look up contact

const grainApiBase = 'https://api.grain.com';

// GitLeads sends webhook payload:
// {
//   "name": "Jane Smith",
//   "email": "jane@example.com",
//   "github_username": "janesmith",
//   "signal_type": "stargazer",
//   "signal_context": "Starred your-org/your-repo",
//   "bio": "Platform engineer at Acme",
//   "top_languages": ["Go", "TypeScript"],
//   "company": "Acme Corp"
// }

async function addGrainContactNote(
  grainToken: string,
  email: string,
  githubSignal: string
) {
  // Find contact in Grain by email
  const contactRes = await fetch(
    `${grainApiBase}/v1/contacts?email=${encodeURIComponent(email)}`,
    { headers: { Authorization: `Bearer ${grainToken}` } }
  );
  const contacts = await contactRes.json();

  if (contacts.data?.length > 0) {
    const contactId = contacts.data[0].id;
    // Add GitHub signal as a note on the contact
    await fetch(`${grainApiBase}/v1/contacts/${contactId}/notes`, {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${grainToken}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        content: `GitHub Signal: ${githubSignal}`,
      }),
    });
  }
}

What GitHub Signal Context to Surface in Grain

• Signal type — whether the lead starred your repo, a competitor repo, or mentioned a keyword in an issue
• Signal context — the exact repo starred or keyword mentioned; this is the conversation starter
• Top languages — tells your rep what technical background the developer has before the call
• GitHub bio and company — often reveals role and organization before you even look them up
• Followers count — a proxy for influence; high-follower developers are also community influencers
• Public repos count — indicates an active open source contributor vs. a passive observer

Use Cases: Why Sales Teams Use This Integration

• Pre-call research automation — instead of manually searching LinkedIn before a call, the rep sees GitHub signal context automatically in Grain
• Competitive intelligence — if a lead starred a competitor repo before starring yours, Grain will surface this during call notes
• Follow-up personalization — after a call, reps reference the GitHub signal in follow-up emails
• DevRel and community calls — developer relations teams use this to know which community members are active contributors vs. passive users
• Deal context for AEs — when an AE takes over from SDR, the GitHub signal context in Grain provides immediate technical background

Setting Up the GitLeads to Grain Integration

1. In GitLeads, set up tracked repos or keyword signals for your target developer community
2. Choose your integration path: HubSpot sync (recommended) or webhook to n8n/Zapier
3. If using HubSpot: connect GitLeads to HubSpot, then connect Grain to the same HubSpot workspace
4. If using webhook: configure a GitLeads outbound webhook, set up n8n/Zapier to receive it, then call the Grain API
5. Test with a small batch of leads and verify the GitHub signal context appears in Grain contact notes
6. Train your sales team on interpreting GitHub signals: starred repos = awareness, keyword mentions = active evaluation