update

internal/api/handlers.go

···
 	"os"
 	"path/filepath"
 	"strconv"
+	"strings"
 	"time"
 
 	"github.com/atscan/atscanner/internal/log"
···
 }
 
 func formatEndpointResponse(ep *storage.Endpoint) map[string]interface{} {
-	return map[string]interface{}{
+	response := map[string]interface{}{
 		"id":            ep.ID,
 		"endpoint_type": ep.EndpointType,
 		"endpoint":      ep.Endpoint,
···
 		"status":        statusToString(ep.Status),
 		"user_count":    ep.UserCount,
 	}
+
+	// Add IP if available
+	if ep.IP != "" {
+		response["ip"] = ep.IP
+	}
+
+	// Extract specific fields from ip_info
+	if ep.IPInfo != nil {
+		// Extract location info
+		if location, ok := ep.IPInfo["location"].(map[string]interface{}); ok {
+			if city, ok := location["city"].(string); ok {
+				response["city"] = city
+			}
+			if countryCode, ok := location["country_code"].(string); ok {
+				response["country_code"] = countryCode
+			}
+			if country, ok := location["country"].(string); ok {
+				response["country"] = country
+			}
+		}
+
+		// Extract ASN info
+		if asn, ok := ep.IPInfo["asn"].(map[string]interface{}); ok {
+			if asnNumber, ok := asn["asn"].(float64); ok {
+				response["asn"] = int(asnNumber)
+			}
+		}
+
+		// Optionally include full ip_info for detailed view
+		// response["ip_info"] = ep.IPInfo
+	}
+
+	return response
 }
 
 func statusToString(status int) string {
···
 		endpointType = "pds"
 	}
 
+	endpoint = "https://" + normalizeEndpoint(endpoint)
 	ep, err := s.db.GetEndpoint(r.Context(), endpoint, endpointType)
 	if err != nil {
 		resp.error("Endpoint not found", http.StatusNotFound)
···
 	result := formatEndpointResponse(ep)
 	result["recent_scans"] = scans
 
+	result["ipinfo"] = ep.IPInfo
 	resp.json(result)
 }
 
···
 	hash := sha256.Sum256(jsonlData)
 	return hex.EncodeToString(hash[:])
 }
+
+func normalizeEndpoint(endpoint string) string {
+	endpoint = strings.TrimPrefix(endpoint, "https://")
+	endpoint = strings.TrimPrefix(endpoint, "http://")
+	endpoint = strings.TrimSuffix(endpoint, "/")
+	return endpoint
+}

internal/ipinfo/client.go

···
+package ipinfo
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net"
+	"net/http"
+	"net/url"
+	"sync"
+	"time"
+)
+
+type Client struct {
+	httpClient      *http.Client
+	baseURL         string
+	mu              sync.RWMutex
+	backoffUntil    time.Time
+	backoffDuration time.Duration
+}
+
+func NewClient() *Client {
+	return &Client{
+		httpClient: &http.Client{
+			Timeout: 10 * time.Second,
+		},
+		baseURL:         "https://api.ipapi.is",
+		backoffDuration: 5 * time.Minute,
+	}
+}
+
+// IsInBackoff checks if we're currently in backoff period
+func (c *Client) IsInBackoff() bool {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	return time.Now().Before(c.backoffUntil)
+}
+
+// SetBackoff sets the backoff period
+func (c *Client) SetBackoff() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.backoffUntil = time.Now().Add(c.backoffDuration)
+}
+
+// ClearBackoff clears the backoff (on successful request)
+func (c *Client) ClearBackoff() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.backoffUntil = time.Time{}
+}
+
+// GetIPInfo fetches IP information from ipapi.is
+func (c *Client) GetIPInfo(ctx context.Context, ip string) (map[string]interface{}, error) {
+	// Check if we're in backoff period
+	if c.IsInBackoff() {
+		c.mu.RLock()
+		remaining := time.Until(c.backoffUntil)
+		c.mu.RUnlock()
+		return nil, fmt.Errorf("in backoff period, retry in %v", remaining.Round(time.Second))
+	}
+
+	// Build URL with IP parameter
+	reqURL := fmt.Sprintf("%s/?q=%s", c.baseURL, url.QueryEscape(ip))
+
+	req, err := http.NewRequestWithContext(ctx, "GET", reqURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		// Set backoff on network errors (timeout, etc)
+		c.SetBackoff()
+		return nil, fmt.Errorf("failed to fetch IP info: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == http.StatusTooManyRequests {
+		// Set backoff on rate limit
+		c.SetBackoff()
+		return nil, fmt.Errorf("rate limited (429), backing off for %v", c.backoffDuration)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		// Set backoff on other errors too
+		c.SetBackoff()
+		return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+	}
+
+	var ipInfo map[string]interface{}
+	if err := json.NewDecoder(resp.Body).Decode(&ipInfo); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	// Clear backoff on successful request
+	c.ClearBackoff()
+
+	return ipInfo, nil
+}
+
+// ExtractIPFromEndpoint extracts IP from endpoint URL
+func ExtractIPFromEndpoint(endpoint string) (string, error) {
+	// Parse URL
+	parsedURL, err := url.Parse(endpoint)
+	if err != nil {
+		return "", fmt.Errorf("failed to parse endpoint URL: %w", err)
+	}
+
+	host := parsedURL.Hostname()
+	if host == "" {
+		return "", fmt.Errorf("no hostname in endpoint")
+	}
+
+	// Check if host is already an IP
+	if net.ParseIP(host) != nil {
+		return host, nil
+	}
+
+	// Resolve hostname to IP
+	ips, err := net.LookupIP(host)
+	if err != nil {
+		return "", fmt.Errorf("failed to resolve hostname: %w", err)
+	}
+
+	if len(ips) == 0 {
+		return "", fmt.Errorf("no IPs found for hostname")
+	}
+
+	// Return first IPv4 address
+	for _, ip := range ips {
+		if ipv4 := ip.To4(); ipv4 != nil {
+			return ipv4.String(), nil
+		}
+	}
+
+	// Fallback to first IP (might be IPv6)
+	return ips[0].String(), nil
+}

internal/pds/scanner.go

···
 
 	"github.com/acarl005/stripansi"
 	"github.com/atscan/atscanner/internal/config"
+	"github.com/atscan/atscanner/internal/ipinfo"
 	"github.com/atscan/atscanner/internal/log"
 	"github.com/atscan/atscanner/internal/storage"
 )
 
 type Scanner struct {
-	client *Client
-	db     storage.Database
-	config config.PDSConfig
+	client       *Client
+	db           storage.Database
+	config       config.PDSConfig
+	ipInfoClient *ipinfo.Client
 }
 
 func NewScanner(db storage.Database, cfg config.PDSConfig) *Scanner {
 	return &Scanner{
-		client: NewClient(cfg.Timeout),
-		db:     db,
-		config: cfg,
+		client:       NewClient(cfg.Timeout),
+		db:           db,
+		config:       cfg,
+		ipInfoClient: ipinfo.NewClient(),
 	}
 }
 
···
 
 func (s *Scanner) scanPDS(ctx context.Context, endpointID int64, endpoint string) *PDSStatus {
 	status := &PDSStatus{
-		EndpointID:  endpointID, // Store Endpoint ID
+		EndpointID:  endpointID,
 		Endpoint:    endpoint,
-		LastChecked: time.Now(),
+		LastChecked: time.Now().UTC(),
 	}
 
 	// Health check
···
 		return status
 	}
 
+	// Fetch and update IP info if needed
+	s.updateIPInfoIfNeeded(ctx, endpointID, endpoint)
+
 	// Describe server
 	desc, err := s.client.DescribeServer(ctx, endpoint)
 	if err != nil {
···
 	}
 
 	// Optionally list repos (DIDs) - commented out by default for performance
-	/*dids, err := s.client.ListRepos(ctx, endpoint)
+	dids, err := s.client.ListRepos(ctx, endpoint)
 	if err != nil {
 		log.Verbose("Warning: failed to list repos for %s: %v", endpoint, err)
 		status.DIDs = []string{}
 	} else {
 		status.DIDs = dids
 		log.Verbose("  → Found %d users on %s", len(dids), endpoint)
-	}*/
+	}
 
 	return status
 }
+
+func (s *Scanner) updateIPInfoIfNeeded(ctx context.Context, endpointID int64, endpoint string) {
+	// Check if IP info client is in backoff
+	if s.ipInfoClient.IsInBackoff() {
+		// Silently skip during backoff period
+		return
+	}
+
+	// Extract IP from endpoint
+	ip, err := ipinfo.ExtractIPFromEndpoint(endpoint)
+	if err != nil {
+		log.Verbose("Failed to extract IP from %s: %v", endpoint, err)
+		return
+	}
+
+	// Check if we need to update IP info
+	shouldUpdate, err := s.db.ShouldUpdateIPInfo(ctx, endpointID, ip)
+	if err != nil {
+		log.Verbose("Failed to check IP info status: %v", err)
+		return
+	}
+
+	if !shouldUpdate {
+		return // IP hasn't changed, no need to fetch
+	}
+
+	// Fetch IP info from ipapi.is
+	log.Verbose("Fetching IP info for %s (%s)", endpoint, ip)
+	ipInfo, err := s.ipInfoClient.GetIPInfo(ctx, ip)
+	if err != nil {
+		// Log only once when backoff starts
+		if s.ipInfoClient.IsInBackoff() {
+			log.Info("⚠ IP info API unavailable, pausing requests for 5 minutes")
+		} else {
+			log.Verbose("Failed to fetch IP info for %s: %v", ip, err)
+		}
+		return
+	}
+
+	// Update database
+	if err := s.db.UpdateEndpointIPInfo(ctx, endpointID, ip, ipInfo); err != nil {
+		log.Error("Failed to update IP info for endpoint %d: %v", endpointID, err)
+	} else {
+		log.Verbose("✓ Updated IP info for %s: %s", endpoint, ip)
+	}
+}

internal/storage/db.go

···
 	// Endpoint operations
 	UpsertEndpoint(ctx context.Context, endpoint *Endpoint) error
 	GetEndpoint(ctx context.Context, endpoint string, endpointType string) (*Endpoint, error)
-	GetEndpointByID(ctx context.Context, id int64) (*Endpoint, error)
 	GetEndpoints(ctx context.Context, filter *EndpointFilter) ([]*Endpoint, error)
 	UpdateEndpointStatus(ctx context.Context, endpointID int64, update *EndpointUpdate) error
 	EndpointExists(ctx context.Context, endpoint string, endpointType string) (bool, error)
 	GetEndpointIDByEndpoint(ctx context.Context, endpoint string, endpointType string) (int64, error)
 	GetEndpointScans(ctx context.Context, endpointID int64, limit int) ([]*EndpointScan, error)
+
+	// IP info operations
+	ShouldUpdateIPInfo(ctx context.Context, endpointID int64, currentIP string) (bool, error)
+	UpdateEndpointIPInfo(ctx context.Context, endpointID int64, ip string, ipInfo map[string]interface{}) error
 
 	// Cursor operations
 	GetScanCursor(ctx context.Context, source string) (*ScanCursor, error)

internal/storage/postgres.go

···
         last_checked TIMESTAMP,
         status INTEGER DEFAULT 0,
         user_count BIGINT DEFAULT 0,
+        ip TEXT,
+        ip_info JSONB,
         updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
         UNIQUE(endpoint_type, endpoint)
     );
···
     CREATE INDEX IF NOT EXISTS idx_endpoints_status ON endpoints(status);
     CREATE INDEX IF NOT EXISTS idx_endpoints_type ON endpoints(endpoint_type);
     CREATE INDEX IF NOT EXISTS idx_endpoints_user_count ON endpoints(user_count);
+    CREATE INDEX IF NOT EXISTS idx_endpoints_ip ON endpoints(ip);
+    CREATE INDEX IF NOT EXISTS idx_endpoints_ip_info ON endpoints USING gin(ip_info);
 
     CREATE TABLE IF NOT EXISTS pds_scans (
         id BIGSERIAL PRIMARY KEY,
···
 // ===== ENDPOINT OPERATIONS =====
 
 func (p *PostgresDB) UpsertEndpoint(ctx context.Context, endpoint *Endpoint) error {
+	var ipInfoJSON []byte
+	var err error
+	if endpoint.IPInfo != nil {
+		ipInfoJSON, err = json.Marshal(endpoint.IPInfo)
+		if err != nil {
+			return fmt.Errorf("failed to marshal ip_info: %w", err)
+		}
+	}
+
 	query := `
-        INSERT INTO endpoints (endpoint_type, endpoint, discovered_at, last_checked, status)
-        VALUES ($1, $2, $3, $4, $5)
+        INSERT INTO endpoints (endpoint_type, endpoint, discovered_at, last_checked, status, ip, ip_info)
+        VALUES ($1, $2, $3, $4, $5, $6, $7)
         ON CONFLICT(endpoint_type, endpoint) DO UPDATE SET
-            last_checked = EXCLUDED.last_checked
+            last_checked = EXCLUDED.last_checked,
+            ip = CASE 
+                WHEN EXCLUDED.ip IS NOT NULL AND EXCLUDED.ip != '' THEN EXCLUDED.ip 
+                ELSE endpoints.ip 
+            END,
+            ip_info = CASE 
+                WHEN EXCLUDED.ip_info IS NOT NULL THEN EXCLUDED.ip_info 
+                ELSE endpoints.ip_info 
+            END
         RETURNING id
     `
-	err := p.db.QueryRowContext(ctx, query,
+	err = p.db.QueryRowContext(ctx, query,
 		endpoint.EndpointType, endpoint.Endpoint, endpoint.DiscoveredAt,
-		endpoint.LastChecked, endpoint.Status).Scan(&endpoint.ID)
+		endpoint.LastChecked, endpoint.Status, endpoint.IP, ipInfoJSON).Scan(&endpoint.ID)
 	return err
 }
 
···
 
 func (p *PostgresDB) GetEndpoint(ctx context.Context, endpoint string, endpointType string) (*Endpoint, error) {
 	query := `
-        SELECT id, endpoint_type, endpoint, discovered_at, last_checked, status, user_count, updated_at
+        SELECT id, endpoint_type, endpoint, discovered_at, last_checked, status, user_count, 
+               ip, ip_info, updated_at
         FROM endpoints 
         WHERE endpoint = $1 AND endpoint_type = $2
     `
 
 	var ep Endpoint
 	var lastChecked sql.NullTime
+	var ip sql.NullString
+	var ipInfoJSON []byte
 
 	err := p.db.QueryRowContext(ctx, query, endpoint, endpointType).Scan(
 		&ep.ID, &ep.EndpointType, &ep.Endpoint, &ep.DiscoveredAt, &lastChecked,
-		&ep.Status, &ep.UserCount, &ep.UpdatedAt,
+		&ep.Status, &ep.UserCount, &ip, &ipInfoJSON, &ep.UpdatedAt,
 	)
 	if err != nil {
 		return nil, err
···
 		ep.LastChecked = lastChecked.Time
 	}
 
-	return &ep, nil
-}
-
-func (p *PostgresDB) GetEndpointByID(ctx context.Context, id int64) (*Endpoint, error) {
-	query := `
-        SELECT id, endpoint_type, endpoint, discovered_at, last_checked, status, user_count, updated_at
-        FROM endpoints 
-        WHERE id = $1
-    `
-
-	var ep Endpoint
-	var lastChecked sql.NullTime
-
-	err := p.db.QueryRowContext(ctx, query, id).Scan(
-		&ep.ID, &ep.EndpointType, &ep.Endpoint, &ep.DiscoveredAt, &lastChecked,
-		&ep.Status, &ep.UserCount, &ep.UpdatedAt,
-	)
-	if err != nil {
-		return nil, err
+	if ip.Valid {
+		ep.IP = ip.String
 	}
 
-	if lastChecked.Valid {
-		ep.LastChecked = lastChecked.Time
+	if len(ipInfoJSON) > 0 {
+		var ipInfo map[string]interface{}
+		if err := json.Unmarshal(ipInfoJSON, &ipInfo); err == nil {
+			ep.IPInfo = ipInfo
+		}
 	}
 
 	return &ep, nil
···
 
 func (p *PostgresDB) GetEndpoints(ctx context.Context, filter *EndpointFilter) ([]*Endpoint, error) {
 	query := `
-        SELECT id, endpoint_type, endpoint, discovered_at, last_checked, status, user_count, updated_at
+        SELECT id, endpoint_type, endpoint, discovered_at, last_checked, status, user_count, 
+               ip, ip_info, updated_at
         FROM endpoints
         WHERE 1=1
     `
···
 	for rows.Next() {
 		var ep Endpoint
 		var lastChecked sql.NullTime
+		var ip sql.NullString
+		var ipInfoJSON []byte
 
 		err := rows.Scan(
 			&ep.ID, &ep.EndpointType, &ep.Endpoint, &ep.DiscoveredAt, &lastChecked,
-			&ep.Status, &ep.UserCount, &ep.UpdatedAt,
+			&ep.Status, &ep.UserCount, &ip, &ipInfoJSON, &ep.UpdatedAt,
 		)
 		if err != nil {
 			return nil, err
···
 
 		if lastChecked.Valid {
 			ep.LastChecked = lastChecked.Time
+		}
+
+		if ip.Valid {
+			ep.IP = ip.String
+		}
+
+		if len(ipInfoJSON) > 0 {
+			var ipInfo map[string]interface{}
+			if err := json.Unmarshal(ipInfoJSON, &ipInfo); err == nil {
+				ep.IPInfo = ipInfo
+			}
 		}
 
 		endpoints = append(endpoints, &ep)
···
         SET status = $1, last_checked = $2, user_count = $3, updated_at = $4
         WHERE id = $5
     `
-	_, err = tx.ExecContext(ctx, query, update.Status, update.LastChecked, userCount, time.Now(), endpointID)
+	_, err = tx.ExecContext(ctx, query, update.Status, update.LastChecked, userCount, time.Now().UTC(), endpointID)
 	if err != nil {
 		return err
 	}
···
 		return err
 	}
 
+	// Keep only the 3 most recent scans per endpoint
+	cleanupQuery := `
+        DELETE FROM pds_scans 
+        WHERE pds_id = $1 
+        AND id NOT IN (
+            SELECT id FROM pds_scans 
+            WHERE pds_id = $1 
+            ORDER BY scanned_at DESC 
+            LIMIT 3
+        )
+    `
+	_, err = tx.ExecContext(ctx, cleanupQuery, endpointID)
+	if err != nil {
+		return err
+	}
+
 	return tx.Commit()
 }
 
···
 	}
 
 	return &stats, err
+}
+
+// Add method to check if IP needs update
+func (p *PostgresDB) ShouldUpdateIPInfo(ctx context.Context, endpointID int64, currentIP string) (bool, error) {
+	query := `SELECT ip FROM endpoints WHERE id = $1`
+
+	var storedIP sql.NullString
+	err := p.db.QueryRowContext(ctx, query, endpointID).Scan(&storedIP)
+	if err != nil {
+		return false, err
+	}
+
+	// Update if no IP stored or IP changed
+	return !storedIP.Valid || storedIP.String != currentIP, nil
+}
+
+// Update IP info for an endpoint
+func (p *PostgresDB) UpdateEndpointIPInfo(ctx context.Context, endpointID int64, ip string, ipInfo map[string]interface{}) error {
+	ipInfoJSON, err := json.Marshal(ipInfo)
+	if err != nil {
+		return fmt.Errorf("failed to marshal ip_info: %w", err)
+	}
+
+	query := `
+        UPDATE endpoints 
+        SET ip = $1, ip_info = $2, updated_at = $3
+        WHERE id = $4
+    `
+	_, err = p.db.ExecContext(ctx, query, ip, ipInfoJSON, time.Now(), endpointID)
+	return err
 }
 
 // ===== CURSOR OPERATIONS =====

internal/storage/types.go

···
 	LastChecked  time.Time
 	Status       int
 	UserCount    int64
+	IP           string
+	IPInfo       map[string]interface{}
 	UpdatedAt    time.Time
 }