What Is My IP API? Get the Caller's Public IP with getip

import http.client
import ipaddress
import json
import urllib.request

GETIP_URL = "https://api.ipgeolocation.io/v3/getip"


def get_public_ip(timeout: float = 10.0) -> str:
    """Return the public IP of the machine running this code."""
    try:
        with urllib.request.urlopen(GETIP_URL, timeout=timeout) as response:
            payload = json.load(response)
    except (OSError, ValueError, http.client.HTTPException) as exc:  # network, timeout, bad reply
        raise RuntimeError(f"getip request failed: {exc}") from exc

    ip = payload.get("ip") if isinstance(payload, dict) else None
    try:
        # Check the value before the rest of your code relies on it
        return str(ipaddress.ip_address(str(ip)))
    except ValueError as exc:
        raise RuntimeError(f"getip returned an unexpected value: {ip!r}") from exc


if __name__ == "__main__":
    try:
        print(get_public_ip())
    except RuntimeError as err:
        raise SystemExit(f"Could not get the public IP: {err}")

import { isIP } from "node:net";

const GETIP_URL = "https://api.ipgeolocation.io/v3/getip";

async function getPublicIp() {
  // Give up after 10 seconds so a stalled network can't hang the script
  const response = await fetch(GETIP_URL, { signal: AbortSignal.timeout(10000) });
  if (!response.ok) {
    throw new Error(`getip returned HTTP ${response.status}`);
  }
  const data = await response.json();
  const ip = data?.ip;
  if (!isIP(ip ?? "")) {
    throw new Error(`getip returned an unexpected value: ${ip}`);
  }
  return ip;
}

try {
  console.log(await getPublicIp());
} catch (err) {
  console.error("Could not get the public IP:", err.message);
  process.exitCode = 1;
}

<p>Your public IP: <span id="visitor-ip">checking...</span></p>
<script>
  // Runs in the visitor's browser, so getip returns the visitor's IP
  (async () => {
    const el = document.getElementById("visitor-ip");
    try {
      const response = await fetch("https://api.ipgeolocation.io/v3/getip", {
        signal: AbortSignal.timeout(10000),
      });
      if (!response.ok) throw new Error(`HTTP ${response.status}`);
      const data = await response.json();
      el.textContent = data?.ip ?? "unavailable";
    } catch (err) {
      el.textContent = "unavailable";
      console.warn("getip failed:", err);
    }
  })();
</script>

package main

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

const getipURL = "https://api.ipgeolocation.io/v3/getip"

func getPublicIP() (netip.Addr, error) {
	client := &http.Client{Timeout: 10 * time.Second}
	resp, err := client.Get(getipURL)
	if err != nil {
		return netip.Addr{}, fmt.Errorf("request failed: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return netip.Addr{}, fmt.Errorf("unexpected status: %s", resp.Status)
	}

	var body struct {
		IP string `json:"ip"`
	}
	if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
		return netip.Addr{}, fmt.Errorf("decoding response: %w", err)
	}

	addr, err := netip.ParseAddr(body.IP)
	if err != nil {
		return netip.Addr{}, fmt.Errorf("getip returned an unexpected value: %q", body.IP)
	}
	return addr, nil
}

func main() {
	ip, err := getPublicIP()
	if err != nil {
		fmt.Fprintln(os.Stderr, "Could not get the public IP:", err)
		os.Exit(1)
	}
	fmt.Println(ip)
}

<?php

function getPublicIp(int $timeoutSeconds = 10): string
{
    $ch = curl_init('https://api.ipgeolocation.io/v3/getip');
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT        => $timeoutSeconds,
        CURLOPT_FAILONERROR    => true, // treat HTTP 4xx and 5xx as errors
    ]);
    $body = curl_exec($ch);

    if ($body === false) {
        throw new RuntimeException('getip request failed: ' . curl_error($ch));
    }

    $data = json_decode($body, true);
    $ip = is_array($data) ? ($data['ip'] ?? null) : null;

    if (!is_string($ip) || filter_var($ip, FILTER_VALIDATE_IP) === false) {
        throw new RuntimeException('getip returned an unexpected value');
    }
    return $ip;
}

try {
    echo getPublicIp(), PHP_EOL;
} catch (RuntimeException $e) {
    fwrite(STDERR, 'Could not get the public IP: ' . $e->getMessage() . PHP_EOL);
    exit(1);
}

#!/usr/bin/env bash
# Run from cron, for example every 10 minutes: */10 * * * * bash /path/to/check-ip.sh
set -euo pipefail

STATE_FILE="${HOME}/.last_public_ip"

# --retry waits longer between attempts after a timeout or a temporary HTTP error
if ! new_ip=$(curl -sS --fail --max-time 10 --retry 3 \
    "https://api.ipgeolocation.io/v3/getip?output=text"); then
  echo "getip failed; keeping the last known IP" >&2
  exit 1
fi

# Accept only a dotted-quad value, never an error page
if [[ ! "$new_ip" =~ ^([0-9]{1,3}\.){3}[0-9]{1,3}$ ]]; then
  echo "unexpected response from getip" >&2
  exit 1
fi

old_ip=$(cat "$STATE_FILE" 2>/dev/null || true)
if [[ "$new_ip" != "$old_ip" ]]; then
  echo "Public IP changed from ${old_ip:-unknown} to $new_ip"
  # Update your DNS record or allowlist here, then save the new value
  printf '%s' "$new_ip" > "$STATE_FILE"
fi

# Your address without the proxy
curl -sS --fail --max-time 10 "https://api.ipgeolocation.io/v3/getip?output=text"; echo

# The same request through the proxy
curl -sS --fail --max-time 10 \
  --proxy proxy.example.com:8080 \
  --proxy-user "$PROXY_USER:$PROXY_PASS" \
  "https://api.ipgeolocation.io/v3/getip?output=text"; echo