PDF asynchron rendern und den Webhook prüfen mit Go

Was Sie brauchen

• Einen API-Key. Legen Sie ihn in der App unter API-Schlüssel an und exportieren Sie ihn als FORMFEED_API_KEY. Zum Ausprobieren ist ein Test-Key (ff_test_…) richtig. Siehe Quickstart.
• Go. Sie brauchen Go 1.21 oder neuer; das Programm nutzt nur die Standardbibliothek.
• Die Vorlage. revenue-report aus dem Berichtsbeispiel und dessen data.json neben dem Programm.
• Ein Secret. 16 bis 200 zufällige Zeichen in FORMFEED_WEBHOOK_SECRET, beiden Programmen bekannt. Es signiert die Zustellungen dieses Renderings, Retries eingeschlossen.
• Eine öffentliche URL. Ersetzen Sie https://example.com/hooks/formfeed durch Ihren Endpunkt. Während der Entwicklung leitet formfeed listen Zustellungen ohne Tunnel an localhost weiter.

Das Programm

Die Anfrage nennt die Vorlage, schaltet auf mode: "async" und sagt, wohin gemeldet wird. Die Antwort kommt sofort, mit dem Status queued.

package main

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

const endpoint = "https://api-eu.formfeed.dev/v1/renders"

// a render or a problem document: both are JSON objects, so one struct decodes either
type render struct {
	ID     string `json:"id"`
	Status string `json:"status"`
	Title  string `json:"title"`
	Detail string `json:"detail"`
}

// send makes one call with the key and decodes the answer
func send(method, url string, body []byte) (int, render) {
	request, _ := http.NewRequest(method, url, bytes.NewReader(body))
	request.Header.Set("Authorization", "Bearer "+os.Getenv("FORMFEED_API_KEY"))
	request.Header.Set("Content-Type", "application/json")
	response, err := http.DefaultClient.Do(request)
	if err != nil {
		panic(err)
	}
	defer response.Body.Close()
	var answer render
	json.NewDecoder(response.Body).Decode(&answer)
	return response.StatusCode, answer
}

func main() {
	data, err := os.ReadFile("data.json")
	if err != nil {
		panic(err)
	}
	body, _ := json.Marshal(map[string]any{
		"template":       "revenue-report",
		"data":           json.RawMessage(data),
		"mode":           "async",
		"webhook_url":    "https://example.com/hooks/formfeed",
		"webhook_secret": os.Getenv("FORMFEED_WEBHOOK_SECRET"),
	})

	status, result := send("POST", endpoint, body)
	// every error is a problem document (RFC 9457) with a title and a detail
	if status >= 400 {
		fmt.Fprintf(os.Stderr, "%s: %s\n", result.Title, result.Detail)
		os.Exit(1)
	}
	fmt.Println(result.ID, result.Status) // queued: the webhook reports the rest
}

Ausführen

Es gibt die ID des Renderings und queued aus. Wenige Sekunden später erhält Ihr Endpunkt render.completed mit dem vollständigen Rendering samt download_url, oder render.failed mit dem Grund.

export FORMFEED_API_KEY=ff_test_...
export FORMFEED_WEBHOOK_SECRET=$(openssl rand -hex 24)
go run main.go

Was an Go besonders ist

• json.RawMessage. Die Beispieldaten gehen so in den Body, wie sie auf der Platte liegen, ohne vorher in Go-Typen dekodiert zu werden; das Programm funktioniert deshalb für jede Vorlage.
• Ein Struct für beide Antworten. Ein Rendering und ein Problem-Dokument sind beide JSON-Objekte, ein einziges Struct mit title und detail neben den Render-Feldern dekodiert also beides.
• Timeouts. http.DefaultClient hat keinen. Geben Sie dem Client in einem Dienst einen Timeout etwas über 60 Sekunden: Ein synchrones Rendering antwortet, wenn die Datei fertig ist, oder nach 60 Sekunden mit 202, während es im Hintergrund weiterläuft.

Der Empfänger

Er lauscht auf Port 8080, liest den rohen Body, prüft Signatur und Alter des Zeitstempels und sieht sich erst dann das JSON an. Eine Zustellung, die die Prüfung nicht besteht, erhält 401.

package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"strconv"
	"strings"
	"time"
)

var secret = []byte(os.Getenv("FORMFEED_WEBHOOK_SECRET"))

// valid checks "Webhook-Signature: t=<unix seconds>,v1=<hex HMAC-SHA256 of t.body>".
func valid(header string, body []byte) bool {
	parts := map[string]string{}
	for _, part := range strings.Split(header, ",") {
		if key, value, ok := strings.Cut(strings.TrimSpace(part), "="); ok {
			parts[key] = value
		}
	}
	timestamp, err := strconv.ParseInt(parts["t"], 10, 64)
	if err != nil {
		return false
	}
	if age := time.Now().Unix() - timestamp; age > 300 || age < -300 {
		return false
	}
	mac := hmac.New(sha256.New, secret)
	fmt.Fprintf(mac, "%d.%s", timestamp, body)
	given, err := hex.DecodeString(parts["v1"])
	return err == nil && hmac.Equal(mac.Sum(nil), given)
}

func main() {
	http.HandleFunc("/hooks/formfeed", func(w http.ResponseWriter, r *http.Request) {
		// the signature covers the bytes on the wire: read the raw body, never re-serialised JSON
		body, _ := io.ReadAll(r.Body)
		if !valid(r.Header.Get("Webhook-Signature"), body) {
			w.WriteHeader(http.StatusUnauthorized)
			return
		}

		var event struct {
			Type string `json:"type"`
			Data struct {
				ID          string `json:"id"`
				DownloadURL string `json:"download_url"`
			} `json:"data"`
		}
		json.Unmarshal(body, &event)
		switch event.Type {
		case "render.completed":
			fmt.Println("done", event.Data.ID, event.Data.DownloadURL)
		case "render.failed":
			fmt.Println("failed", event.Data.ID)
		}
		w.WriteHeader(http.StatusNoContent)
	})
	http.ListenAndServe(":8080", nil)
}

Empfänger starten

FORMFEED_WEBHOOK_SECRET=… go run hook.go

Prüfen in Go

• hmac.Equal. Es vergleicht die dekodierten Signatur-Bytes in konstanter Zeit, wodurch auch Hex in Großbuchstaben unproblematisch ist.
• Einmal lesen. io.ReadAll(r.Body) liefert die exakten Bytes; dekodieren Sie das JSON danach aus diesem Slice, nicht ein zweites Mal aus dem Request-Body.

Was ankommt

Ein POST mit Webhook-Signature: t=<Unix-Sekunden>,v1=<hex>; das Hex ist HMAC-SHA256 über t, einen Punkt und den rohen Body, mit Ihrem Secret als Schlüssel, genau so, wie Sie es haben, als UTF-8-Bytes: das webhook_secret, das Sie gesendet haben, oder die ganze whsec_…-Zeichenkette eines registrierten Endpunkts samt Präfix. Jeder Versuch wird mit eigenem t neu signiert. Webhook-Id bleibt über Retries gleich und ist damit Ihr Schlüssel zum Deduplizieren. data ist das Rendering, wie GET /renders/{id} es liefert:

{
  "id": "evt_5b0c8e6f2d4a4c3e9b1a7f6e5d4c3b2a",
  "type": "render.completed",
  "created_at": "2026-09-18T10:42:00Z",
  "workspace_id": "3a6f…",
  "data": {
    "id": "rnd_7da09ab6cd9946b798c187c2a9350852",
    "status": "succeeded",
    "download_url": "https://cdn.formfeed.dev/o/eu/…/document.pdf?exp=…&sig=…",
    "page_count": 2,
    "units": 1,
    …
  }
}

Retries, und was Ihr Endpunkt leisten muss

• Schnell antworten. Eine Zustellung gelingt mit einem 2xx innerhalb von 10 Sekunden. Speichern Sie das Event und erledigen Sie die Arbeit danach.
• Retries. Alles andere, auch eine Weiterleitung, wird nach 1 Minute, 5 Minuten, 30 Minuten, 2 Stunden und 12 Stunden wiederholt: insgesamt sechs Versuche über etwa 14 Stunden und 40 Minuten. Dasselbe Event kann also zweimal ankommen: Deduplizieren Sie über Webhook-Id.
• Ohne Secret. Eine webhook_url ohne webhook_secret wird unsigniert zugestellt. Für signierte Zustellungen aller Renderings registrieren Sie einmal einen Endpunkt in der App oder über POST /webhooks; er erhält ein eigenes Secret.
• Lokal ausprobieren. formfeed listen --forward-to http://localhost:8080/hooks/formfeed leitet die Events Ihrer Test-Renderings an Ihren Rechner weiter, signiert mit dem eigenen Secret der Session statt mit webhook_secret: Starten Sie den Empfänger mit diesem, das formfeed listen --print-secret ausgibt (vor der Session aufrufen, denn es beendet eine laufende). formfeed trigger render.completed --template revenue-report erzeugt ein echtes Test-Rendering, dessen Event Sie ankommen sehen. Der Schlüssel braucht den Scope webhook:listen. Siehe Webhooks lokal entwickeln.

Wenn die API nein sagt

• Eine Form für jeden Fehler. Fehler sind Problem-Dokumente (RFC 9457) mit type, title, status, detail, einem stabilen code und der request_id, die Sie dem Support nennen; die type-URL führt zu einer Seite über diesen Fehler. Die Liste steht in der Fehlerreferenz.
• Die üblichen. 401 unauthorized bei fehlendem oder widerrufenem Schlüssel, 404 template_not_found bei falschem Vorlagennamen, 422 template_runtime_error, wenn die Vorlage an den Daten scheitert, 429 rate_limited über den Anfragen pro Sekunde des Tarifs, 402 quota_exceeded, wenn die Einheiten des Free-Tarifs verbraucht sind (ein bezahlter Tarif rechnet weitere Einheiten ab, bis zu seiner Obergrenze).
• Sicher wiederholen. Senden Sie beim POST einen Idempotency-Key-Header und wiederholen Sie die Anfrage mit demselben Schlüssel, wenn Sie nicht wissen, ob der erste Versuch ankam: 24 Stunden lang liefert der Schlüssel die erste Antwort, statt erneut zu rendern und zu berechnen. Gespeichert wird die Antwort, sobald der erste Versuch beantwortet ist; wiederholen Sie also nicht, solange er noch laufen kann. Auch Probleme unter 500 werden gespeichert, eine korrigierte Anfrage braucht deshalb einen neuen Schlüssel.

Die Aufgabe um dieses Programm

Dieser Guide ist ein Programm. Was die Aufgabe darum herum braucht, von der Vorlage bis zu Limits und Preis, steht auf der Seite Report-PDFs erzeugen.

Weitere Guides für Go

• PDF-Rechnung aus JSON erzeugen mit Go
• ZUGFeRD-E-Rechnung erstellen mit Go
• HTML in PDF umwandeln mit Go
• Open-Graph-Bilder erzeugen mit Go
• PDFs aus einer CSV erzeugen mit Go
• PDFs zusammenfügen und mit Passwort schützen mit Go

FAQ

Kann ich pollen, statt einen Webhook zu empfangen?

Ja: GET /renders/{id}, bis der Status succeeded oder failed ist; die SDKs haben dafür waitFor und wait_for. Ein Webhook spart die Anfragen und meldet sich früher. Siehe Async und Batch.

Warum muss der rohe Body verwendet werden?

Die Signatur läuft über die Bytes auf der Leitung. JSON zu parsen und neu zu serialisieren kann Schlüssel umsortieren, Zahlenformate ändern oder Zeichen anders maskieren, und der HMAC dieses Textes passt dann nicht mehr.

Wozu dient die Fünf-Minuten-Toleranz?

Sie verhindert, dass eine abgefangene Zustellung später erneut eingespielt wird. Sie bedeutet auch, dass die Uhr Ihres Servers ungefähr stimmen muss.

Asynchron rendern mit Webhook in anderen Sprachen

• Node.js (TypeScript)
• Python
• PHP
• C# (.NET)
• Java
• Ruby