GPS & GeoURI Validation in Python

1. Why GPS validation is harder than it looks

GPS coordinates look deceptively simple — just two numbers representing latitude and longitude. In practice, users enter coordinates in at least four different formats, each with its own syntax for degrees, minutes, seconds, and direction. Google Maps outputs decimal degrees, marine navigation devices use degrees and decimal minutes, aviation charts prefer degrees-minutes-seconds, and modern QR codes embed geo: URIs defined by RFC 5870.

A naive float() call handles exactly one of these formats. It raises a ValueError on DMS strings like 52°13'46.92"N, ignores direction letters, cannot distinguish latitude from longitude in a GeoURI, and produces no error when a value exceeds the valid range. The result is subtle bugs that only surface when real users paste coordinates from unfamiliar sources.

On top of format variety, there are Unicode traps. Copy-pasting from Wikipedia or a PDF often introduces prime symbols (U+2032) instead of apostrophes, double primes (U+2033) instead of quotation marks, and ring-above characters (U+02DA) instead of degree signs. These look-alike characters break strict parsers silently.

The IsValid GPS API handles all of this in a single call — four formats, Unicode normalization, direction letters, range validation, and automatic DMS conversion. You send the raw user input; it returns structured, validated coordinates.

2. Four input formats

The API auto-detects which format the input uses. You do not need to tell it — just pass the raw string and the response includes the detected format field.

Each format can include direction letters (N/S/E/W) either before or after the number. For example, N52.2297 E21.0122 and 52.2297N 21.0122E are both valid DD inputs.

There is also a dash-separated DMS variant: 52-13-46.92 N 21-0-43.92 E. This format uses hyphens instead of degree, minute, and second symbols. Because hyphens could also indicate negative values, this variant requires an explicit direction letter to avoid ambiguity.

3. Coordinate ranges

Valid GPS coordinates must fall within strict geographic bounds. Anything outside these ranges does not correspond to a real point on Earth's surface.

The API rounds all coordinates to 6 decimal places in the response. This is intentional — 6 decimal places of latitude or longitude correspond to roughly 11 centimeters of ground distance, which is more precision than most applications need.

4. Unicode normalization

One of the most common reasons coordinate parsing fails in production is Unicode look-alike characters. When users copy coordinates from Wikipedia articles, PDF documents, or desktop publishing software, the degree, prime, and double-prime symbols are often replaced by visually similar but technically different Unicode code points.

The API normalizes the following characters before parsing, so you never need to pre-process them yourself:

This is a real problem in practice. Consider the following Python code — these three strings look identical but contain different bytes:

# These look the same but use different Unicode code points:
a = '52°13\'46.92"N'    # ASCII quotes — works
b = '52°13′46.92″N'    # prime + double prime — common in Wikipedia
c = '52˚13\'46.92"N'    # ring above instead of degree — common in PDFs

# Without normalization, b and c would fail to parse.
# The IsValid API normalizes all of them to the same canonical form.

Because the API handles normalization server-side, you can pass raw clipboard content or OCR output directly. No find-and-replace preprocessing needed.

5. Direction letters — N / S / E / W

Direction letters indicate which hemisphere a coordinate falls in. They can appear in several positions depending on the format and regional convention:

The S and W direction letters produce negative coordinates internally. The API always returns the sign-based lat and lon values (negative for south and west) along with the explicit latDir and lonDir fields.

# All three refer to the same point — Sydney, Australia:
validate_gps("-33.8688 151.2093")       # negative lat = South
validate_gps("S33.8688 E151.2093")      # S prefix = South
validate_gps("33.8688S 151.2093E")      # S suffix = South

# Response for all three:
# { "lat": -33.8688, "lon": 151.2093, "latDir": "S", "lonDir": "E", ... }

6. The API response

Valid coordinate — Warsaw, Poland (DD format)

{
  "valid": true,
  "format": "dd",
  "lat": 52.2297,
  "lon": 21.0122,
  "latDir": "N",
  "lonDir": "E",
  "dms": {
    "lat": "52°13'46.92\"N",
    "lon": "21°0'43.92\"E"
  }
}

Invalid coordinate — latitude out of range

{
  "valid": false
}

7. Python code example

Using the requests library — the de facto standard for HTTP in Python. Install it with pip install requests.

# gps_validator.py
import os
import requests

API_KEY = os.environ["ISVALID_API_KEY"]
BASE_URL = "https://api.isvalid.dev"


def validate_gps(coords: str) -> dict:
    """Validate GPS coordinates using the IsValid API.

    Args:
        coords: Coordinate string in any format (DD, DDM, DMS, GeoURI).

    Returns:
        Validation result as a dictionary.

    Raises:
        requests.HTTPError: If the API returns a non-2xx status.
    """
    response = requests.get(
        f"{BASE_URL}/v0/gps",
        params={"value": coords},
        headers={"Authorization": f"Bearer {API_KEY}"},
    )
    response.raise_for_status()
    return response.json()


# ── Example usage ──────────────────────────────────────────────────────────────────────

result = validate_gps('52°13\'46.92"N 21°0\'43.92"E')

if not result["valid"]:
    print("Invalid coordinates")
else:
    print(f"Format : {result['format']}")      # "dms"
    print(f"Lat    : {result['lat']}")          # 52.2297
    print(f"Lon    : {result['lon']}")          # 21.0122
    print(f"DMS lat: {result['dms']['lat']}")   # "52°13'46.92"N"
    print(f"DMS lon: {result['dms']['lon']}")   # "21°0'43.92"E"

Validating multiple formats in a single batch:

from concurrent.futures import ThreadPoolExecutor

inputs = [
    "52.2297 21.0122",            # DD
    "52°13.782' 21°0.732'",       # DDM
    "geo:52.2297,21.0122",        # GeoURI
    "91.0000 21.0122",            # Invalid — lat > 90
]

with ThreadPoolExecutor(max_workers=4) as pool:
    results = list(pool.map(validate_gps, inputs))

for coord, r in zip(inputs, results):
    if r["valid"]:
        print(f"{coord} → {r['format']} ({r['lat']}, {r['lon']})")
    else:
        print(f"{coord} → INVALID")

In a Flask application, you might use it like this to validate location data:

# app.py (Flask)
from flask import Flask, request, jsonify

app = Flask(__name__)


@app.post("/location")
def location():
    data = request.get_json()

    try:
        result = validate_gps(data["coordinates"])
    except requests.RequestException:
        return jsonify(error="GPS validation service unavailable"), 502

    if not result["valid"]:
        return jsonify(error="Invalid GPS coordinates"), 400

    return jsonify(
        lat=result["lat"],
        lon=result["lon"],
        dms=result["dms"],
        format=result["format"],
    )

8. cURL examples

Decimal Degrees — Warsaw:

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.isvalid.dev/v0/gps?value=52.2297%2021.0122"

DMS with direction letters — Warsaw:

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.isvalid.dev/v0/gps?value=52%C2%B013%2746.92%22N%2021%C2%B00%2743.92%22E"

GeoURI (RFC 5870) — Warsaw:

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.isvalid.dev/v0/gps?value=geo%3A52.2297%2C21.0122"

9. Edge cases to handle

# North Pole — all longitudes are equivalent here
validate_gps("90.0 0.0")       # valid, lat: 90, latDir: "N"
validate_gps("90.0 180.0")     # valid, same physical point

# South Pole
validate_gps("-90.0 0.0")      # valid, lat: -90, latDir: "S"

# Both refer to the same meridian
validate_gps("0.0 180.0")      # valid, lon: 180, lonDir: "E"
validate_gps("0.0 -180.0")     # valid, lon: -180, lonDir: "W"

# But 180.001 is out of range
validate_gps("0.0 180.001")    # {"valid": False}

# GeoURI with altitude (123 meters)
result = validate_gps("geo:52.2297,21.0122,123")

# Altitude is accepted but not returned in the response
print(result["lat"])      # 52.2297
print(result["lon"])      # 21.0122
print(result["format"])   # "geo-uri"

# Dash-separated DMS — direction letter required
validate_gps("52-13-46.92 N 21-0-43.92 E")  # valid, format: "dms"

# Without direction letters, dashes are ambiguous
# The API interprets plain negative numbers as DD format:
validate_gps("-33.8688 151.2093")            # valid, format: "dd"