Scalable IP address API

# Default (whichever family resolves first)
curl https://api.ipme.sh

# Force IPv4 / IPv6 via DNS-only subdomains
curl https://ipv4.api.ipme.sh
curl https://ipv6.api.ipme.sh

# JSON
curl https://api.ipme.sh/json

const r = await fetch('https://api.ipme.sh/json');
const { ip } = await r.json();
console.log(ip);

import urllib.request, json

with urllib.request.urlopen('https://api.ipme.sh/json') as r:
    print(json.load(r)['ip'])

# or with requests
import requests
print(requests.get('https://api.ipme.sh').text.strip())

package main

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

func main() {
    r, _ := http.Get("https://api.ipme.sh/json")
    defer r.Body.Close()
    var out struct{ IP string }
    json.NewDecoder(r.Body).Decode(&out)
    fmt.Println(out.IP)
}

const r = await fetch('https://api.ipme.sh/json');
const { ip } = await r.json();
console.log(ip);

#!/usr/bin/env bash
# Update record only when public IP changes.
set -euo pipefail

STATE=/var/lib/ipme/last-ip
mkdir -p "$(dirname "$STATE")"
NOW=$(curl -fsS https://api.ipme.sh)
LAST=$(cat "$STATE" 2>/dev/null || true)

if [[ "$NOW" != "$LAST" ]]; then
  echo "IP changed: $LAST -> $NOW"
  # update_dns_record "$NOW"
  echo "$NOW" > "$STATE"
fi

$ip = trim(file_get_contents('https://api.ipme.sh'));
echo $ip;

// JSON
$data = json_decode(file_get_contents('https://api.ipme.sh/json'), true);
echo $data['ip'];

require 'net/http'
require 'json'

ip = Net::HTTP.get(URI('https://api.ipme.sh')).strip
puts ip

data = JSON.parse(Net::HTTP.get(URI('https://api.ipme.sh/json')))
puts data['ip']

let ip: String = ureq::get("https://api.ipme.sh")
    .call()?
    .into_string()?
    .trim()
    .to_string();
println!("{ip}");

// Java 11+
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class IpMe {
    public static void main(String[] args) throws Exception {
        var client = HttpClient.newHttpClient();
        var req = HttpRequest.newBuilder(URI.create("https://api.ipme.sh")).build();
        var res = client.send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.body().trim());
    }
}

// build.gradle.kts: implementation("com.squareup.okhttp3:okhttp:4.12.0")
import okhttp3.OkHttpClient
import okhttp3.Request

val client = OkHttpClient()
val req = Request.Builder().url("https://api.ipme.sh").build()
client.newCall(req).execute().use { res ->
    println(res.body!!.string().trim())
}

For server-side Kotlin on JVM 11+, the stdlib java.net.http.HttpClient works without OkHttp. See the Java example above.

// iOS 15+ / macOS 12+, Swift 5.5+ (async/await)
import Foundation

struct IpResponse: Decodable { let ip: String }

let url = URL(string: "https://api.ipme.sh/json")!
let (data, _) = try await URLSession.shared.data(from: url)
let ip = try JSONDecoder().decode(IpResponse.self, from: data).ip
print(ip)

// .NET 6+ (top-level statements)
using System.Text.Json;

using var http = new HttpClient();

// Text
var ip = (await http.GetStringAsync("https://api.ipme.sh")).Trim();
Console.WriteLine(ip);

// JSON
using var stream = await http.GetStreamAsync("https://api.ipme.sh/json");
var doc = await JsonDocument.ParseAsync(stream);
Console.WriteLine(doc.RootElement.GetProperty("ip").GetString());

# Text
(Invoke-WebRequest https://api.ipme.sh).Content.Trim()

# JSON (Invoke-RestMethod auto-parses)
(Invoke-RestMethod https://api.ipme.sh/json).ip

# Force IPv4 / IPv6 via DNS-only subdomains
(Invoke-RestMethod https://ipv4.api.ipme.sh/json).ip
(Invoke-RestMethod https://ipv6.api.ipme.sh/json).ip

# mix.exs: {:req, "~> 0.5"}
# or one-off: Mix.install([:req])

# Text
Req.get!("https://api.ipme.sh").body |> String.trim() |> IO.puts()

# JSON (Req auto-decodes application/json)
Req.get!("https://api.ipme.sh/json").body["ip"] |> IO.puts()

<script src="https://api.ipme.sh/jsonp?callback=showIP"></script>
<script>
  function showIP(data) { console.log(data.ip); }
</script>

For anything new, fetch is a better fit. JSONP is mostly for older clients.