Add E-Signatures to Go

Quick start

1. Get an API key from signb.ee (free, no credit card)
2. Set SIGNBEE_API_KEY in your environment
3. Add the code below to your app

Go example

package main

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

func sendContract(w http.ResponseWriter, r *http.Request) {
    var body map[string]string
    json.NewDecoder(r.Body).Decode(&body)

    payload, _ := json.Marshal(body)
    req, _ := http.NewRequest("POST", "https://signb.ee/api/send",
        bytes.NewBuffer(payload))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("SIGNBEE_API_KEY"))
    req.Header.Set("Content-Type", "application/json")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    w.Header().Set("Content-Type", "application/json")
    io.Copy(w, resp.Body)
}

What happens

1. Your app sends markdown or a PDF URL to Signbee
2. Signbee generates a PDF (if markdown) and emails the recipient a signing link
3. Recipient signs — both parties receive the signed PDF with SHA-256 certificate

Also works with AI agents

Install the MCP server to let Claude, Cursor, or Windsurf send documents directly:

npx -y signbee-mcp

Integration details

Go is the language of choice for high-performance backend services. Adding e-signatures to Go uses only the standard library — no external dependencies required.

Standard library only: The example uses net/http, encoding/json, bytes, and os — all from Go's standard library. No third-party HTTP client or SDK is needed. This keeps your binary small and dependency-free.

Error handling: The example omits error handling for brevity. In production, check every error return — json.NewDecoder errors (malformed JSON), http.NewRequest errors (invalid URL), http.DefaultClient.Do errors (network failures), and response status codes (4xx/5xx).

Context propagation: Use r.Context() to propagate request context through the API call. This enables request cancellation and timeout propagation. Set a context.WithTimeout to prevent long-running API calls from blocking your server.

HTTP client reuse: Don't use http.DefaultClient in production. Create a shared *http.Client with appropriate timeouts and connection pool settings. This reuses TCP connections across requests, reducing latency.

Goroutine-based concurrency: Go's goroutines make it trivial to send contracts concurrently. For batch operations, launch goroutines for each API call with a semaphore (buffered channel) to control concurrency and prevent overwhelming the API.

Gin/Fiber frameworks: If you're using Gin or Fiber, the API call is identical — only the request/response handling syntax changes. The core HTTP POST to Signbee works the same regardless of framework.

FAQs