Vier LeadGrid API-integraties die je team echt gaat gebruiken

LeadGrid is API-first gebouwd. Elke actie die je in de UI kunt uitvoeren - een dossier aanmaken, een lead door een fase bewegen, een notitie toevoegen, een eigenaar toewijzen - is een gedocumenteerde REST-aanroep. Dat is een ontwerpkeuze, geen bijzaak.

Volgens het Postman 2025 State of the API Report heeft 82% van de organisaties een API-first aanpak omarmd. Teams die bovenop hun pipeline-tool bouwen in plaats van er omheen, zijn de teams die stoppen met dezelfde handmatige taak twee keer per week te herhalen.

Hier zijn vier integraties die teams echt bouwen, inclusief de code.

1. Webformulier-inzending maakt automatisch een dossier aan

Dit is de meest voorkomende. Je hebt een contactformulier, een landingspagina of een partnerverwijzingslink. Iemand vult het in. Nu kopieert iemand van je team die gegevens handmatig naar LeadGrid. Dat is het eerste wat je moet afschaffen.

De LeadGrid API laat je POST /dossiers aanroepen om een nieuw record in een pipeline aan te maken. Een simpele webhook-ontvanger in Node doet de rest:

// Getriggerd door je formulierprovider (Typeform, Tally, eigen formulier - maakt niet uit)
app.post('/webhook/new-lead', async (req, res) => {
  const { name, email, company } = req.body;
 
  await fetch('https://api.leadgrid.io/v1/dossiers', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.LEADGRID_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      pipelineId: 'your-pipeline-id',
      title: `${name} - ${company}`,
      fields: { email, company },
    }),
  });
 
  res.sendStatus(200);
});

Nieuwe lead binnen. Geen kopieer-plak. Niemand die het vergeet.

2. Fasewijziging verstuurt een Slack-melding

Salesmanagers kijken in LeadGrid. De rest van het team kijkt in Slack. Als een deal naar "Onderhandeling" gaat of een kandidaat de "Eindgesprek"-fase bereikt, moet je Slack-kanaal dat weten voordat iemand ernaar hoeft te vragen.

LeadGrid-webhooks laten je abonneren op dossier.stage_changed-events. Als dat vuurt, stuur je het door naar je Slack incoming webhook:

app.post('/webhook/leadgrid-events', async (req, res) => {
  const { event, data } = req.body;
 
  if (event === 'dossier.stage_changed') {
    const { title, stage, pipelineId } = data;
 
    await fetch(process.env.SLACK_WEBHOOK_URL, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        text: `Pipeline-update: *${title}* verplaatst naar *${stage}*`,
      }),
    });
  }
 
  res.sendStatus(200);
});

Dertig regels. Je team stopt met vragen: "waar staat die deal nu eigenlijk?"

3. Gesloten deal stuurt een record naar je HR- of ERP-systeem

Als een recruitment-plaatsing afgerond is of een salescontract getekend, moet je backoffice dat weten. Handmatig exporteren uit LeadGrid en importeren in je HR-platform of ERP is precies het soort werk dat donderdagmiddag tot fouten leidt.

Abonneer je op dossier.closed-events en stuur de gestructureerde data direct door:

if (event === 'dossier.closed') {
  const { id, title, fields } = data;
 
  // Push naar je HR-systeem - vervang door de API van jouw leverancier
  await fetch('https://api.your-hr-tool.com/employees', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.HR_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      name: fields.candidateName,
      email: fields.email,
      startDate: fields.startDate,
      role: fields.jobTitle,
    }),
  });
}

LeadGrid is de trigger. Je HR-systeem ontvangt schone, gestructureerde data. Geen CSV te bekennen.

4. Nachtelijk pipeline-rapport in je inbox

Management wil elke ochtend een snapshot. Wat is er gisteren bewogen? Wat staat stil? Wat heeft aandacht nodig?

Een simpele cron-job die GET /dossiers?filter=updated_since=yesterday aanroept en het resultaat opmaakt, dekt dit volledig:

// Elke ochtend om 07:00 draaien via cron of een geplande functie
const yesterday = new Date(Date.now() - 86400000).toISOString();
 
const response = await fetch(
  `https://api.leadgrid.io/v1/dossiers?updated_since=${yesterday}`,
  { headers: { 'Authorization': `Bearer ${process.env.LEADGRID_API_KEY}` } }
);
 
const { dossiers } = await response.json();
const summary = dossiers.map(d => `- ${d.title}: ${d.stage}`).join('\n');
 
// Verstuur via Resend, Postmark of een andere transactionele e-mailprovider
await sendEmail({
  to: 'team@yourcompany.com',
  subject: `Pipeline-update - ${new Date().toLocaleDateString()}`,
  text: summary || 'Geen wijzigingen sinds gisteren.',
});

Het Postman 2025 State of the API Report concludeerde ook dat 52% van de ontwikkelaars in 2024 te maken had met breaking changes van externe leveranciers. LeadGrid onderhoudt versioned endpoints (/v1/) zodat je integraties niet stilletjes op een dinsdagochtend stukgaan.

Het patroon achter alle vier

Elke integratie volgt dezelfde structuur: luister naar een trigger (webhook of schema), roep de LeadGrid API aan om data te lezen of schrijven, en stuur het resultaat ergens anders naartoe. Het API-oppervlak is consistent, geverifieerd met één bearer token en retourneert voorspelbare JSON.

Dat is wat API-first in de praktijk betekent. Je bouwt workflows niet binnen LeadGrid. Je bouwt ze bovenop.

Volledige API-referentie, authenticatiedocumentatie en webhook-eventcatalogus vind je op leadgrid.io/docs.

Gratis starten →