🆕 Go SDK

Hulpcentrum

Sjablonen

Documenten

Integraties

Ontwikkelaars

Account

API-SDK's

Met DocuGenerate kunt u PDF- en Word-documenten rechtstreeks vanuit uw Go-applicatie maken. Deze handleiding laat zien hoe u elke API-methode aanroept vanuit Go 1.18 of hoger. Zie de API-referentie voor de volledige lijst met parameters en antwoorden.

Samenvatting

1. Authenticatie
2. Sjabloon maken
3. Sjablonen weergeven
4. Sjabloon ophalen
5. Sjabloon bijwerken
6. Sjabloon verwijderen
7. Document genereren
8. Documenten weergeven
9. Document ophalen
10. Document bijwerken
11. Document verwijderen

1. Authenticatie

Elk verzoek wordt geauthenticeerd door uw API-sleutel mee te sturen in de header Authorization. Bewaar de sleutel in een omgevingsvariabele in plaats van hem hard te coderen in uw broncode:

export DOCUGENERATE_API_KEY="YOUR-API-KEY"

De voorbeelden gebruiken de packages net/http, mime/multipart en encoding/json uit de standaardbibliotheek van Go, dus u hoeft niets te installeren. Elk voorbeeld is geschreven als de body van de functie main van een programma met deze imports en declaraties. Verwijder de imports die een voorbeeld niet gebruikt, omdat Go ongebruikte imports niet compileert. Omdat net/http geen fout retourneert bij HTTP-foutstatussen, controleert elk voorbeeld de statuscode voordat het antwoord wordt gelezen:

package main

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

const apiURL = "https://api.docugenerate.com/v1"

var apiKey = os.Getenv("DOCUGENERATE_API_KEY")

func main() {
	// Add the example code here
}

Als uw account gegevens in een andere regio opslaat, vervang dan de basis-URL door het bijbehorende regionale eindpunt, bijvoorbeeld https://api.eu.docugenerate.com/v1.

2. Sjabloon maken

Om een sjabloon te maken, uploadt u het sjabloonbestand met een verzoek naar POST /template. Dit eindpunt vereist het content type multipart/form-data, hier opgebouwd met een multipart.Writer:

file, err := os.Open("Business Letter.docx")
if err != nil {
	panic(err)
}
defer file.Close()

var form bytes.Buffer
writer := multipart.NewWriter(&form)
part, err := writer.CreateFormFile("file", "Business Letter.docx")
if err != nil {
	panic(err)
}
if _, err := io.Copy(part, file); err != nil {
	panic(err)
}
writer.WriteField("name", "Business Letter")
writer.Close()

request, err := http.NewRequest("POST", apiURL+"/template", &form)
if err != nil {
	panic(err)
}
request.Header.Set("Authorization", apiKey)
request.Header.Set("Accept", "application/json")
request.Header.Set("Content-Type", writer.FormDataContentType())

response, err := http.DefaultClient.Do(request)
if err != nil {
	panic(err)
}
defer response.Body.Close()

body, err := io.ReadAll(response.Body)
if err != nil {
	panic(err)
}

if response.StatusCode >= 400 {
	panic(fmt.Sprintf("DocuGenerate API error %d: %s", response.StatusCode, body))
}

var template map[string]any
if err := json.Unmarshal(body, &template); err != nil {
	panic(err)
}
fmt.Println(template["id"])

Stel de header Content-Type altijd in met writer.FormDataContentType(), dat de multipart-boundary bevat. Zonder de boundary mislukt het verzoek. Het antwoord bevat het nieuwe sjabloon, inclusief de tags die automatisch in het bestand zijn gedetecteerd:

{
  "enhanced_syntax": false,
  "versioning_enabled": false,
  "folder": [],
  "tags": {
    "valid": [
      "Date",
      "Name",
      "Job Title",
      "Company Name",
      "Street Address",
      "City",
      "State",
      "Zip Code",
      "Email",
      "Phone"
    ],
    "invalid": []
  },
  "created": 1791055374301,
  "updated": 1791055374301,
  "name": "Business Letter",
  "delimiters": {
    "left": "[",
    "right": "]"
  },
  "filename": "Business Letter.docx",
  "format": ".docx",
  "region": "eu",
  "page_count": 1,
  "image_uri": "https://firebasestorage.googleapis.com/v0/b/storage.eu.docugenerate.com/o/templates%2FuVE30i1427KQsYcED0bl%2FBusiness%20Letter.png?alt=media&token=0ce64a4b-495a-426b-8783-42b479f7ae38",
  "preview_uri": "https://firebasestorage.googleapis.com/v0/b/storage.eu.docugenerate.com/o/templates%2FuVE30i1427KQsYcED0bl%2FBusiness%20Letter.pdf?alt=media&token=0b3939c7-824e-4979-9aca-ca4a87175cbf",
  "template_uri": "https://firebasestorage.googleapis.com/v0/b/storage.eu.docugenerate.com/o/templates%2FuVE30i1427KQsYcED0bl%2FBusiness%20Letter.docx?alt=media&token=d37a4458-3620-48db-94b8-6ac46f0442ab",
  "id": "uVE30i1427KQsYcED0bl"
}

Bewaar de id van het sjabloon, want u hebt die nodig om documenten te genereren. De volgende optionele parameters kunnen ook naar het formulier worden geschreven:

  • delimiters: De scheidingstekens waarmee de tags worden gedetecteerd, verzonden als JSON-string, bijv. {"left": "[", "right": "]"}. Standaard worden ze automatisch bepaald.
  • region: Waar het sjabloon en de gegenereerde documenten worden opgeslagen, us, eu, uk of au. Standaard wordt de regio van het account gebruikt.
  • enhanced_syntax: Stel in op "true" om geneste eigenschappen en logische of wiskundige operatoren in de tags te gebruiken.
  • versioning_enabled: Stel in op "true" om eerdere versies van het bestand te bewaren bij het uploaden van een nieuw bestand, als uw plan dit toestaat.
  • folder: De map van het sjabloon, van de hoofdmap tot het laagste niveau. Ontbrekende mappen worden automatisch aangemaakt.

Om het sjabloon in een map te plaatsen, schrijft u voor elk niveau van het pad een folder-veld. Bijvoorbeeld om het in de map Letters > Business te plaatsen:

writer.WriteField("folder", "Letters")
writer.WriteField("folder", "Business")

3. Sjablonen weergeven

Een verzoek naar GET /template retourneert alle sjablonen in uw account:

request, err := http.NewRequest("GET", apiURL+"/template", nil)
if err != nil {
	panic(err)
}
request.Header.Set("Authorization", apiKey)
request.Header.Set("Accept", "application/json")

response, err := http.DefaultClient.Do(request)
if err != nil {
	panic(err)
}
defer response.Body.Close()

body, err := io.ReadAll(response.Body)
if err != nil {
	panic(err)
}

if response.StatusCode >= 400 {
	panic(fmt.Sprintf("DocuGenerate API error %d: %s", response.StatusCode, body))
}

var templates []map[string]any
if err := json.Unmarshal(body, &templates); err != nil {
	panic(err)
}
for _, template := range templates {
	fmt.Println(template["id"], template["name"])
}

Om alleen de sjablonen van een map weer te geven, herhaalt u de queryparameter folder voor elk niveau van het pad. Bijvoorbeeld om de sjablonen in de map Letters > Business weer te geven:

request, err := http.NewRequest("GET", apiURL+"/template?folder=Letters&folder=Business", nil)
if err != nil {
	panic(err)
}
request.Header.Set("Authorization", apiKey)
request.Header.Set("Accept", "application/json")

response, err := http.DefaultClient.Do(request)
if err != nil {
	panic(err)
}
defer response.Body.Close()

body, err := io.ReadAll(response.Body)
if err != nil {
	panic(err)
}

if response.StatusCode >= 400 {
	panic(fmt.Sprintf("DocuGenerate API error %d: %s", response.StatusCode, body))
}

Alleen de sjablonen die direct in die map staan, worden geretourneerd. Sjablonen in de submappen worden niet meegenomen. Lees meer over hoe u met de API sjablonen in mappen organiseert.

4. Sjabloon ophalen

Om één sjabloon op te halen, roept u GET /template/{id} aan met de ID ervan:

templateID := "bet2oQirk0pSd9ctH9Qu"

request, err := http.NewRequest("GET", apiURL+"/template/"+templateID, nil)
if err != nil {
	panic(err)
}
request.Header.Set("Authorization", apiKey)
request.Header.Set("Accept", "application/json")

response, err := http.DefaultClient.Do(request)
if err != nil {
	panic(err)
}
defer response.Body.Close()

body, err := io.ReadAll(response.Body)
if err != nil {
	panic(err)
}

if response.StatusCode >= 400 {
	panic(fmt.Sprintf("DocuGenerate API error %d: %s", response.StatusCode, body))
}

var template map[string]any
if err := json.Unmarshal(body, &template); err != nil {
	panic(err)
}
fmt.Println(template["tags"].(map[string]any)["valid"])

Dit is bijvoorbeeld handig om te controleren welke merge-tags het sjabloon verwacht voordat u documenten genereert.

5. Sjabloon bijwerken

Een verzoek naar PUT /template/{id} werkt een sjabloon bij. Alle parameters zijn optioneel, dus stuur alleen de parameters mee die u wilt wijzigen. Bijvoorbeeld om een nieuwe versie van het bestand te uploaden en het sjabloon te hernoemen:

templateID := "bet2oQirk0pSd9ctH9Qu"

file, err := os.Open("Business Letter v2.docx")
if err != nil {
	panic(err)
}
defer file.Close()

var form bytes.Buffer
writer := multipart.NewWriter(&form)
part, err := writer.CreateFormFile("file", "Business Letter v2.docx")
if err != nil {
	panic(err)
}
if _, err := io.Copy(part, file); err != nil {
	panic(err)
}
writer.WriteField("name", "Business Letter v2")
writer.Close()

request, err := http.NewRequest("PUT", apiURL+"/template/"+templateID, &form)
if err != nil {
	panic(err)
}
request.Header.Set("Authorization", apiKey)
request.Header.Set("Accept", "application/json")
request.Header.Set("Content-Type", writer.FormDataContentType())

response, err := http.DefaultClient.Do(request)
if err != nil {
	panic(err)
}
defer response.Body.Close()

body, err := io.ReadAll(response.Body)
if err != nil {
	panic(err)
}

if response.StatusCode >= 400 {
	panic(fmt.Sprintf("DocuGenerate API error %d: %s", response.StatusCode, body))
}

var template map[string]any
if err := json.Unmarshal(body, &template); err != nil {
	panic(err)
}

Net als bij het maken van een sjabloon moet de body multipart/form-data zijn, met de header Content-Type ingesteld op writer.FormDataContentType(). Naast file en name kunnen de volgende optionele parameters naar het formulier worden geschreven:

  • delimiters: De nieuwe scheidingstekens, verzonden als JSON-string. Indien opgegeven, wordt het sjabloon opnieuw geanalyseerd om de merge-tags te detecteren op basis van de nieuwe scheidingstekens. Wanneer een nieuw file wordt geüpload zonder delimiters, worden de huidige scheidingstekens gebruikt.
  • region: Verplaatst het sjabloon naar een andere regio, us, eu, uk of au. Documenten die daarna worden gegenereerd, worden in de nieuwe regio opgeslagen, terwijl bestaande documenten in hun huidige regio blijven.
  • folder: Verplaatst het sjabloon naar een andere map, met één folder-veld voor elk niveau van het pad. Stuur "[]" om het sjabloon uit elke map te halen.
  • enhanced_syntax: Stel in op "true" of "false" om de uitgebreide syntax in of uit te schakelen.
  • versioning_enabled: Stel in op "true" of "false" om de versiegeschiedenis in of uit te schakelen, als uw plan dit toestaat.

6. Sjabloon verwijderen

Om een sjabloon te verwijderen, stuurt u een verzoek naar DELETE /template/{id}. De API antwoordt bij succes met de status 204 No Content:

templateID := "bet2oQirk0pSd9ctH9Qu"

request, err := http.NewRequest("DELETE", apiURL+"/template/"+templateID, nil)
if err != nil {
	panic(err)
}
request.Header.Set("Authorization", apiKey)
request.Header.Set("Accept", "application/json")

response, err := http.DefaultClient.Do(request)
if err != nil {
	panic(err)
}
defer response.Body.Close()

body, err := io.ReadAll(response.Body)
if err != nil {
	panic(err)
}

if response.StatusCode >= 400 {
	panic(fmt.Sprintf("DocuGenerate API error %d: %s", response.StatusCode, body))
}

7. Document genereren

U genereert documenten met een verzoek naar POST /document, waarbij u de template_id en de data meegeeft waarmee de merge-tags worden vervangen:

payload, err := json.Marshal(map[string]any{
	"template_id": "bet2oQirk0pSd9ctH9Qu",
	"data": map[string]string{
		"Date":           "October 4, 2026",
		"Name":           "Emily Carter",
		"Job Title":      "Operations Manager",
		"Company Name":   "Harbor Point Consulting",
		"Street Address": "118 West Street",
		"City":           "Annapolis",
		"State":          "Maryland",
		"Zip Code":       "21405",
		"Email":          "emily.carter@example.com",
		"Phone":          "(410) 555-0142",
	},
	"output_format": ".pdf",
})
if err != nil {
	panic(err)
}

request, err := http.NewRequest("POST", apiURL+"/document", bytes.NewReader(payload))
if err != nil {
	panic(err)
}
request.Header.Set("Authorization", apiKey)
request.Header.Set("Accept", "application/json")
request.Header.Set("Content-Type", "application/json")

response, err := http.DefaultClient.Do(request)
if err != nil {
	panic(err)
}
defer response.Body.Close()

body, err := io.ReadAll(response.Body)
if err != nil {
	panic(err)
}

if response.StatusCode >= 400 {
	panic(fmt.Sprintf("DocuGenerate API error %d: %s", response.StatusCode, body))
}

var document map[string]any
if err := json.Unmarshal(body, &document); err != nil {
	panic(err)
}
fmt.Println(document["document_uri"])

Het antwoord bevat de eigenschappen van het document:

{
  "created": 1791125416372,
  "template_id": "bet2oQirk0pSd9ctH9Qu",
  "name": "Business Letter",
  "format": ".pdf",
  "data_length": 1,
  "filename": "Business Letter.pdf",
  "document_uri": "https://firebasestorage.googleapis.com/v0/b/storage.us.docugenerate.com/o/documents%2FiESelthRt4uaYQRTemrL%2FBusiness%20Letter.pdf?alt=media&token=c4b259ec-249b-4b35-a62f-6a8dc0da75f3",
  "id": "iESelthRt4uaYQRTemrL"
}

Het output_format kan .docx (standaard), .pdf, .doc, .odt, .txt, .html, .png of een PDF/A-versie zijn. U kunt ook met merge_with PDF-bestanden samenvoegen aan het einde van het gegenereerde document, of met attach bijlagen toevoegen.

Het bestand downloaden
De document_uri verwijst naar het gegenereerde bestand, dat u kunt downloaden en op schijf kunt opslaan:

file, err := http.Get(document["document_uri"].(string))
if err != nil {
	panic(err)
}
defer file.Body.Close()

if file.StatusCode >= 400 {
	panic(fmt.Sprintf("Download failed with status %d", file.StatusCode))
}

content, err := io.ReadAll(file.Body)
if err != nil {
	panic(err)
}
if err := os.WriteFile(document["filename"].(string), content, 0644); err != nil {
	panic(err)
}

Het bestand direct ontvangen
Als u niet wilt dat het document in de cloud wordt opgeslagen, stel dan de header Accept in op application/octet-stream. De API antwoordt dan met het binaire bestand in plaats van JSON:

payload, err := json.Marshal(map[string]any{
	"template_id": "bet2oQirk0pSd9ctH9Qu",
	"data": map[string]string{
		"Date":           "October 4, 2026",
		"Name":           "Emily Carter",
		"Job Title":      "Operations Manager",
		"Company Name":   "Harbor Point Consulting",
		"Street Address": "118 West Street",
		"City":           "Annapolis",
		"State":          "Maryland",
		"Zip Code":       "21405",
		"Email":          "emily.carter@example.com",
		"Phone":          "(410) 555-0142",
	},
	"output_format": ".pdf",
})
if err != nil {
	panic(err)
}

request, err := http.NewRequest("POST", apiURL+"/document", bytes.NewReader(payload))
if err != nil {
	panic(err)
}
request.Header.Set("Authorization", apiKey)
request.Header.Set("Accept", "application/octet-stream")
request.Header.Set("Content-Type", "application/json")

response, err := http.DefaultClient.Do(request)
if err != nil {
	panic(err)
}
defer response.Body.Close()

body, err := io.ReadAll(response.Body)
if err != nil {
	panic(err)
}

if response.StatusCode >= 400 {
	panic(fmt.Sprintf("DocuGenerate API error %d: %s", response.StatusCode, body))
}

if err := os.WriteFile("Business Letter.pdf", body, 0644); err != nil {
	panic(err)
}
fmt.Println(response.Header.Get("X-Document-Id"))

Batchgewijze documentgeneratie
Om meerdere documenten in één verzoek te genereren, geeft u een slice van maps mee als data. Voor elke map wordt een document gegenereerd:

payload, err := json.Marshal(map[string]any{
	"template_id": "bet2oQirk0pSd9ctH9Qu",
	"data": []map[string]string{
		{"Date": "October 4, 2026", "Name": "Emily Carter", "Job Title": "Operations Manager", "Company Name": "Harbor Point Consulting", "Street Address": "118 West Street", "City": "Annapolis", "State": "Maryland", "Zip Code": "21405", "Email": "emily.carter@example.com", "Phone": "(410) 555-0142"},
		{"Date": "October 4, 2026", "Name": "Daniel Brooks", "Job Title": "Logistics Coordinator", "Company Name": "Northfield Logistics", "Street Address": "2400 South Lamar Boulevard", "City": "Austin", "State": "Texas", "Zip Code": "78704", "Email": "daniel.brooks@example.com", "Phone": "(512) 555-0187"},
	},
	"output_format": ".pdf",
	"single_file":   true,
	"page_break":    true,
})
if err != nil {
	panic(err)
}

request, err := http.NewRequest("POST", apiURL+"/document", bytes.NewReader(payload))
if err != nil {
	panic(err)
}
request.Header.Set("Authorization", apiKey)
request.Header.Set("Accept", "application/json")
request.Header.Set("Content-Type", "application/json")

response, err := http.DefaultClient.Do(request)
if err != nil {
	panic(err)
}
defer response.Body.Close()

body, err := io.ReadAll(response.Body)
if err != nil {
	panic(err)
}

if response.StatusCode >= 400 {
	panic(fmt.Sprintf("DocuGenerate API error %d: %s", response.StatusCode, body))
}

var document map[string]any
if err := json.Unmarshal(body, &document); err != nil {
	panic(err)
}

Standaard worden alle documenten samengevoegd in één bestand, met een pagina-einde na elk document. Stel page_break in op false om de pagina-eindes te verwijderen.

Wanneer single_file op false staat, wordt per data-object een bestand gegenereerd en worden alle bestanden gegroepeerd in een .zip-archief. Gebruik de parameter name om het archief een naam te geven, en output_name met merge-tags om elk bestand een dynamische naam te geven, zoals Letter for [Name]:

payload, err := json.Marshal(map[string]any{
	"template_id":   "bet2oQirk0pSd9ctH9Qu",
	"data":          []map[string]string{...},
	"output_format": ".pdf",
	"single_file":   false,
	"name":          "Business Letters",
	"output_name":   "Letter for [Name]",
})

Dit genereert een archief Business Letters.zip met Letter for Emily Carter.pdf en Letter for Daniel Brooks.pdf. De merge-tags in output_name moeten dezelfde scheidingstekens gebruiken als het sjabloon.

Een gegevensbestand gebruiken
Om documenten in bulk te genereren vanuit een Excel- of CSV-bestand, verstuurt u het bestand in een multipart/form-data-verzoek. Voor elke rij van het spreadsheet wordt een document gegenereerd. Als het bestand meerdere werkbladen bevat, geef dan met de parameter sheet aan welk werkblad u wilt gebruiken.

file, err := os.Open("Data.xlsx")
if err != nil {
	panic(err)
}
defer file.Close()

var form bytes.Buffer
writer := multipart.NewWriter(&form)
writer.WriteField("template_id", "bet2oQirk0pSd9ctH9Qu")
part, err := writer.CreateFormFile("file", "Data.xlsx")
if err != nil {
	panic(err)
}
if _, err := io.Copy(part, file); err != nil {
	panic(err)
}
writer.WriteField("output_format", ".pdf")
writer.Close()

request, err := http.NewRequest("POST", apiURL+"/document", &form)
if err != nil {
	panic(err)
}
request.Header.Set("Authorization", apiKey)
request.Header.Set("Accept", "application/json")
request.Header.Set("Content-Type", writer.FormDataContentType())

response, err := http.DefaultClient.Do(request)
if err != nil {
	panic(err)
}
defer response.Body.Close()

body, err := io.ReadAll(response.Body)
if err != nil {
	panic(err)
}

if response.StatusCode >= 400 {
	panic(fmt.Sprintf("DocuGenerate API error %d: %s", response.StatusCode, body))
}

Een gegevensbestand gebruiken is een andere vorm van batchgeneratie, dus dezelfde parameters gelden voor het samenvoegen van de gegenereerde documenten in één bestand of het groeperen ervan in een .zip-archief met een eigen naam voor elk bestand.

8. Documenten weergeven

Een verzoek naar GET /document retourneert de documenten die op basis van een sjabloon zijn gegenereerd. De ID van het sjabloon wordt meegegeven in de queryparameter template_id:

request, err := http.NewRequest("GET", apiURL+"/document?template_id=bet2oQirk0pSd9ctH9Qu", nil)
if err != nil {
	panic(err)
}
request.Header.Set("Authorization", apiKey)
request.Header.Set("Accept", "application/json")

response, err := http.DefaultClient.Do(request)
if err != nil {
	panic(err)
}
defer response.Body.Close()

body, err := io.ReadAll(response.Body)
if err != nil {
	panic(err)
}

if response.StatusCode >= 400 {
	panic(fmt.Sprintf("DocuGenerate API error %d: %s", response.StatusCode, body))
}

var documents []map[string]any
if err := json.Unmarshal(body, &documents); err != nil {
	panic(err)
}
for _, document := range documents {
	fmt.Println(document["id"], document["name"], document["document_uri"])
}

9. Document ophalen

Om één document op te halen, roept u GET /document/{id} aan met de ID ervan:

documentID := "iESelthRt4uaYQRTemrL"

request, err := http.NewRequest("GET", apiURL+"/document/"+documentID, nil)
if err != nil {
	panic(err)
}
request.Header.Set("Authorization", apiKey)
request.Header.Set("Accept", "application/json")

response, err := http.DefaultClient.Do(request)
if err != nil {
	panic(err)
}
defer response.Body.Close()

body, err := io.ReadAll(response.Body)
if err != nil {
	panic(err)
}

if response.StatusCode >= 400 {
	panic(fmt.Sprintf("DocuGenerate API error %d: %s", response.StatusCode, body))
}

var document map[string]any
if err := json.Unmarshal(body, &document); err != nil {
	panic(err)
}

10. Document bijwerken

Een verzoek naar PUT /document/{id} hernoemt een document, want de naam is de enige eigenschap die kan worden bijgewerkt:

documentID := "iESelthRt4uaYQRTemrL"

payload, err := json.Marshal(map[string]string{"name": "Letter for Emily Carter"})
if err != nil {
	panic(err)
}

request, err := http.NewRequest("PUT", apiURL+"/document/"+documentID, bytes.NewReader(payload))
if err != nil {
	panic(err)
}
request.Header.Set("Authorization", apiKey)
request.Header.Set("Accept", "application/json")
request.Header.Set("Content-Type", "application/json")

response, err := http.DefaultClient.Do(request)
if err != nil {
	panic(err)
}
defer response.Body.Close()

body, err := io.ReadAll(response.Body)
if err != nil {
	panic(err)
}

if response.StatusCode >= 400 {
	panic(fmt.Sprintf("DocuGenerate API error %d: %s", response.StatusCode, body))
}

var document map[string]any
if err := json.Unmarshal(body, &document); err != nil {
	panic(err)
}

11. Document verwijderen

Om een document te verwijderen, stuurt u een verzoek naar DELETE /document/{id}. De API antwoordt bij succes met de status 204 No Content:

documentID := "iESelthRt4uaYQRTemrL"

request, err := http.NewRequest("DELETE", apiURL+"/document/"+documentID, nil)
if err != nil {
	panic(err)
}
request.Header.Set("Authorization", apiKey)
request.Header.Set("Accept", "application/json")

response, err := http.DefaultClient.Do(request)
if err != nil {
	panic(err)
}
defer response.Body.Close()

body, err := io.ReadAll(response.Body)
if err != nil {
	panic(err)
}

if response.StatusCode >= 400 {
	panic(fmt.Sprintf("DocuGenerate API error %d: %s", response.StatusCode, body))
}