update

internal/api/handlers.go

···
 		if pds.IPInfo.ASN > 0 {
 			response["asn"] = pds.IPInfo.ASN
 		}
-		if pds.IPInfo.IsDatacenter {
-			response["is_datacenter"] = pds.IPInfo.IsDatacenter
-		}
+
+		// Add all network type flags
+		response["is_datacenter"] = pds.IPInfo.IsDatacenter
+		response["is_vpn"] = pds.IPInfo.IsVPN
+		response["is_crawler"] = pds.IPInfo.IsCrawler
+		response["is_tor"] = pds.IPInfo.IsTor
+		response["is_proxy"] = pds.IPInfo.IsProxy
+
+		// Add computed is_home field
+		response["is_home"] = pds.IPInfo.IsHome()
 	}
 
 	return response
···
 		}
 	}
 
-	// Add full IP info
+	// Add full IP info with computed is_home field
 	if pds.IPInfo != nil {
-		response["ip_info"] = pds.IPInfo
+		// Convert IPInfo to map
+		ipInfoMap := make(map[string]interface{})
+		ipInfoJSON, _ := json.Marshal(pds.IPInfo)
+		json.Unmarshal(ipInfoJSON, &ipInfoMap)
+
+		// Add computed is_home field
+		ipInfoMap["is_home"] = pds.IPInfo.IsHome()
+
+		response["ip_info"] = ipInfoMap
 	}
 
 	return response

internal/ipinfo/client.go

···
 	return ipInfo, nil
 }
 
-// ExtractIPFromEndpoint extracts IP from endpoint URL
-func ExtractIPFromEndpoint(endpoint string) (string, error) {
+// IPAddresses holds both IPv4 and IPv6 addresses
+type IPAddresses struct {
+	IPv4 string
+	IPv6 string
+}
+
+// ExtractIPsFromEndpoint extracts both IPv4 and IPv6 from endpoint URL
+func ExtractIPsFromEndpoint(endpoint string) (*IPAddresses, error) {
 	// Parse URL
 	parsedURL, err := url.Parse(endpoint)
 	if err != nil {
-		return "", fmt.Errorf("failed to parse endpoint URL: %w", err)
+		return nil, fmt.Errorf("failed to parse endpoint URL: %w", err)
 	}
 
 	host := parsedURL.Hostname()
 	if host == "" {
-		return "", fmt.Errorf("no hostname in endpoint")
+		return nil, fmt.Errorf("no hostname in endpoint")
 	}
+
+	result := &IPAddresses{}
 
 	// Check if host is already an IP
-	if net.ParseIP(host) != nil {
-		return host, nil
+	if ip := net.ParseIP(host); ip != nil {
+		if ip.To4() != nil {
+			result.IPv4 = host
+		} else {
+			result.IPv6 = host
+		}
+		return result, nil
 	}
 
-	// Resolve hostname to IP
+	// Resolve hostname to IPs
 	ips, err := net.LookupIP(host)
 	if err != nil {
-		return "", fmt.Errorf("failed to resolve hostname: %w", err)
+		return nil, fmt.Errorf("failed to resolve hostname: %w", err)
 	}
 
 	if len(ips) == 0 {
-		return "", fmt.Errorf("no IPs found for hostname")
+		return nil, fmt.Errorf("no IPs found for hostname")
 	}
 
-	// Return first IPv4 address
+	// Extract both IPv4 and IPv6
 	for _, ip := range ips {
 		if ipv4 := ip.To4(); ipv4 != nil {
-			return ipv4.String(), nil
+			if result.IPv4 == "" {
+				result.IPv4 = ipv4.String()
+			}
+		} else {
+			if result.IPv6 == "" {
+				result.IPv6 = ip.String()
+			}
 		}
 	}
 
-	// Fallback to first IP (might be IPv6)
-	return ips[0].String(), nil
+	// Must have at least one IP
+	if result.IPv4 == "" && result.IPv6 == "" {
+		return nil, fmt.Errorf("no valid IPs found")
+	}
+
+	return result, nil
 }

internal/pds/scanner.go

···
 }
 
 func (s *Scanner) scanAndSaveEndpoint(ctx context.Context, ep *storage.Endpoint) {
-	// STEP 1: Resolve IP (before any network call)
-	ip, err := ipinfo.ExtractIPFromEndpoint(ep.Endpoint)
+	// STEP 1: Resolve IPs (both IPv4 and IPv6)
+	ips, err := ipinfo.ExtractIPsFromEndpoint(ep.Endpoint)
 	if err != nil {
 		// Mark as offline due to DNS failure
 		s.saveScanResult(ctx, ep.ID, &ScanResult{
···
 		return
 	}
 
-	// Update IP immediately
-	s.db.UpdateEndpointIP(ctx, ep.ID, ip, time.Now().UTC())
+	// Update IPs immediately
+	s.db.UpdateEndpointIPs(ctx, ep.ID, ips.IPv4, ips.IPv6, time.Now().UTC())
 
-	// STEP 1.5: Fetch IP info asynchronously ASAP (runs in parallel with scanning)
-	go s.updateIPInfoIfNeeded(ctx, ip)
+	// STEP 1.5: Fetch IP info asynchronously for both IPs
+	if ips.IPv4 != "" {
+		go s.updateIPInfoIfNeeded(ctx, ips.IPv4)
+	}
+	if ips.IPv6 != "" {
+		go s.updateIPInfoIfNeeded(ctx, ips.IPv6)
+	}
 
-	// STEP 2: Health check
+	// STEP 2: Health check (rest remains the same)
 	available, responseTime, version, err := s.client.CheckHealth(ctx, ep.Endpoint)
 	if err != nil || !available {
 		errMsg := "health check failed"

internal/storage/db.go

···
 	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)
-	UpdateEndpointIP(ctx context.Context, endpointID int64, ip string, resolvedAt time.Time) error
+	UpdateEndpointIPs(ctx context.Context, endpointID int64, ipv4, ipv6 string, resolvedAt time.Time) error
 	SaveEndpointScan(ctx context.Context, scan *EndpointScan) error
 	SetScanRetention(retention int)
 	UpdateEndpointStatus(ctx context.Context, endpointID int64, update *EndpointUpdate) error

internal/storage/postgres.go

···
 	log.Info("Running database migrations...")
 
 	schema := `
-    -- Endpoints table (NO user_count, NO ip_info)
-    CREATE TABLE IF NOT EXISTS endpoints (
-        id BIGSERIAL PRIMARY KEY,
-        endpoint_type TEXT NOT NULL DEFAULT 'pds',
-        endpoint TEXT NOT NULL,
-        server_did TEXT,
-        discovered_at TIMESTAMP NOT NULL,
-        last_checked TIMESTAMP,
-        status INTEGER DEFAULT 0,
-        ip TEXT,
-        ip_resolved_at TIMESTAMP,
-        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        UNIQUE(endpoint_type, endpoint)
-    );
+	-- Endpoints table (NO user_count, NO ip_info)
+	CREATE TABLE IF NOT EXISTS endpoints (
+		id BIGSERIAL PRIMARY KEY,
+		endpoint_type TEXT NOT NULL DEFAULT 'pds',
+		endpoint TEXT NOT NULL,
+		server_did TEXT,
+		discovered_at TIMESTAMP NOT NULL,
+		last_checked TIMESTAMP,
+		status INTEGER DEFAULT 0,
+		ip TEXT,
+		ipv6 TEXT,
+		ip_resolved_at TIMESTAMP,
+		updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+		UNIQUE(endpoint_type, endpoint)
+	);
 
-    CREATE INDEX IF NOT EXISTS idx_endpoints_type_endpoint ON endpoints(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_ip ON endpoints(ip);
-    CREATE INDEX IF NOT EXISTS idx_endpoints_server_did ON endpoints(server_did);
+	CREATE INDEX IF NOT EXISTS idx_endpoints_type_endpoint ON endpoints(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_ip ON endpoints(ip);
+	CREATE INDEX IF NOT EXISTS idx_endpoints_ipv6 ON endpoints(ipv6);
+	CREATE INDEX IF NOT EXISTS idx_endpoints_server_did ON endpoints(server_did);
 	CREATE INDEX IF NOT EXISTS idx_endpoints_server_did_type_discovered ON endpoints(server_did, endpoint_type, discovered_at);
 
-    -- IP infos table (IP as PRIMARY KEY)
-    CREATE TABLE IF NOT EXISTS ip_infos (
-        ip TEXT PRIMARY KEY,
-        city TEXT,
-        country TEXT,
-        country_code TEXT,
-        asn INTEGER,
-        asn_org TEXT,
-        is_datacenter BOOLEAN,
-        is_vpn BOOLEAN,
-        latitude REAL,
-        longitude REAL,
-        raw_data JSONB,
-        fetched_at TIMESTAMP NOT NULL,
-        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-    );
+	-- IP infos table (IP as PRIMARY KEY)
+	CREATE TABLE IF NOT EXISTS ip_infos (
+		ip TEXT PRIMARY KEY,
+		city TEXT,
+		country TEXT,
+		country_code TEXT,
+		asn INTEGER,
+		asn_org TEXT,
+		is_datacenter BOOLEAN,
+		is_vpn BOOLEAN,
+		is_crawler BOOLEAN,
+		is_tor BOOLEAN,
+		is_proxy BOOLEAN,
+		latitude REAL,
+		longitude REAL,
+		raw_data JSONB,
+		fetched_at TIMESTAMP NOT NULL,
+		updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+	);
 
-    CREATE INDEX IF NOT EXISTS idx_ip_infos_country_code ON ip_infos(country_code);
-    CREATE INDEX IF NOT EXISTS idx_ip_infos_asn ON ip_infos(asn);
+	CREATE INDEX IF NOT EXISTS idx_ip_infos_country_code ON ip_infos(country_code);
+	CREATE INDEX IF NOT EXISTS idx_ip_infos_asn ON ip_infos(asn);
 
     -- Endpoint scans (renamed from pds_scans)
 	CREATE TABLE IF NOT EXISTS endpoint_scans (
···
 
 func (p *PostgresDB) UpsertEndpoint(ctx context.Context, endpoint *Endpoint) error {
 	query := `
-        INSERT INTO endpoints (endpoint_type, endpoint, discovered_at, last_checked, status, ip, ip_resolved_at)
-        VALUES ($1, $2, $3, $4, $5, $6, $7)
+        INSERT INTO endpoints (endpoint_type, endpoint, discovered_at, last_checked, status, ip, ipv6, ip_resolved_at)
+        VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
         ON CONFLICT(endpoint_type, endpoint) DO UPDATE SET
             last_checked = EXCLUDED.last_checked,
             status = EXCLUDED.status,
···
                 WHEN EXCLUDED.ip IS NOT NULL AND EXCLUDED.ip != '' THEN EXCLUDED.ip 
                 ELSE endpoints.ip 
             END,
+            ipv6 = CASE 
+                WHEN EXCLUDED.ipv6 IS NOT NULL AND EXCLUDED.ipv6 != '' THEN EXCLUDED.ipv6 
+                ELSE endpoints.ipv6 
+            END,
             ip_resolved_at = CASE
-                WHEN EXCLUDED.ip IS NOT NULL AND EXCLUDED.ip != '' THEN EXCLUDED.ip_resolved_at
+                WHEN (EXCLUDED.ip IS NOT NULL AND EXCLUDED.ip != '') OR (EXCLUDED.ipv6 IS NOT NULL AND EXCLUDED.ipv6 != '') THEN EXCLUDED.ip_resolved_at
                 ELSE endpoints.ip_resolved_at
             END,
             updated_at = CURRENT_TIMESTAMP
···
     `
 	err := p.db.QueryRowContext(ctx, query,
 		endpoint.EndpointType, endpoint.Endpoint, endpoint.DiscoveredAt,
-		endpoint.LastChecked, endpoint.Status, endpoint.IP, endpoint.IPResolvedAt).Scan(&endpoint.ID)
+		endpoint.LastChecked, endpoint.Status, endpoint.IP, endpoint.IPv6, endpoint.IPResolvedAt).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, 
-               ip, ip_resolved_at, updated_at
+               ip, ipv6, ip_resolved_at, updated_at
         FROM endpoints 
         WHERE endpoint = $1 AND endpoint_type = $2
     `
 
 	var ep Endpoint
 	var lastChecked, ipResolvedAt sql.NullTime
-	var ip sql.NullString
+	var ip, ipv6 sql.NullString
 
 	err := p.db.QueryRowContext(ctx, query, endpoint, endpointType).Scan(
 		&ep.ID, &ep.EndpointType, &ep.Endpoint, &ep.DiscoveredAt, &lastChecked,
-		&ep.Status, &ip, &ipResolvedAt, &ep.UpdatedAt,
+		&ep.Status, &ip, &ipv6, &ipResolvedAt, &ep.UpdatedAt,
 	)
 	if err != nil {
 		return nil, err
···
 	if ip.Valid {
 		ep.IP = ip.String
 	}
+	if ipv6.Valid {
+		ep.IPv6 = ipv6.String
+	}
 	if ipResolvedAt.Valid {
 		ep.IPResolvedAt = ipResolvedAt.Time
 	}
···
 
 func (p *PostgresDB) GetEndpoints(ctx context.Context, filter *EndpointFilter) ([]*Endpoint, error) {
 	query := `
-		SELECT DISTINCT ON (COALESCE(server_did, id::text))
-			id, endpoint_type, endpoint, server_did, discovered_at, last_checked, status, 
-			ip, ip_resolved_at, updated_at
-		FROM endpoints
-		WHERE 1=1
+	SELECT DISTINCT ON (COALESCE(server_did, id::text))
+		id, endpoint_type, endpoint, server_did, discovered_at, last_checked, status, 
+		ip, ipv6, ip_resolved_at, updated_at
+	FROM endpoints
+	WHERE 1=1
 	`
 	args := []interface{}{}
 	argIdx := 1
···
 	for rows.Next() {
 		var ep Endpoint
 		var lastChecked, ipResolvedAt sql.NullTime
-		var ip, serverDID sql.NullString
+		var ip, ipv6, serverDID sql.NullString
 
 		err := rows.Scan(
 			&ep.ID, &ep.EndpointType, &ep.Endpoint, &serverDID, &ep.DiscoveredAt, &lastChecked,
-			&ep.Status, &ip, &ipResolvedAt, &ep.UpdatedAt,
+			&ep.Status, &ip, &ipv6, &ipResolvedAt, &ep.UpdatedAt,
 		)
 		if err != nil {
 			return nil, err
···
 		}
 		if ip.Valid {
 			ep.IP = ip.String
+		}
+		if ipv6.Valid {
+			ep.IPv6 = ipv6.String
 		}
 		if ipResolvedAt.Valid {
 			ep.IPResolvedAt = ipResolvedAt.Time
···
 	return err
 }
 
-func (p *PostgresDB) UpdateEndpointIP(ctx context.Context, endpointID int64, ip string, resolvedAt time.Time) error {
+func (p *PostgresDB) UpdateEndpointIPs(ctx context.Context, endpointID int64, ipv4, ipv6 string, resolvedAt time.Time) error {
 	query := `
         UPDATE endpoints 
-        SET ip = $1, ip_resolved_at = $2, updated_at = $3
-        WHERE id = $4
+        SET ip = $1, ipv6 = $2, ip_resolved_at = $3, updated_at = $4
+        WHERE id = $5
     `
-	_, err := p.db.ExecContext(ctx, query, ip, resolvedAt, time.Now().UTC(), endpointID)
+	_, err := p.db.ExecContext(ctx, query, ipv4, ipv6, resolvedAt, time.Now().UTC(), endpointID)
 	return err
 }
 
···
 			e.id, e.endpoint, e.server_did, e.discovered_at, e.last_checked, e.status, e.ip,
 			latest.user_count, latest.response_time, latest.version, latest.scanned_at,
 			i.city, i.country, i.country_code, i.asn, i.asn_org,
-			i.is_datacenter, i.is_vpn, i.latitude, i.longitude
+			i.is_datacenter, i.is_vpn, i.is_crawler, i.is_tor, i.is_proxy,
+			i.latitude, i.longitude
 		FROM unique_servers e
 		LEFT JOIN LATERAL (
 			SELECT 
···
 		item := &PDSListItem{}
 		var ip, serverDID, city, country, countryCode, asnOrg sql.NullString
 		var asn sql.NullInt32
-		var isDatacenter, isVPN sql.NullBool
+		var isDatacenter, isVPN, isCrawler, isTor, isProxy sql.NullBool
 		var lat, lon sql.NullFloat64
 		var userCount sql.NullInt32
 		var responseTime sql.NullFloat64
···
 			&item.ID, &item.Endpoint, &serverDID, &item.DiscoveredAt, &item.LastChecked, &item.Status, &ip,
 			&userCount, &responseTime, &version, &scannedAt,
 			&city, &country, &countryCode, &asn, &asnOrg,
-			&isDatacenter, &isVPN, &lat, &lon,
+			&isDatacenter, &isVPN, &isCrawler, &isTor, &isProxy,
+			&lat, &lon,
 		)
 		if err != nil {
 			return nil, err
···
 				ASNOrg:       asnOrg.String,
 				IsDatacenter: isDatacenter.Bool,
 				IsVPN:        isVPN.Bool,
+				IsCrawler:    isCrawler.Bool,
+				IsTor:        isTor.Bool,
+				IsProxy:      isProxy.Bool,
 				Latitude:     float32(lat.Float64),
 				Longitude:    float32(lon.Float64),
 			}
···
 			latest.scan_data->'metadata'->'server_info' as server_info,
 			latest.scanned_at,
 			i.city, i.country, i.country_code, i.asn, i.asn_org,
-			i.is_datacenter, i.is_vpn, i.latitude, i.longitude,
+			i.is_datacenter, i.is_vpn, i.is_crawler, i.is_tor, i.is_proxy,
+			i.latitude, i.longitude,
 			i.raw_data,
 			COALESCE(aa.aliases, ARRAY[]::text[]) as aliases,
 			aa.first_discovered_at
···
 	detail := &PDSDetail{}
 	var ip, city, country, countryCode, asnOrg, serverDID sql.NullString
 	var asn sql.NullInt32
-	var isDatacenter, isVPN sql.NullBool
+	var isDatacenter, isVPN, isCrawler, isTor, isProxy sql.NullBool
 	var lat, lon sql.NullFloat64
 	var userCount sql.NullInt32
 	var responseTime sql.NullFloat64
···
 		&detail.ID, &detail.Endpoint, &serverDID, &detail.DiscoveredAt, &detail.LastChecked, &detail.Status, &ip,
 		&userCount, &responseTime, &version, &serverInfoJSON, &scannedAt,
 		&city, &country, &countryCode, &asn, &asnOrg,
-		&isDatacenter, &isVPN, &lat, &lon,
+		&isDatacenter, &isVPN, &isCrawler, &isTor, &isProxy,
+		&lat, &lon,
 		&rawDataJSON,
 		pq.Array(&aliases),
 		&firstDiscoveredAt,
···
 		}
 	}
 
-	// Parse IP info
+	// Parse IP info with all fields
 	if city.Valid || country.Valid {
 		detail.IPInfo = &IPInfo{
 			IP:           ip.String,
···
 			ASNOrg:       asnOrg.String,
 			IsDatacenter: isDatacenter.Bool,
 			IsVPN:        isVPN.Bool,
+			IsCrawler:    isCrawler.Bool,
+			IsTor:        isTor.Bool,
+			IsProxy:      isProxy.Bool,
 			Latitude:     float32(lat.Float64),
 			Longitude:    float32(lon.Float64),
 		}
···
 		isVPN = val
 	}
 
+	isCrawler := false
+	if val, ok := ipInfo["is_crawler"].(bool); ok {
+		isCrawler = val
+	}
+
+	isTor := false
+	if val, ok := ipInfo["is_tor"].(bool); ok {
+		isTor = val
+	}
+
+	isProxy := false
+	if val, ok := ipInfo["is_proxy"].(bool); ok {
+		isProxy = val
+	}
+
 	lat := extractFloat(ipInfo, "location", "latitude")
 	lon := extractFloat(ipInfo, "location", "longitude")
 
 	query := `
-        INSERT INTO ip_infos (ip, city, country, country_code, asn, asn_org, is_datacenter, is_vpn, latitude, longitude, raw_data, fetched_at)
-        VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+        INSERT INTO ip_infos (ip, city, country, country_code, asn, asn_org, is_datacenter, is_vpn, is_crawler, is_tor, is_proxy, latitude, longitude, raw_data, fetched_at)
+        VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)
         ON CONFLICT(ip) DO UPDATE SET
             city = EXCLUDED.city,
             country = EXCLUDED.country,
···
             asn_org = EXCLUDED.asn_org,
             is_datacenter = EXCLUDED.is_datacenter,
             is_vpn = EXCLUDED.is_vpn,
+            is_crawler = EXCLUDED.is_crawler,
+            is_tor = EXCLUDED.is_tor,
+            is_proxy = EXCLUDED.is_proxy,
             latitude = EXCLUDED.latitude,
             longitude = EXCLUDED.longitude,
             raw_data = EXCLUDED.raw_data,
             fetched_at = EXCLUDED.fetched_at,
             updated_at = CURRENT_TIMESTAMP
     `
-	_, err := p.db.ExecContext(ctx, query, ip, city, country, countryCode, asn, asnOrg, isDatacenter, isVPN, lat, lon, rawDataJSON, time.Now().UTC())
+	_, err := p.db.ExecContext(ctx, query, ip, city, country, countryCode, asn, asnOrg, isDatacenter, isVPN, isCrawler, isTor, isProxy, lat, lon, rawDataJSON, time.Now().UTC())
 	return err
 }
 
 func (p *PostgresDB) GetIPInfo(ctx context.Context, ip string) (*IPInfo, error) {
 	query := `
-        SELECT ip, city, country, country_code, asn, asn_org, is_datacenter, is_vpn, 
+        SELECT ip, city, country, country_code, asn, asn_org, is_datacenter, is_vpn, is_crawler, is_tor, is_proxy,
                latitude, longitude, raw_data, fetched_at, updated_at
         FROM ip_infos
         WHERE ip = $1
···
 
 	err := p.db.QueryRowContext(ctx, query, ip).Scan(
 		&info.IP, &info.City, &info.Country, &info.CountryCode, &info.ASN, &info.ASNOrg,
-		&info.IsDatacenter, &info.IsVPN, &info.Latitude, &info.Longitude,
+		&info.IsDatacenter, &info.IsVPN, &info.IsCrawler, &info.IsTor, &info.IsProxy,
+		&info.Latitude, &info.Longitude,
 		&rawDataJSON, &info.FetchedAt, &info.UpdatedAt,
 	)
 	if err != nil {
···
 		}
 	}
 	return 0
-}
-
-func extractBool(data map[string]interface{}, keys ...string) bool {
-	current := data
-	for i, key := range keys {
-		if i == len(keys)-1 {
-			if val, ok := current[key].(bool); ok {
-				return val
-			}
-			// Check if it's a string that matches (for type="hosting")
-			if val, ok := current[key].(string); ok {
-				// For cases like company.type == "hosting"
-				expectedValue := keys[len(keys)-1]
-				return val == expectedValue
-			}
-			return false
-		}
-		if nested, ok := current[key].(map[string]interface{}); ok {
-			current = nested
-		} else {
-			return false
-		}
-	}
-	return false
 }
 
 // ===== BUNDLE OPERATIONS =====

internal/storage/types.go

···
 	LastChecked  time.Time
 	Status       int
 	IP           string
+	IPv6         string // NEW
 	IPResolvedAt time.Time
 	UpdatedAt    time.Time
 }
···
 	ASNOrg       string                 `json:"asn_org,omitempty"`
 	IsDatacenter bool                   `json:"is_datacenter"`
 	IsVPN        bool                   `json:"is_vpn"`
+	IsCrawler    bool                   `json:"is_crawler"`
+	IsTor        bool                   `json:"is_tor"`
+	IsProxy      bool                   `json:"is_proxy"`
 	Latitude     float32                `json:"latitude,omitempty"`
 	Longitude    float32                `json:"longitude,omitempty"`
 	RawData      map[string]interface{} `json:"raw_data,omitempty"`
 	FetchedAt    time.Time              `json:"fetched_at"`
 	UpdatedAt    time.Time              `json:"updated_at"`
+}
+
+// IsHome returns true if this is a residential/home IP
+// (not crawler, datacenter, tor, proxy, or vpn)
+func (i *IPInfo) IsHome() bool {
+	return !i.IsCrawler && !i.IsDatacenter && !i.IsTor && !i.IsProxy && !i.IsVPN
 }
 
 // PDSListItem is a virtual type created by JOIN for /pds endpoint