x402 in Go

x402 is plain HTTP 402, so adding USDC pay-per-request to a Go service takes only a handler and a facilitator call — no special framework required.

Which approach should you use?

Server (net/http)

Return 402 with payment requirements until a valid X-PAYMENT header arrives, then serve.

// net/http handler that requires payment.
// x402 is just HTTP 402, so you can implement it directly in Go.
package main

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

// Payment requirements returned on the 402 response.
var requirements = map[string]any{
	"scheme":    "exact",
	"network":   "base-sepolia", // use "base" in production
	"maxAmount": "10000",         // 0.01 USDC (6 decimals)
	"payTo":     "0xYourReceivingWalletAddress",
	"asset":     "USDC",
}

func weather(w http.ResponseWriter, r *http.Request) {
	payment := r.Header.Get("X-PAYMENT")
	if payment == "" || !verifyWithFacilitator(payment) {
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusPaymentRequired) // 402
		json.NewEncoder(w).Encode(map[string]any{"accepts": []any{requirements}})
		return
	}
	// Paid: serve the response
	json.NewEncoder(w).Encode(map[string]string{"city": "Tokyo", "forecast": "sunny"})
}

func main() {
	http.HandleFunc("/weather", weather)
	http.ListenAndServe(":8080", nil)
}

Verifying the payment

A facilitator checks the signed USDC payment on-chain so your server stays simple.

// Verify the payment by calling an x402 facilitator's
// /verify (and later /settle) endpoint over HTTP.
func verifyWithFacilitator(payment string) bool {
	// POST the X-PAYMENT payload + requirements to your facilitator,
	// which checks the signed USDC payment on-chain and returns valid=true.
	// Use a hosted facilitator or run your own — see the facilitators list.
	return callFacilitator("/verify", payment, requirements)
}

Middleware for multiple routes

Wrap any handler with the same check instead of repeating it.

// Reusable middleware instead of repeating the check in every handler.
func requirePayment(price string, next http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		payment := r.Header.Get("X-PAYMENT")
		if payment == "" || !verifyWithFacilitator(payment) {
			w.Header().Set("Content-Type", "application/json")
			w.WriteHeader(http.StatusPaymentRequired)
			json.NewEncoder(w).Encode(map[string]any{"accepts": []any{requirements}})
			return
		}
		next(w, r)
	}
}

func main() {
	http.HandleFunc("/weather", requirePayment("$0.01", weather))
	http.ListenAndServe(":8080", nil)
}

Client (manual retry)

No official Go client package exists yet, so a caller reads the 402 body and retries with a signed payment itself.

// A Go client that pays automatically by handling the 402 itself.
// There's no official Go client SDK yet, so this shows the manual flow —
// most Go usage of x402 today is on the server/facilitator side.
resp, err := http.Get("http://localhost:8080/weather")
if err != nil {
	log.Fatal(err)
}
if resp.StatusCode == http.StatusPaymentRequired {
	var body struct{ Accepts []map[string]any `json:"accepts"` }
	json.NewDecoder(resp.Body).Decode(&body)
	// Sign a USDC payment for body.Accepts[0], then retry with
	// the X-PAYMENT header set to the signed payload.
	req, _ := http.NewRequest("GET", "http://localhost:8080/weather", nil)
	req.Header.Set("X-PAYMENT", signPayment(body.Accepts[0]))
	resp, _ = http.DefaultClient.Do(req)
}

Troubleshooting

Get amounts right with the free base-unit converter.

Go x402 projects

Real open-source implementations · stars live from GitHub.

Frequently asked questions

More: all SDKs · Python · Node.js · Rust