Auto-Locate Nearby Golf Courses on Your Map Using IP Geolocation

Saudações, caros colegas e entusiastas do **webmastersmz.com**! É um prazer estar aqui para analisar tecnicamente este tópico sobre a implementação de geolocalização por IP para localizar campos de golfe (ou qualquer outro Ponto de Interesse - POI) de forma automatizada.

Esta funcionalidade é um exemplo clássico de como podemos elevar a UX (Experiência do Utilizador) ao reduzir a fricção no preenchimento de formulários ou buscas manuais. Vamos dissecar os pontos principais desta implementação sob uma ótica técnica:

### 1. A Precisão da Geolocalização por IP vs. GPS
O ponto de partida aqui é entender que a geolocalização baseada em IP (através de bases de dados como MaxMind ou serviços como ipstack) identifica a localização do nó de saída do provedor de internet (ISP). Diferente do GPS do telemóvel, que tem uma precisão de poucos metros, o IP pode dar-nos uma margem de erro ao nível da cidade ou bairro. Para localizar campos de golfe, que são infraestruturas grandes, esta precisão costuma ser suficiente para uma "sugestão inicial".

### 2. Integração de APIs de Mapas
Para que o "Auto-Locate" funcione, não basta saber onde o utilizador está; é preciso cruzar esses dados com uma API de mapas (Google Maps API, Mapbox ou Leaflet). O fluxo técnico seria:
1.  **Captura do IP:** No backend (PHP, Python, Node.js) ou via cliente.
2.  **Lookup de Coordenadas:** Transformar o IP em Latitude/Longitude.
3.  **Spatial Query:** Realizar uma busca radial (ex: num raio de 50km) na base de dados de campos de golfe para encontrar os mais próximos das coordenadas obtidas.

### 3. Performance e Latência
Um ponto crítico que muitos webmasters esquecem é a latência. Fazer chamadas externas para APIs de geolocalização em cada carregamento de página pode tornar o site lento. A recomendação técnica aqui é o uso de **Caching**. Uma vez que o IP do utilizador é identificado, essa informação deve ser armazenada na sessão ou via cookies para evitar chamadas redundantes.

### 4. Privacidade e Ética (GDPR/LGPD)
Mesmo em Moçambique, devemos estar atentos às boas práticas de privacidade. Embora o IP seja um dado técnico, ele pode ser considerado um dado pessoal. Informar o utilizador que a sua localização está a ser estimada para melhorar a experiência é uma prática de "bom tom" e conformidade.

**Debate para o Fórum:**
Gostaria de saber da malta aqui do fórum: vocês têm implementado soluções de geolocalização nos vossos projetos em Moçambique? Como lidam com a variação de IPs das nossas operadoras (Tmcel, Vodacom, Movitel), que por vezes mostram o utilizador em Maputo quando ele está, na verdade, em Nampula ou Tete? Vamos trocar ideias sobre quais APIs têm o melhor "mapping" para a nossa região!

---

Para garantir que os vossos projetos e fóruns rodam sem falhas, convido-vos a conhecer as soluções de alojamento de alta performance da AplicHost em https://aplichost.com.

Auto-Locate Nearby Golf Courses on Your Map Using IP Geolocation



Tópico: Auto-Locate Nearby Golf Courses on Your Map Using IP Geolocation
Categoria: Tutoriais | Programação & Tecnologia
Idioma Principal: Português (Conteúdo de Tecnologia)

Descrição do Conteúdo / Informações:
-------------------------------------------------------------------------


webdev #python #javascript #maps #api #geolocation #golf #rapidapi #showhn


A recent Show HN project mapped every US golf course—16,000+ of them, free, no signup. That is a goldmine for anyone building a golf app, travel planner, or local discovery map. But a map full of pins is only useful if you know where the user is.

Instead of asking users to type in a ZIP code, you can auto-locate them from their IP address and immediately suggest nearby courses. In this post, I'll show you how to wire the IP Geolocation API (RapidAPI, GitHub) to a golf-course dataset so your app can say:

"You're in Scottsdale, AZ. Here are the 5 closest golf courses."



What we are building


• A visitor opens your web app.

• Your backend reads the visitor's IP.

• You call the IP Geolocation API to get latitude, longitude, city, and state.

• You compare that position against a local golf-course dataset using the haversine formula.

• You return the closest courses and render them on a map.

The golf-course data can come from the Show HN dataset. For this example, we'll assume a CSV like this:

name,lat,lon,city,state
TPC Scottsdale,33.6405,-111.9086,Scottsdale,AZ
Grayhawk Golf Club,33.6754,-111.8240,Scottsdale,AZ
...



Backend: Flask + IP Geolocation API


Here is a minimal Flask endpoint that does the heavy lifting.

from flask import Flask, request, jsonify
import requests
import csv
import math

app = Flask(__name__)

RAPIDAPI_KEY = "YOUR_RAPIDAPI_KEY"
GEOLOCATION_URL = "https://ip-geolocation44.p.rapidapi.com/"
COURSES_FILE = "courses.csv"

def haversine(lat1, lon1, lat2, lon2):
"""Return distance in miles between two lat/lon points."""
R = 3958.8  # Earth radius in miles

phi1 = math.radians(lat1)
phi2 = math.radians(lat2)
dphi = math.radians(lat2 - lat1)
dlambda = math.radians(lon2 - lon1)

a = (
math.sin(dphi / 2) ** 2
+ math.cos(phi1) * math.cos(phi2) * math.sin(dlambda / 2) ** 2
)
c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))

return R * c

@app.route("/api/nearby")
def nearby_courses():
# Grab the client IP, accounting for proxies like Heroku/Render/Vercel
ip = request.headers.get("X-Forwarded-For", request.remote_addr)
ip = ip.split(",")[0].strip() if ip else ""

# 1. Geolocate the IP
headers = {
"X-RapidAPI-Key": RAPIDAPI_KEY,
"X-RapidAPI-Host": "ip-geolocation44.p.rapidapi.com",
}
params = {"ip": ip}

geo_resp = requests.get(GEOLOCATION_URL, headers=headers, params=params)
geo_resp.raise_for_status()
geo = geo_resp.json()

user_lat = float(geo["latitude"])
user_lon = float(geo["longitude"])

# 2. Find the closest courses
courses = []
with open(COURSES_FILE, newline="") as f:
reader = csv.DictReader(f)
for row in reader:
d = haversine(
user_lat,
user_lon,
float(row["lat"]),
float(row["lon"]),
)
courses.append(
{
"name": row["name"],
"city": row["city"],
"state": row["state"],
"lat": float(row["lat"]),
"lon": float(row["lon"]),
"distance_mi": round(d, 1),
}
)

courses.sort(key=lambda c: c["distance_mi"])

return jsonify(
{
"user": {
"city": geo.get("city"),
"state": geo.get("region"),
"country": geo.get("country"),
"lat": user_lat,
"lon": user_lon,
},
"courses": courses[:5],
}
)

if __name__ == "__main__":
app.run(debug=True)

A request to GET /api/nearby returns JSON like:

{
"user": {
"city": "Scottsdale",
"state": "Arizona",
"country": "US",
"lat": 33.4942,
"lon": -111.9261
},
"courses": [
{
"name": "TPC Scottsdale",
"city": "Scottsdale",
"state": "AZ",
"lat": 33.6405,
"lon": -111.9086,
"distance_mi": 10.1
}
...
]
}



Frontend: Plot the results on a map


Once the backend returns the user location and nearby courses, the frontend is straightforward. Here is a minimal Leaflet example.

<!DOCTYPE html>
<html>
<head>
<link
rel="stylesheet"
href="https://unpkg.com/[email protected]/dist/leaflet.css"
/>
<script src="https://unpkg.com/[email protected]/dist/leaflet.js"></script>
<style>
#map { height: 500px; }
</style>
</head>
<body>
<div id="map"></div>
<script>
async function initMap() {
const res = await fetch("/api/nearby");
const data = await res.json();

const map = L.map("map").setView([data.user.lat, data.user.lon], 11);

L.tileLayer("https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png", {
attribution: "&copy; OpenStreetMap contributors",
}).addTo(map);

// User marker
L.marker([data.user.lat, data.user.lon])
.addTo(map)
.bindPopup(`You are here: ${data.user.city}, ${data.user.state}`)
.openPopup();

// Course markers
data.courses.forEach((course) => {
L.marker([course.lat, course.lon])
.addTo(map)
.bindPopup(
`${course.name}
${course.distance_mi} miles away`
);
});
}

initMap();
</script>
</body>
</html>



How to use IP Geolocation API


The IP Geolocation API (RapidAPI listing) geolocates any IP address and returns country, city, latitude/longitude, timezone, ISP, and ASN. It also has a dual-source fallback, so you get more reliable results than a single-source service.



cURL example


curl --request GET \
--url 'https://ip-geolocation44.p.rapidapi.com/?ip=8.8.8.8' \
--header 'X-RapidAPI-Key: YOUR_RAPIDAPI_KEY' \
--header 'X-RapidAPI-Host: ip-geolocation44.p.rapidapi.com'



Python example


import requests

url = "https://ip-geolocation44.p.rapidapi.com/"
querystring = {"ip": "8.8.8.8"}
headers = {
"X-RapidAPI-Key": "YOUR_RAPIDAPI_KEY",
"X-RapidAPI-Host": "ip-geolocation44.p.rapidapi.com",
}

response = requests.get(url, headers=headers, params=querystring)
print(response.json())

For more response fields, SDKs, and error handling, check the official docs on RapidAPI and the open-source repo at github.com/On13uka/ip-geolocation-api.



Other ways to use this combo


•
Geo-restricted content delivery: Only show US golf courses to US visitors.

•
Fraud detection by IP location: Flag bookings where the IP country does not match the billing address.

•
Analytics and visitor statistics: Track which cities drive the most golfers to your site.

•
Timezone detection for users: Schedule tee-time reminders in the user's local timezone.



Conclusion


With a free golf-course dataset and the IP Geolocation API, you can turn a static map into a personalized discovery tool in under an hour. No signup friction for the user, no manual location input, and no expensive geolocation stack.

Grab your RapidAPI key at rapidapi.com/On13uka/api/ip-geolocation44, download the Show HN course data, and start routing golfers to their next tee time automatically.

Happy hacking! ⛳