· 3 min · TextMeFlow Team

WhatsApp-Nachricht senden mit Go (Golang) über die API

Die Standardbibliothek von Go bringt alles mit, was du für die Kommunikation mit der TextMeFlow API brauchst — kein SDK, keine Codegenerierung, kein HTTP-Client von Drittanbietern. net/http, encoding/json und crypto/hmac reichen aus, um Nachrichten zu senden, Rate Limits zu behandeln und eingehende Webhooks zu verifizieren. Dieser Leitfaden geht alle drei Punkte durch, mit Code, den du direkt in einen Service übernehmen kannst.

Bevor du anfängst

  1. Erstelle ein kostenloses TextMeFlow-Konto — 50 Nachrichten pro Monat, für immer, ohne Kreditkarte und ohne Meta-Business-Verifizierung.
  2. Scanne den QR-Code im Portal mit dem Telefon, auf dem die WhatsApp-Nummer eingerichtet ist, von der du senden möchtest.
  3. Kopiere deinen API-Schlüssel aus dem Dashboard.

Die vollständige Endpunkt-Referenz findest du unter /de/docs/api; alles Folgende bezieht sich auf POST /v1/messages.

Eine Nachricht senden

Ein minimaler Client besteht aus einem Struct, einem serialisierten Body und einem Bearer-Token:

package textmeflow

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
)

type SendRequest struct {
	To      string `json:"to"`
	Text    string `json:"text,omitempty"`
	MediaURL string `json:"media_url,omitempty"`
}

type SendResponse struct {
	MessageID string `json:"message_id"`
	Status    string `json:"status"`
}

func Send(apiKey string, msg SendRequest) (*SendResponse, error) {
	body, err := json.Marshal(msg)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest(http.MethodPost, "https://api.textmeflow.eu/v1/messages", bytes.NewReader(body))
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer "+apiKey)

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusAccepted {
		return nil, fmt.Errorf("textmeflow: unexpected status %d", resp.StatusCode)
	}

	var out SendResponse
	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
		return nil, err
	}
	return &out, nil
}

Halte das Feld To im E.164-Format (+ und Ländervorwahl) — alles andere wird mit einem 422 abgelehnt. MediaURL ist optional und akzeptiert jede öffentlich erreichbare Datei bis 100 MB (Bild, PDF, Sprachnachricht); für eine reine Textnachricht lässt du es leer. Eine 202-Antwort bedeutet, dass die Nachricht in der Warteschlange liegt, nicht dass sie schon zugestellt ist — mit der message_id aus der Antwort prüfst du später den tatsächlichen Status.

Bei 429 erneut versuchen, ohne die API zu bombardieren

TextMeFlow begrenzt bewusst die Rate — ein Burst-Limit pro Minute und eine Stundenobergrenze je nach Tarif, beschrieben auf der Seite zu den Rate Limits. Der Body einer 429-Antwort enthält reason (burst_exceeded oder hourly_exceeded) und retry_after_seconds, du musst die Wartezeit also nicht raten:

func SendWithRetry(apiKey string, msg SendRequest, maxAttempts int) (*SendResponse, error) {
	var last error
	for attempt := 1; attempt <= maxAttempts; attempt++ {
		body, _ := json.Marshal(msg)
		req, _ := http.NewRequest(http.MethodPost, "https://api.textmeflow.eu/v1/messages", bytes.NewReader(body))
		req.Header.Set("Content-Type", "application/json")
		req.Header.Set("Authorization", "Bearer "+apiKey)

		resp, err := http.DefaultClient.Do(req)
		if err != nil {
			return nil, err
		}

		if resp.StatusCode == http.StatusTooManyRequests {
			var rl struct {
				Reason            string `json:"reason"`
				RetryAfterSeconds int    `json:"retry_after_seconds"`
			}
			json.NewDecoder(resp.Body).Decode(&rl)
			resp.Body.Close()
			last = fmt.Errorf("rate limited: %s", rl.Reason)
			time.Sleep(time.Duration(rl.RetryAfterSeconds*attempt) * time.Second)
			continue
		}

		defer resp.Body.Close()
		var out SendResponse
		if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
			return nil, err
		}
		return &out, nil
	}
	return nil, fmt.Errorf("gave up after %d attempts: %w", maxAttempts, last)
}

Fünf Versuche reichen in der Praxis völlig aus. Wenn du die empfohlene Wartezeit mit der Versuchsnummer multiplizierst, kommt zu dem, was die API dir schon mitgeteilt hat, ein Sicherheitspuffer hinzu — ohne auf eine feste sleep(5)-Schleife zurückzufallen, die entweder Zeit verschwendet oder zu früh erneut versucht. Die ausführliche Abwägung, ob du GET /v1/messages/{id} abfragen oder beim Zustellstatus einfach auf Webhooks vertrauen solltest, findest du im Leitfaden zu Rate Limits und Nachrichtenstatus.

Antworten empfangen: ein signierter Webhook-Handler

Jede eingehende WhatsApp-Antwort wird per POST an den Endpunkt gesendet, den du unter /admin/webhook konfigurierst, signiert mit X-TextMeFlow-Signature: sha256=<hex> — einem HMAC-SHA256 des rohen Request-Bodys mit dem Secret, das dir nur einmal bei der Erstellung angezeigt wird. Das Paket crypto/hmac von Go bringt ein Equal mit konstanter Laufzeit mit, du musst also keinen eigenen timing-sicheren Vergleich schreiben:

func webhookHandler(secret []byte) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		raw, err := io.ReadAll(r.Body)
		if err != nil {
			http.Error(w, "bad request", http.StatusBadRequest)
			return
		}

		mac := hmac.New(sha256.New, secret)
		mac.Write(raw)
		expected := "sha256=" + hex.EncodeToString(mac.Sum(nil))
		received := r.Header.Get("X-TextMeFlow-Signature")

		if !hmac.Equal([]byte(expected), []byte(received)) {
			http.Error(w, "invalid signature", http.StatusUnauthorized)
			return
		}

		eventID := r.Header.Get("X-TextMeFlow-Event-Id")
		// INSERT ... ON CONFLICT (event_id) DO NOTHING, danach asynchron verarbeiten.
		w.WriteHeader(http.StatusOK)
	}
}

Lies den Body mit io.ReadAll, bevor Router-Middleware ihn neu kodiert — einen neu serialisierten JSON-Body statt der Original-Bytes zu hashen, ist der häufigste Grund, warum diese Prüfung unbemerkt fehlschlägt. X-TextMeFlow-Event-Id bleibt über alle Wiederholungen hinweg gleich, ein Unique-Constraint auf dieser Spalte genügt also, um Doppelverarbeitung zu vermeiden: TextMeFlow wiederholt nicht zugestellte Webhooks bis zu 5-mal mit zunehmendem Backoff, und alles außer einer 2xx-Antwort innerhalb von 10 Sekunden zählt als gescheiterter Versuch. Antworte sofort mit 200 und erledige die eigentliche Arbeit in einer Goroutine oder einer Queue, nicht inline — ein langsamer Handler sieht aus Sicht von TextMeFlow genauso aus wie ein Timeout und wird unnötig wiederholt. Die vollständige Header-Liste und den Aufbau der Payload findest du in der Webhook-Dokumentation; die Funktionsweise der Signatur wird ausführlicher in WhatsApp-Webhook-Signaturen verifizieren behandelt.

Fazit

Eine Go-Integration braucht drei Dinge: einen POST mit Bearer-Token, eine Retry-Schleife, die retry_after_seconds respektiert, und eine HMAC-Prüfung für eingehende Anfragen — alles Standardbibliothek, ohne Abhängigkeiten, die du vendoren müsstest. Starte kostenlos und in unter einer Stunde laufen Sendeweg und Webhook-Handler.

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