Generate PDFs in Go with net/http and a static binary

package main

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"time"
)

const statementHTML = `
<h1>Statement for {{ customer.name }}</h1>
<p>{{ period.label }}. Opening balance {{ period.opening | money: "EUR", "de-DE" }}</p>
<table>
  <thead><tr><th>Date</th><th>Reference</th><th>Amount</th></tr></thead>
  <tbody>
  {% for line in lines %}
    <tr><td>{{ line.date | format_date: "short", "UTC", "de-DE" }}</td><td>{{ line.ref }}</td><td>{{ line.amount | money: "EUR", "de-DE" }}</td></tr>
  {% endfor %}
  </tbody>
</table>`

type apiError struct {
	Error struct {
		Code    string `json:"code"`
		Message string `json:"message"`
	} `json:"error"`
}

func main() {
	payload := map[string]any{
		"html": statementHTML,
		"data": map[string]any{
			"customer": map[string]any{"name": "Harbour Lane Bakery"},
			"period":   map[string]any{"label": "September 2026", "opening": 2140.80},
			"lines": []map[string]any{
				{"date": "2026-09-04", "ref": "Invoice INV-7710", "amount": 1240},
				{"date": "2026-09-18", "ref": "Payment received", "amount": -1240},
				{"date": "2026-09-27", "ref": "Invoice INV-7795", "amount": 986.50},
			},
		},
		"mode":     "print",
		"filename": "statement-2026-09",
	}
	body, err := json.Marshal(payload)
	if err != nil {
		log.Fatal(err)
	}

	ctx, cancel := context.WithTimeout(context.Background(), 75*time.Second)
	defer cancel()

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, "https://api.castpdf.com/v1/pdf", bytes.NewReader(body))
	if err != nil {
		log.Fatal(err)
	}
	req.Header.Set("Authorization", "Bearer "+os.Getenv("CASTPDF_API_KEY"))
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer res.Body.Close()

	if res.StatusCode != http.StatusOK {
		var e apiError
		_ = json.NewDecoder(res.Body).Decode(&e)
		log.Fatalf("%d %s: %s", res.StatusCode, e.Error.Code, e.Error.Message)
	}

	out, err := os.Create("statement.pdf")
	if err != nil {
		log.Fatal(err)
	}
	defer out.Close()
	if _, err := io.Copy(out, res.Body); err != nil {
		log.Fatal(err)
	}
	fmt.Println("saved statement.pdf,", res.Header.Get("X-Pages"), "page(s)")
}

package main

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

type statementLine struct {
	Date   string  `json:"date"`
	Ref    string  `json:"ref"`
	Amount float64 `json:"amount"`
}

type statementRequest struct {
	TemplateID string         `json:"template_id"`
	Data       map[string]any `json:"data"`
	Filename   string         `json:"filename"`
	Response   string         `json:"response"`
}

type pdfLink struct {
	ID        string    `json:"id"`
	Pages     int       `json:"pages"`
	Bytes     int64     `json:"bytes"`
	URL       string    `json:"url"`
	ExpiresAt time.Time `json:"expires_at"`
}

var client = &http.Client{Timeout: 90 * time.Second}

func statementLink(ctx context.Context, customerID, customerName, period string, lines []statementLine) (pdfLink, error) {
	key := fmt.Sprintf("statement-%s-%s", customerID, period)
	body, err := json.Marshal(statementRequest{
		TemplateID: os.Getenv("STATEMENT_TEMPLATE_ID"),
		Data: map[string]any{
			"customer": map[string]any{"id": customerID, "name": customerName},
			"period":   map[string]any{"label": period},
			"lines":    lines,
		},
		Filename: key,
		Response: "url",
	})
	if err != nil {
		return pdfLink{}, err
	}

	ctx, cancel := context.WithTimeout(ctx, 75*time.Second)
	defer cancel()
	req, err := http.NewRequestWithContext(ctx, http.MethodPost, "https://api.castpdf.com/v1/pdf", bytes.NewReader(body))
	if err != nil {
		return pdfLink{}, err
	}
	req.Header.Set("Authorization", "Bearer "+os.Getenv("CASTPDF_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Idempotency-Key", key)

	res, err := client.Do(req)
	if err != nil {
		return pdfLink{}, err
	}
	defer res.Body.Close()
	if res.StatusCode != http.StatusOK {
		return pdfLink{}, fmt.Errorf("castpdf: unexpected status %s", res.Status)
	}

	var link pdfLink
	err = json.NewDecoder(res.Body).Decode(&link)
	return link, err
}

func main() {
	lines := []statementLine{
		{Date: "2026-09-04", Ref: "Invoice INV-7710", Amount: 1240},
		{Date: "2026-09-18", Ref: "Payment received", Amount: -1240},
		{Date: "2026-09-27", Ref: "Invoice INV-7795", Amount: 986.5},
	}
	link, err := statementLink(context.Background(), "C-2291", "Harbour Lane Bakery", "2026-09", lines)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(link.URL, link.Pages, "pages, expires", link.ExpiresAt.Format(time.RFC1123))
}

package castpdf

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"strconv"
	"time"
)

// Error is a non-retryable answer from the API.
type Error struct {
	Status  int
	Code    string
	Message string
}

func (e *Error) Error() string {
	return fmt.Sprintf("castpdf: %d %s: %s", e.Status, e.Code, e.Message)
}

// Render posts payload and retries 409, 429, 503 and transport errors with the same idempotency key.
func Render(ctx context.Context, client *http.Client, payload []byte, idempotencyKey string) ([]byte, error) {
	const maxAttempts = 5
	for attempt := 1; ; attempt++ {
		res, body, err := post(ctx, client, payload, idempotencyKey)
		if err == nil && res.StatusCode == http.StatusOK {
			return body, nil
		}

		wait := time.Duration(1<<attempt) * time.Second
		if err == nil {
			apiErr := decodeError(res.StatusCode, body)
			if !retryable(res.StatusCode) {
				return nil, apiErr
			}
			if s, convErr := strconv.Atoi(res.Header.Get("Retry-After")); convErr == nil {
				wait = time.Duration(s) * time.Second
			}
			err = apiErr
		}
		if attempt == maxAttempts || ctx.Err() != nil {
			return nil, err
		}

		select {
		case <-ctx.Done():
			return nil, ctx.Err()
		case <-time.After(wait):
		}
	}
}

func post(ctx context.Context, client *http.Client, payload []byte, idempotencyKey string) (*http.Response, []byte, error) {
	reqCtx, cancel := context.WithTimeout(ctx, 75*time.Second)
	defer cancel()

	req, err := http.NewRequestWithContext(reqCtx, http.MethodPost, "https://api.castpdf.com/v1/pdf", bytes.NewReader(payload))
	if err != nil {
		return nil, nil, err
	}
	req.Header.Set("Authorization", "Bearer "+os.Getenv("CASTPDF_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Idempotency-Key", idempotencyKey)

	res, err := client.Do(req)
	if err != nil {
		return nil, nil, err
	}
	defer res.Body.Close()
	body, err := io.ReadAll(res.Body)
	return res, body, err
}

func retryable(status int) bool {
	return status == http.StatusConflict || status == http.StatusTooManyRequests || status == http.StatusServiceUnavailable
}

func decodeError(status int, body []byte) *Error {
	var envelope struct {
		Error struct {
			Code    string `json:"code"`
			Message string `json:"message"`
		} `json:"error"`
	}
	_ = json.Unmarshal(body, &envelope)
	return &Error{Status: status, Code: envelope.Error.Code, Message: envelope.Error.Message}
}