Go

type IPLookup struct {
	IP          string  `json:"ip"`
	City        string  `json:"city"`
	Region      string  `json:"region"`
	Country     string  `json:"country"`
	CountryCode string  `json:"country_code"`
	Latitude    float64 `json:"latitude"`
	Longitude   float64 `json:"longitude"`
	PostalCode  string  `json:"postal_code"`
	Timezone    string  `json:"timezone"`
	ASN         ASNInfo `json:"asn"`
	Privacy     Privacy `json:"privacy"`
}

type ASNInfo struct {
	Number int    `json:"number"`
	Name   string `json:"name"`
	Org    string `json:"org"`
	Route  string `json:"route"`
}

type Privacy struct {
	IsVPN     bool `json:"is_vpn"`
	IsProxy   bool `json:"is_proxy"`
	IsTor     bool `json:"is_tor"`
	IsHosting bool `json:"is_hosting"`
}

package main

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

func main() {
	resp, err := http.Get("https://whatismyip.technology/api/me")
	if err != nil {
		fmt.Printf("Request failed: %v\n", err)
		return
	}
	defer resp.Body.Close()

	var result IPLookup
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		fmt.Printf("JSON parse failed: %v\n", err)
		return
	}

	fmt.Printf("Your IP: %s\n", result.IP)
}

func lookupIP(ip string) (*IPLookup, error) {
	resp, err := http.Get("https://whatismyip.technology/api/" + ip)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, _ := io.ReadAll(resp.Body)
		return nil, fmt.Errorf("HTTP %d: %s", resp.StatusCode, body)
	}

	var result IPLookup
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return nil, err
	}
	return &result, nil
}

// Usage
data, err := lookupIP("8.8.8.8")
if err != nil {
	log.Fatal(err)
}
fmt.Printf("%s is in %s, %s\n", data.IP, data.City, data.Country)

resp, err := http.Get("https://whatismyip.technology/api/8.8.8.8/geo")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var geo struct {
	City    string  `json:"city"`
	Country string  `json:"country"`
	Lat     float64 `json:"latitude"`
	Lon     float64 `json:"longitude"`
}
json.NewDecoder(resp.Body).Decode(&geo)
fmt.Printf("%s, %s (%.4f, %.4f)\n", geo.City, geo.Country, geo.Lat, geo.Lon)

resp, err := http.Get("https://whatismyip.technology/api/8.8.8.8/privacy")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var privacy Privacy
json.NewDecoder(resp.Body).Decode(&privacy)

if privacy.IsVPN {
	fmt.Println("This IP is behind a VPN")
}
if privacy.IsTor {
	fmt.Println("This IP is a Tor exit node")
}

ips := map[string][]string{
	"ips": {"8.8.8.8", "1.1.1.1", "208.67.222.222"},
}
body, _ := json.Marshal(ips)

resp, err := http.Post(
	"https://whatismyip.technology/api/bulk",
	"application/json",
	bytes.NewReader(body),
)
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var results []IPLookup
json.NewDecoder(resp.Body).Decode(&results)

for _, r := range results {
	fmt.Printf("%s -> %s, %s\n", r.IP, r.City, r.Country)
}

package main

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

const apiBase = "https://whatismyip.technology/api/me"

func main() {
	url := apiBase
	if len(os.Args) > 1 {
		url = apiBase + "/" + os.Args[1]
	}

	resp, err := http.Get(url)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
		os.Exit(1)
	}
	defer resp.Body.Close()

	var data map[string]interface{}
	json.NewDecoder(resp.Body).Decode(&data)

	out, _ := json.MarshalIndent(data, "", "  ")
	fmt.Println(string(out))
}