Skip to main content

​
Overview

Radar’s geofencing capabilities allow you to create custom geofences and monitor when users enter, exit, or dwell in specific locations. Geofences can be circular or polygon-shaped and include rich metadata for targeting and personalization.

​
Understanding Geofences

Geofences are virtual boundaries that trigger events when a user crosses them. Each geofence includes:
  • Unique identifier: Radar ID and optional external ID
  • Tag: Categorize geofences (e.g., “store”, “warehouse”, “delivery-zone”)
  • Description: Human-readable name
  • Geometry: Circle or polygon shape
  • Metadata: Custom key-value pairs for additional context
  • Operating hours: Optional hours when the geofence is active

​
Geofence Events

Radar generates three types of geofence events:
1

Entry Events

Triggered when a user enters a geofence.Event type: RadarEventTypeUserEnteredGeofence
func didReceiveEvents(_ events: [RadarEvent], user: RadarUser?) {
    for event in events {
        if event.type == .userEnteredGeofence {
            let geofence = event.geofence
            print("Entered: \(geofence?.tag ?? "")")
            print("Description: \(geofence?.__description ?? "")")
        }
    }
}
2

Exit Events

Triggered when a user exits a geofence.Event type: RadarEventTypeUserExitedGeofence
func didReceiveEvents(_ events: [RadarEvent], user: RadarUser?) {
    for event in events {
        if event.type == .userExitedGeofence {
            let geofence = event.geofence
            let duration = event.duration // in minutes
            print("Exited: \(geofence?.tag ?? "") after \(duration) minutes")
        }
    }
}
Exit events include a duration property indicating how long the user was inside the geofence (in minutes).
3

Dwell Events

Triggered when a user dwells in a geofence for a specified duration.Event type: RadarEventTypeUserDwelledInGeofence
func didReceiveEvents(_ events: [RadarEvent], user: RadarUser?) {
    for event in events {
        if event.type == .userDwelledInGeofence {
            let geofence = event.geofence
            print("Dwelled in: \(geofence?.tag ?? "")")
            
            // Access geofence metadata
            if let metadata = geofence?.metadata {
                print("Metadata: \(metadata)")
            }
        }
    }
}
Configure dwell duration thresholds in the Radar dashboard. Default is 5 minutes.

​
Searching for Geofences

You can search for nearby geofences using the searchGeofences() method.

​
Search Near Current Location

Radar.searchGeofences { (status, location, geofences) in
    if status == .success {
        // geofences sorted by distance
        for geofence in geofences ?? [] {
            print("Geofence: \(geofence.__description)")
            print("Tag: \(geofence.tag ?? "")")
            print("External ID: \(geofence.externalId ?? "")")
        }
    }
}

​
Search with Filters

Filter geofences by tag, metadata, radius, and limit: 
let location = CLLocation(latitude: 40.7128, longitude: -74.0060)
let tags = ["store", "restaurant"]
let metadata = ["category": "retail"]

Radar.searchGeofences(
    near: location,
    radius: 1000, // meters
    tags: tags,
    metadata: metadata,
    limit: 10,
    includeGeometry: false
) { (status, location, geofences) in
    if status == .success {
        print("Found \(geofences?.count ?? 0) geofences")
    }
}

​
Search Parameters

ParameterTypeDescription
nearCLLocation?Location to search near. Use nil for current location.
radiusintRadius to search in meters (100-10000). Use -1 for unlimited.
tags[String]?Filter by geofence tags.
metadata[String: Any]?Filter by geofence metadata key-value pairs.
limitintMaximum number of results (1-1000). Default is 100.
includeGeometryBOOLInclude full geometry in response. Set to false for >100 results.
To retrieve more than 100 geofences, set includeGeometry to false. Including geometry data limits results to 100.

​
Geofence Properties

Access geofence properties from the RadarGeofence object: 
let geofence: RadarGeofence = event.geofence!

// Identifiers
let radarId = geofence._id
let externalId = geofence.externalId
let tag = geofence.tag

// Description
let description = geofence.__description

// Metadata
if let metadata = geofence.metadata {
    let storeNumber = metadata["store_number"] as? String
    let region = metadata["region"] as? String
}

// Geometry
let geometry = geofence.geometry
if let circleGeometry = geometry as? RadarCircleGeometry {
    let center = circleGeometry.center
    let radius = circleGeometry.radius
} else if let polygonGeometry = geometry as? RadarPolygonGeometry {
    let coordinates = polygonGeometry.coordinates
}

// Operating hours
if let operatingHours = geofence.operatingHours {
    // check if currently open
}

​
Syncing Geofences

Enable geofence syncing to download nearby geofences to the device for improved responsiveness: 
let trackingOptions = RadarTrackingOptions.presetResponsive
trackingOptions.syncGeofences = true

Radar.startTracking(trackingOptions: trackingOptions)
Enabling syncGeofences allows the SDK to monitor nearby geofences locally, reducing latency for entry and exit events.

​
Using Client Geofences

Client geofences create local iOS region monitoring around the user’s current location: 
let trackingOptions = RadarTrackingOptions.presetResponsive

// Enable stopped geofence
trackingOptions.useStoppedGeofence = true
trackingOptions.stoppedGeofenceRadius = 100 // meters

// Enable moving geofence
trackingOptions.useMovingGeofence = true
trackingOptions.movingGeofenceRadius = 200 // meters

Radar.startTracking(trackingOptions: trackingOptions)
Client geofences use Apple’s region monitoring service to wake the app when the user moves beyond the specified radius, improving battery efficiency.

​
Event Confidence

Geofence events include a confidence level indicating the likelihood that the event is accurate: 
func didReceiveEvents(_ events: [RadarEvent], user: RadarUser?) {
    for event in events {
        switch event.confidence {
        case .high:
            // High confidence - act immediately
            print("High confidence event")
        case .medium:
            // Medium confidence - may want to verify
            print("Medium confidence event")
        case .low:
            // Low confidence - treat with caution
            print("Low confidence event")
        case .none:
            print("Unknown confidence")
        @unknown default:
            break
        }
    }
}

​
Verifying Events

You can accept or reject geofence events to improve accuracy: 
// Accept an event
let eventId = event._id
Radar.acceptEventId(eventId, verifiedPlaceId: nil)

// Reject an event
Radar.rejectEventId(eventId)
Event verifications help Radar’s machine learning improve future event accuracy and confidence levels.

​
Use Cases

Store Pickup

Trigger curbside pickup notifications when customers arrive at store geofences.

Delivery Zones

Monitor when delivery drivers enter and exit delivery zones for real-time tracking.

Attendance Tracking

Track employee or student attendance based on geofence entry/exit events.

Marketing Campaigns

Send targeted messages when users enter specific geographic areas or competitor locations.

​
Best Practices

1

Use Tags for Organization

Organize geofences with tags (e.g., “store”, “warehouse”, “restaurant”) for easy filtering and management.
2

Leverage Metadata

Store additional context in geofence metadata (store IDs, manager contacts, operating details) for personalization.
3

Set Appropriate Radii

Use smaller radii (50-100m) for precise locations like stores. Use larger radii (500-1000m) for neighborhoods or zones.
4

Monitor Event Confidence

Check event confidence levels and handle high-confidence events differently than low-confidence ones.
5

Enable Geofence Syncing

Enable syncGeofences for better responsiveness and reduced latency in geofence events.
For more details on geofencing, visit the Radar documentation.

Build docs developers (and LLMs) love

Get started for freeTalk to us