· 4 min · TextMeFlow Team

WhatsApp-Nachrichten aus Next.js auf Vercel senden

Next.js auf Vercel ist ein gängiger Ort, um WhatsApp-Benachrichtigungen einzurichten: eine Formularübermittlung, eine Bestellbestätigung, ein Update zu einem Support-Ticket. Schwierig ist nicht der HTTP-Aufruf selbst, sondern ihn zuverlässig aus einer Serverless-Funktion auszuführen und Webhooks auf einer Plattform ohne dauerhaften Server zu empfangen. Diese Anleitung behandelt beides.

Eine Nachricht aus einer API-Route senden

Ein Route Handler (die Konvention app/api/*/route.ts) ist der einfachste Ort, um die TextMeFlow-API aufzurufen. Er läuft als kurzlebige Serverless-Funktion, halte die Anfrage also synchron und gib eine Antwort zurück, sobald der API-Aufruf abgeschlossen ist — sende nicht „Fire-and-forget“ ohne await, sonst kann Vercel die Funktion einfrieren, bevor die Anfrage fertig ist.

// app/api/notify/route.ts
export async function POST(req: Request) {
  const { phone, message } = await req.json();

  const res = await fetch('https://api.textmeflow.eu/v1/messages', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.TEXTMEFLOW_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ to: phone, text: message }),
  });

  if (!res.ok) {
    const error = await res.json();
    return Response.json({ error }, { status: res.status });
  }

  return Response.json({ sent: true });
}

Speichere TEXTMEFLOW_API_KEY als Vercel-Umgebungsvariable, nicht im Code — er darf nie im Client-Bundle landen, verwende ihn also nur innerhalb eines Route Handlers oder einer Server Action, niemals in einer 'use client'-Komponente.

Aus einer Server Action aufrufen

Nutzt du bereits den App Router, erspart dir eine Server Action den zusätzlichen Netzwerk-Hop, der entsteht, wenn du deine eigene API-Route vom Client aus aufrufst:

// app/actions.ts
'use server';

export async function sendConfirmation(phone: string, orderId: string) {
  const res = await fetch('https://api.textmeflow.eu/v1/messages', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.TEXTMEFLOW_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      to: phone,
      text: `Deine Bestellung ${orderId} ist bestätigt.`,
    }),
  });

  return res.ok;
}

Rufe sie direkt über die action-Prop eines Formulars auf oder nachdem eine Mutation abgeschlossen ist — kein clientseitiger Fetch, keine API-Route, die du pflegen musst.

Webhooks auf Vercel empfangen

Willst du auch den Zustellstatus oder eingehende Antworten, brauchst du einen Route Handler, der POST-Anfragen von TextMeFlow akzeptiert und die Signatur prüft, bevor er der Payload vertraut. Jede Webhook-Anfrage trägt eine HMAC-Signatur — den genauen Header und die Prüfschritte findest du in der Webhook-Dokumentation. Überspringst du diese Prüfung, kann jeder, der die URL deines Endpunkts findet, gefälschte Zustell-Events senden.

// app/api/webhooks/textmeflow/route.ts
import crypto from 'crypto';

export async function POST(req: Request) {
  const rawBody = await req.text();
  const signature = req.headers.get('x-textmeflow-signature') ?? '';

  const expected = crypto
    .createHmac('sha256', process.env.TEXTMEFLOW_WEBHOOK_SECRET!)
    .update(rawBody)
    .digest('hex');

  if (signature !== expected) {
    return new Response('Invalid signature', { status: 401 });
  }

  const event = JSON.parse(rawBody);
  // handle event.type: message.delivered, message.failed, message.received, ...

  return new Response('ok', { status: 200 });
}

Zwei Serverless-spezifische Details sind hier wichtig. Erstens: Verwende req.json() nicht, bevor du die Signatur geprüft hast — du brauchst die exakten Roh-Bytes, die TextMeFlow signiert hat, und ein geparstes Objekt erneut zu serialisieren kann eine andere Byte-Folge ergeben, die die Prüfung nicht besteht. Zweitens haben Vercel-Funktionen ein Budget für Cold Starts und Ausführungszeit: Halte die Webhook-Verarbeitung schnell (protokollieren, in eine Queue stellen, bestätigen) und lagere langsame Arbeiten wie das Senden einer Folgenachricht oder das Schreiben in eine Datenbank in einen Hintergrundjob oder eine Queue aus, statt die Antwort zu blockieren.

Idempotenz bei Wiederholungen

TextMeFlow wiederholt eine Webhook-Zustellung, wenn dein Endpunkt nicht rechtzeitig antwortet, was bei einer Serverless-Funktion mit Cold Start häufiger passiert als bei einem warmen Server. Jedes Event trägt eine event_id — speichere verarbeitete IDs (und sei es nur in einem KV-Store oder deiner Datenbank) und überspringe Duplikate, damit ein erneut gesendetes message.delivered-Event keine doppelte Benachrichtigung weiter unten in der Kette auslöst. Die Anleitung zu Webhook-Wiederholungen und Idempotenz behandelt das Muster ausführlicher.

Loslegen

Zum Senden brauchst du nur einen API-Schlüssel: Verknüpfe deine WhatsApp-Nummer über den QR-Ablauf, hol den Schlüssel aus dem Dashboard, und der Route Handler oben ist in wenigen Minuten eine funktionierende Integration. Den Verknüpfungsschritt findest du in der Einstiegsanleitung, und dann probiere TextMeFlow kostenlos aus — der kostenlose Tarif enthält 50 Nachrichten pro Monat, um den ganzen Ablauf zu testen, bevor du dich festlegst.

Selbst WhatsApp-Nachrichten per API senden?

Für immer gratis bis 50 Nachrichten/Monat. QR scannen und in 5 Minuten die erste Nachricht senden.

Für immer gratis