Vier LeadGrid API-Integrationen, die dein Team wirklich nutzen wird

LeadGrid ist API-first entwickelt. Jede Aktion, die du in der UI durchführen kannst - ein Dossier erstellen, einen Lead durch eine Phase bewegen, eine Notiz hinzufügen, einen Inhaber(in) zuweisen - ist ein dokumentierter REST-Aufruf. Das ist eine Designentscheidung, kein Nebenmerkmal.

Laut dem Postman 2025 State of the API Report haben 82% der Organisationen einen API-first-Ansatz übernommen. Teams, die auf ihrem Pipeline-Tool aufbauen statt darum herum zu arbeiten, hören auf, dieselbe manuelle Aufgabe zweimal pro Woche zu erledigen.

Hier sind vier Integrationen, die Teams tatsächlich bauen, mit dem dazugehörigen Code.

1. Webformular-Einsendung erstellt automatisch ein Dossier

Das ist die häufigste Integration. Du hast ein Kontaktformular, eine Landingpage oder einen Partner-Empfehlungslink. Jemand füllt es aus. Zurzeit kopiert jemand in deinem Team diese Daten manuell in LeadGrid. Das ist das Erste, was du abschaffen solltest.

Die LeadGrid API lässt dich POST /dossiers aufrufen, um einen neuen Datensatz in einer Pipeline zu erstellen. Ein einfacher Webhook-Empfänger in Node erledigt den Rest:

// Ausgelöst von deinem Formularanbieter (Typeform, Tally, eigenes Formular - egal)
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);
});

Neuer Lead drin. Kein Kopieren und Einfügen. Niemand vergisst es.

2. Phasenänderung sendet eine Slack-Benachrichtigung

Sales-Manager schauen in LeadGrid. Der Rest des Teams schaut in Slack. Wenn ein Deal in die "Verhandlung"-Phase wechselt oder ein Kandidat(in) das "Abschlussgespräch" erreicht, sollte dein Slack-Kanal das wissen, bevor jemand nachfragen muss.

LeadGrid-Webhooks ermöglichen das Abonnieren von dossier.stage_changed-Events. Wenn das ausgelöst wird, leitest du es an deinen Slack Incoming Webhook weiter:

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}* ist jetzt in Phase *${stage}*`,
      }),
    });
  }
 
  res.sendStatus(200);
});

Dreißig Zeilen. Dein Team hört auf zu fragen: "Wo steht der Deal gerade?"

3. Abgeschlossener Deal schreibt einen Datensatz in dein HR- oder ERP-System

Wenn eine Recruitment-Vermittlung abgeschlossen ist oder ein Vertrag unterzeichnet wurde, muss dein Backoffice es wissen. Manuell aus LeadGrid exportieren und in deine HR-Plattform oder dein ERP importieren ist genau die Art von Arbeit, die donnerstagnachmittags zu Fehlern führt.

Abonniere dossier.closed-Events und sende die strukturierten Daten direkt weiter:

if (event === 'dossier.closed') {
  const { id, title, fields } = data;
 
  // Push an dein HR-System - ersetze durch die API deines Anbieters
  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 ist der Auslöser. Dein HR-System empfängt saubere, strukturierte Daten. Keine CSV weit und breit.

4. Nächtlicher Pipeline-Bericht in deinem Posteingang

Das Management möchte jeden Morgen einen Überblick. Was hat sich gestern bewegt? Was steckt fest? Was braucht Aufmerksamkeit?

Ein einfacher Cron-Job, der GET /dossiers?filter=updated_since=yesterday aufruft und das Ergebnis formatiert, deckt das vollständig ab:

// Jeden Morgen um 07:00 Uhr über Cron oder eine geplante Funktion ausführen
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');
 
// Senden über Resend, Postmark oder einen anderen Transaktions-E-Mail-Anbieter
await sendEmail({
  to: 'team@yourcompany.com',
  subject: `Pipeline-Update - ${new Date().toLocaleDateString()}`,
  text: summary || 'Keine Änderungen seit gestern.',
});

Der Postman 2025 State of the API Report stellte außerdem fest, dass 52% der Entwickler 2024 mit Breaking Changes externer Anbieter konfrontiert waren. LeadGrid pflegt versionierte Endpunkte (/v1/), damit deine Integrationen nicht still und leise an einem Dienstagmorgen kaputtgehen.

Das Muster hinter allen vier

Jede dieser Integrationen folgt der gleichen Struktur: auf einen Trigger hören (Webhook oder Zeitplan), die LeadGrid API aufrufen, um Daten zu lesen oder zu schreiben, das Ergebnis woanders hinschicken. Die API-Oberfläche ist konsistent, per einzelnem Bearer-Token authentifiziert und gibt vorhersehbares JSON zurück.

Das ist, was API-first in der Praxis bedeutet. Du baust Workflows nicht innerhalb von LeadGrid. Du baust sie darauf.

Vollständige API-Referenz, Authentifizierungsdokumentation und Webhook-Event-Katalog findest du auf leadgrid.io/docs.

Kostenlos starten →