Navigate Peace of Mind: Set Smart GPS Fences Now

Introduction

Virtual boundaries, also known as geofences, allow you to define a digital perimeter around a real-world area using GPS coordinates. When a device crosses that perimeter, it triggers an action—such as sending a notification, logging data, or activating a smart home device. This feature is especially useful for security, fleet management, marketing campaigns, and IoT automation.

Why Use GPS Fences?

• Real-time alerts: Receive instant notifications when someone enters or leaves a designated zone.
• Automated workflows: Trigger smart devices (lights, locks, HVAC) based on location.
• Data collection: Log visitation patterns for analytics and reporting.
• Cost savings: Reduce manual monitoring and improve operational efficiency.

Step-by-Step Guide to Creating a GPS Fence

1. Choose a Platform or Service
   Popular options include Google Maps API, Mapbox, Azure Spatial Anchors, and dedicated IoT platforms like AWS IoT Core. For beginners, the Google Geofencing API offers a comprehensive SDK.
2. Select Your Boundary Shape
   Most services support circular, polygonal, or custom shapes. Circular fences are easier to set up:

   <circle center="37.4219983,-122.084">
       <radius>200</radius>
   </circle>

3. Define the Trigger Events
   Decide whether you want to trigger on entry, exit, or both. Example using JavaScript with Google Maps:

   geofenceRequest = {
         geofence: {
           id: 'office',
           latitude: 37.4219983,
           longitude: -122.084,
           radius: 200
         },
         triggers: [GeofenceTriggerType.GEOFENCE_ENTER, GeofenceTriggerType.GEOFENCE_EXIT]
       };

4. Implement the Client SDK
   Embed the SDK in your mobile or web app. Ensure you handle permissions for location access and battery optimization.
5. Test Thoroughly
   Use GPS spoofing tools (e.g., Fake GPS on Android) to simulate movement across the fence. Verify that events fire correctly and that edge cases—such as rapid entry/exit—are handled gracefully.
6. Deploy and Monitor
   Once live, monitor logs for false positives or missed triggers. Adjust radius or shape if necessary to account for GPS drift.

Practical Use Cases

• Smart Home Automation: Turn on hallway lights when you approach the front door.
• Fleet Tracking: Receive alerts if a delivery van deviates from its route.
• Retail Marketing: Send a coupon to shoppers who enter your store’s perimeter.
• Security Monitoring: Log when personnel enter restricted zones in an industrial facility.

Troubleshooting Tips

• GPS Accuracy: Urban canyons and indoor environments reduce precision. Use Wi-Fi or cell tower triangulation as a fallback.
• Battery Drain: Continuous GPS usage drains battery quickly. Implement passive location updates or use geofencing services that rely on low-power background tracking.
• Permission Issues: Ensure your app requests the correct level of location permission (foreground vs. background) and handles denial gracefully.

By following these steps and best practices, you can harness GPS fences to create responsive, location-aware experiences that enhance security, convenience, and operational efficiency.

What Are GPS Fences?

{
  "name": "Warehouse Zone",
  "type": "polygon",
  "coordinates": [
    [37.7749, -122.4194],
    [37.7750, -122.4180],
    [37.7735, -122.4175],
    [37.7728, -122.4190]
  ]
}

import { GeofenceManager } from 'geofence-sdk';

const manager = new GeofenceManager({
  apiKey: 'YOUR_API_KEY',
  userId: 'driver123'
});

manager.startMonitoring();

Benefits of Virtual Boundaries

Hardware Requirements

If you want your virtual boundary system to run smoothly, make sure the hardware you choose is up to the task. Below we break down the essential components, give practical examples of suitable devices, and offer tips for optimizing performance.

1. GPS‑Enabled Device (Primary Tracking Unit)

• Smartphone or Tablet: Most modern Android and iOS devices have built‑in GPS chips that are accurate to within a few meters. For a basic setup, an inexpensive model such as the Samsung Galaxy A12 or Apple iPad Mini will do.
• Dedicated GPS Tracker: If you need continuous tracking for a vehicle or animal, consider devices like the Tracki 2021 or Garmin eTrex 20x. These units are rugged and can run on battery for days.
• Considerations:
  • Battery life – choose a device that can stay powered for the duration of your monitoring period.
  • Signal reception – devices with external antennas or dual‑band GPS (L1/L5) offer better performance in urban canyons.
  • Data plan – if you’re sending real‑time updates, ensure a reliable cellular connection or use Wi‑Fi when available.

2. Internet Connectivity

The GPS device must send its coordinates to your server or cloud service. Depending on your setup:

• Cellular (4G/5G): A SIM card with a data plan is essential for mobile devices that move outside Wi‑Fi coverage.
• Wi‑Fi: For stationary setups like indoor boundary monitoring, a stable router can suffice. Use a wired Ethernet connection for the server to reduce latency.
• LoRaWAN or NB‑IoT Gateways: In rural or industrial settings where cellular coverage is spotty, low‑power wide‑area networks can transmit GPS data over long distances with minimal battery drain.

3. Server / Cloud Backend

Your application needs a place to receive, process, and store location data. Options include:

• Self‑Hosted VPS (DigitalOcean, Linode): Offers full control; install a Node.js or PHP backend with PostgreSQL/PostGIS for spatial queries.
• Managed Cloud Platform (AWS Lambda + DynamoDB, Google Firebase): Serverless architectures reduce maintenance overhead and scale automatically.
• Edge Computing: If you need sub‑second response times for real‑time alerts, consider deploying a small edge node near the tracking device using AWS Greengrass or Azure IoT Edge.

4. Power Supply & Battery Management

For long‑term deployments, plan how your devices will stay powered:

• Solar Panels + Batteries: Ideal for remote locations; pair a small solar panel with a Li‑ion bank.
• High‑Capacity Power Banks: Portable solutions that can be swapped or recharged in the field.
• Battery Monitoring: Use devices that report battery level to your server so you can schedule maintenance before a shutdown.

5. Optional Sensors & Accessories

Enhance boundary detection with complementary hardware:

• Magnetic or RFID Tags: Attach to objects that need precise indoor tracking; read by a dedicated reader placed at the gate.
• Accelerometers & Gyroscopes: On wearable trackers, these can detect sudden movements or falls, adding context to location data.
• Cameras (IP/RTSP): Combine visual confirmation with GPS triggers for security applications.

Practical Advice & Checklist

1. Define Your Use Case: Is it a vehicle, livestock, child safety, or asset tracking? The answer determines the required accuracy and durability.
2. Test in Real Conditions: Before full deployment, run a pilot to measure GPS drift, signal loss, and battery life.
3. Plan for Redundancy: Use dual‑mode devices (GPS + GLONASS) and backup power options to mitigate single points of failure.
4. Secure Data Transmission: Encrypt data over HTTPS or MQTT with TLS; store credentials securely on the device.
5. Monitor & Maintain: Set up alerts for low battery, connectivity loss, and boundary breaches. Schedule regular firmware updates.

By carefully selecting and configuring each piece of hardware, you’ll build a robust foundation that ensures your virtual boundaries are reliable, accurate, and responsive to real‑world conditions.

Software Options

[geo_fence id="office" action="email_admin" radius="200"]

Step 1: Create an Account

Step 2: Define the Fence Area

Step 3: Set Trigger Settings

Step 4: Add Notification Recipients

Add Notification Recipients

Once your virtual boundaries are defined, decide who should receive alerts when a device crosses them. The notification system can be configured to send SMS, email, or push notifications through the app’s built‑in messaging module.

• Single Recipient: If you’re monitoring one person (e.g., a child), simply enter their phone number or email in the “Primary Alert” field. The system will deliver a real‑time message whenever the boundary is breached.
• Multiple Recipients: For family groups, add each member’s contact details under “Secondary Alerts.” Each recipient can choose to receive SMS or push notifications based on their device preferences.
• Conditional Alerts: Use the “Alert Rules” panel to specify conditions such as time of day (e.g., only alert after 8 p.m.) or distance threshold. This helps reduce nuisance alerts during routine commutes.
• Role‑Based Notifications: In a corporate setting, assign roles like Manager, HR, or Security. Each role can receive different types of notifications—for instance, managers might get a summary report instead of instant alerts.

Practical Example: Setting Up a School Bus Boundary

1. Create a circular GPS fence with a 500‑meter radius around the school’s parking lot.
2. Add parents as primary recipients and the transportation supervisor as a secondary recipient.
3. Configure conditional alerts to trigger only between 7 a.m. and 9 a.m., when buses are expected to arrive.
4. Enable “silent mode” for weekdays after 3 p.m. so parents aren’t disturbed by normal traffic movements.

Troubleshooting Tips

• Delayed Alerts: Ensure the device’s GPS is active and the app has background location permissions. A weak signal can cause a lag in boundary breach detection.
• No Notification Sent: Verify that the recipient’s contact details are correct and that the chosen notification channel (SMS, email, push) is enabled on their device.
• False Positives: If alerts trigger too frequently, consider tightening the GPS fence radius or adding a “minimum stay” timer so the device must remain outside for a set period before an alert fires.

By thoughtfully configuring notification recipients and conditions, you can maintain situational awareness without overwhelming your contacts with unnecessary messages.

Step 5: Test the Fence

Once you’ve created a virtual boundary, it’s essential to verify that the GPS fence behaves exactly as expected. Testing ensures that your triggers fire at the right moments and that no false positives or negatives occur.

1. Use the “Simulate” Feature in Google Maps Platform

The Google Maps JavaScript API offers a setPosition() method on the google.maps.Marker object, which you can use to simulate movement across your fence. Here’s a quick example:

const marker = new google.maps.Marker({
  position: { lat: 40.7128, lng: -74.0060 },
  map: map,
});

function moveMarkerTo(lat, lng) {
  const newPos = new google.maps.LatLng(lat, lng);
  marker.setPosition(newPos);
  // Trigger any event listeners that depend on the marker’s position
}

Call moveMarkerTo() with coordinates inside and outside your fence to see if the correct events fire.

2. Leverage the “Event Log” in Firebase Cloud Functions

If you’re using Cloud Functions for your GPS triggers, enable detailed logging:

exports.onLocationChange = functions.firestore
  .document('users/{userId}/locations/{locationId}')
  .onWrite((change, context) => {
    const before = change.before.data();
    const after = change.after.data();

    console.log(`User ${context.params.userId} moved from`, before?.lat, before?.lng);
    console.log(`to`, after.lat, after.lng);

    // Your fence logic here
  });

View these logs in the Firebase Console to confirm that your function receives the correct data and fires at the right time.

3. Test on Real Devices with Varying Signal Strengths

• Indoor vs Outdoor: GPS accuracy drops indoors; test both scenarios.
• Different Bands: iOS uses CLLocationAccuracyBestForNavigation, Android uses PRIORITY_HIGH_ACCURACY. Verify that each platform respects your chosen accuracy level.
• Simulated Movement: Use tools like Android Device Manager or Xcode’s Location Simulation to emulate movement across the fence.

4. Validate Edge Cases

Fences can behave unexpectedly when:

• The device is near the boundary but experiences GPS jitter.
• The user crosses a small “no‑go” zone that’s part of a larger fence.
• The device loses signal and then regains it, causing multiple entry/exit events.

Implement debouncing logic in your event handlers to mitigate false triggers. For example:

let lastTriggerTime = 0;
function onFenceEvent(event) {
  const now = Date.now();
  if (now - lastTriggerTime < 30000) return; // ignore events within 30 seconds
  lastTriggerTime = now;

  // Process event
}

5. Create a Test Plan Checklist

6. Automate Testing with Cypress or Playwright

Write end‑to‑end tests that simulate user movement and verify UI updates:

describe('GPS Fence Tests', () => {
  it('should notify on entry', () => {
    cy.visit('/app');
    cy.window().then(win => {
      win.navigator.geolocation.getCurrentPosition = () => ({
        coords: { latitude: 40.7127, longitude: -74.0059 }
      });
      // Trigger position change
      win.dispatchEvent(new Event('locationupdate'));
    });

    cy.contains('You have entered the zone').should('be.visible');
  });
});

Automated tests give you confidence that future code changes won’t break your fence logic.

7. Monitor Real‑World Usage After Deployment

• Set up dashboards in Firebase Analytics to track entry/exit events.
• Enable crash reporting (e.g., Sentry) to catch any runtime errors related to location services.
• Collect user feedback via in‑app surveys if they report false positives or missed triggers.

By rigorously testing both in simulation and on real devices, you’ll ensure that your GPS fence is reliable, accurate, and ready for production use.

Integration with Other Systems

Once you’ve mastered the basics of setting up virtual boundaries using GPS fences, the next step is to weave that functionality into the broader ecosystem of your business or personal workflow. By integrating GPS fencing with other systems—such as CRM platforms, IoT devices, mobile apps, and analytics dashboards—you can unlock powerful automation, real‑time monitoring, and actionable insights.

1. Connecting GPS Fences to a Customer Relationship Management (CRM) System

Use case: Trigger personalized marketing messages when a customer enters a specific store zone.

• Example: When a shopper’s phone crosses the GPS boundary of Store A, the fence event is sent to HubSpot. HubSpot then triggers an email campaign offering a discount on items they previously viewed.
• Implementation tip: Use webhooks or REST APIs to push fence events from your GPS platform (e.g., Geofencing.io) directly into the CRM. Map the event payload fields—customer_id, boundary_name, timestamp—to custom properties in the CRM.
• Security note: Ensure data is transmitted over HTTPS and that you adhere to GDPR or CCPA guidelines when sharing location data with third parties.

2. Syncing GPS Fences with IoT Devices

Use case: Automate smart home actions based on proximity, such as turning lights on when a homeowner approaches the house.

• Example: An ESP32 microcontroller receives MQTT messages from a geofencing service. When the device detects that the user’s phone has entered the Home boundary, it publishes an “ON” command to a Philips Hue bridge.
• Implementation tip: Use lightweight protocols like MQTT or CoAP for low-latency communication between your GPS service and IoT hubs. Configure a small edge gateway (e.g., Raspberry Pi) to translate HTTP events into MQTT topics.
• Reliability trick: Implement message queuing (e.g., RabbitMQ) so that if the network drops, fence events are stored and replayed once connectivity is restored.

3. Embedding GPS Fence Logic in Mobile Applications

Use case: Provide real‑time navigation or safety alerts within a native app.

• Example: A delivery driver’s Android app receives push notifications when they enter the Warehouse Zone, prompting them to scan a QR code that confirms receipt of goods.
• Implementation tip: Use platform SDKs (e.g., Google Maps Geofencing API, Apple Core Location) to define and monitor fences locally. Sync with your backend via secure REST endpoints for audit logging.
• User experience hack: Show a subtle visual cue on the map when the driver is inside a boundary—such as a translucent overlay—to avoid notification fatigue.

4. Data Aggregation and Analytics Dashboards

Use case: Visualize foot traffic patterns or asset movement over time.

• Example: A retail chain uses a Power BI dashboard that pulls GPS fence event logs to generate heatmaps of customer dwell times within each aisle.
• Implementation tip: Export events in CSV/JSON and ingest them into a time-series database (e.g., InfluxDB). Use Grafana for real-time dashboards with alerts when thresholds are breached.
• Advanced trick: Combine GPS data with sensor feeds (temperature, humidity) to correlate environmental conditions with customer behavior.

5. Automating Workflow via Zapier or Integromat

Use case: Trigger a sequence of actions across multiple apps without writing code.

• Example: When a vehicle enters the Delivery Zone, Zapier sends an SMS via Twilio, logs the event in Google Sheets, and updates a Trello card.
• Implementation tip: Map each fence event field to corresponding triggers or actions. Use filters to ensure only relevant events (e.g., “entry” vs. “exit”) fire the automation.
• Cost consideration: Keep an eye on API call limits; batch multiple events into a single Zap if possible.

Practical Checklist for Seamless Integration

1. Define clear boundary names and metadata (e.g., store_id, region_code).
2. Choose a reliable geofencing provider that supports webhooks, SDKs, and robust documentation.
3. Securely transmit event data—use OAuth2 or API keys with least privilege.
4. Implement idempotent handlers to avoid duplicate processing of the same fence event.
5. Set up monitoring (e.g., alerts on webhook failures, latency spikes) and logging for audit trails.
6. Test edge cases: device GPS drift, boundary overlap, and network outages.

By thoughtfully connecting GPS fences to your existing digital tools, you create a responsive environment where location triggers meaningful actions—enhancing customer engagement, operational efficiency, and data-driven decision making.

Troubleshooting Common Issues

When setting up GPS virtual boundaries (geofences) in WordPress plugins or custom solutions, a few problems frequently crop up. Below is a practical guide to diagnosing and fixing these issues.

1. Geofence Not Triggering When Entering the Area

• Check Device Location Accuracy: Modern smartphones can have location errors of 5–20 m. Test on multiple devices to ensure consistent results.
• Verify Radius Settings: A radius that is too small (e.g., < 50 m) may never be hit if the GPS jitter keeps you slightly outside.
• Confirm API Permissions: On Android, ensure ACCESS_FINE_LOCATION and ACCESS_BACKGROUND_LOCATION are granted. On iOS, check that “Always” permission is set in the app’s settings.
• Inspect Backend Logs: Many geofencing plugins log entry/exit events. Look for entries like “Geofence enter denied due to insufficient accuracy.”

2. Geofence Triggering Too Frequently (False Positives)

• Enable Throttling: Some plugins let you set a debounce interval (e.g., ignore triggers for 30 s after an entry).
• Increase Radius Threshold: A slightly larger radius reduces sensitivity to GPS drift.
• Use “Hysteresis” Logic: Require the device to stay inside the boundary for a set number of consecutive location updates before firing the event.

3. Geofence Not Working in Background Mode

• Background Location Services: On iOS, ensure “Location updates” background mode is enabled in Xcode and that the app requests permission accordingly.
• Android Doze & App Standby: Use JobScheduler or WorkManager to request periodic location checks when the device is idle.
• Battery Optimization Whitelisting: Prompt users to exclude your app from battery optimizations (Android) or “Low Power Mode” (iOS).

4. API Rate Limits Exceeded

• Cache Geofence Results: Store the last known boundary status locally and only query the server when a potential change is detected.
• Batch Requests: If your app checks multiple geofences, send them in one request instead of individual calls.
• Monitor Quotas: Most mapping services (Google Maps, Mapbox) provide dashboard metrics. Set alerts for approaching limits.

5. Inconsistent Behavior Across Browsers

• Geolocation API Differences: Chrome offers high-accuracy mode; Safari may default to less accurate mode unless explicitly requested.
• Feature Detection: Use navigator.geolocation.getCurrentPosition with options: { enableHighAccuracy: true, timeout: 5000 }.
• Polyfills: Consider using a library like Leaflet Geosearch for consistent map rendering.

6. Security & Privacy Concerns

• Data Minimization: Store only the latitude, longitude, and timestamp—no raw GPS logs unless necessary.
• Encryption at Rest & Transit: Use HTTPS for all API calls and encrypt stored coordinates in your database.
• User Consent Flow: Clearly explain why location data is needed and how it will be used before requesting permissions.

Practical Checklist Before Deployment

1. Test on at least three devices (iOS, Android, web).
2. Validate geofence boundaries on a real map using the plugin’s admin UI.
3. Simulate entering/exiting the fence by walking around the perimeter.
4. Review logs for any error messages or warnings.
5. Confirm that notifications or actions (e.g., email, webhook) fire correctly.

By systematically addressing these common pitfalls, you can ensure a reliable and user‑friendly geofencing experience in your WordPress site.

Security and Privacy Considerations

When you rely on GPS‑based virtual boundaries—often called geofences—to automate workflows, trigger notifications or enforce access controls, it’s essential to understand the security implications and respect user privacy. Below we outline key risks, mitigation strategies, and best practices for building a trustworthy system.

1. Data Integrity & Tampering Risks

• GPS Spoofing: Malicious actors can inject fake GPS data to bypass geofence checks. Mitigation:
  • Use device‑level anti‑spoofing APIs where available (e.g., Android’s LocationManager with isFromMockProvider()).
  • Cross‑verify location with other signals such as Wi‑Fi SSIDs or cell tower triangulation.
• Server‑Side Replay: An attacker could replay old GPS coordinates to trigger actions. Mitigation:
  • Timestamp all incoming location updates and enforce a freshness window (e.g., last 30 seconds).
  • Use cryptographic signatures on payloads if the device supports it.

2. Privacy Concerns & Regulatory Compliance

• Minimal Data Retention: Store only the necessary geofence metadata (lat/lng, radius, timestamp). Avoid logging raw GPS traces unless absolutely required.
• Consent Management:
  • Present a clear privacy notice explaining why location data is needed and how it will be used.
  • Use a toggle that lets users opt‑in or opt‑out of geofence tracking, with the ability to revoke permission at any time.
• GDPR & CCPA:
  • Implement data subject rights: access, rectification, erasure, and portability for location information.
  • Maintain a record of processing activities (ROPA) that details the purpose, lawful basis, retention period, and security measures.

3. Authentication & Authorization Controls

Ensure that only authenticated devices can register or update geofences. Use OAuth2/OpenID Connect flows for mobile apps and implement device attestation when possible.

4. Network Security

• Transport Layer Security (TLS): All location data must be transmitted over HTTPS with a valid certificate chain.
• API Rate Limiting: Protect your geofence API endpoints from brute‑force or denial‑of‑service attacks by throttling requests per IP and per user token.
• Input Validation: Sanitize all incoming coordinates to guard against injection attacks. Accept only numeric values within valid latitude/longitude ranges.

5. Edge Cases & Fallback Strategies

• No GPS Signal: When the device cannot obtain a fix, fallback to last known position with a lower confidence radius. Notify users that geofence accuracy may be reduced.
• Battery Conservation: Frequent high‑accuracy location polling drains battery. Offer settings for “high‑precision” vs. “low‑power” modes, and inform users how each mode affects geofencing behavior.

6. Practical Implementation Example (Android)

// Requesting high‑accuracy location updates
LocationRequest request = LocationRequest.create()
    .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
    .setInterval(5000);

// Geofence definition
Geofence geofence = new Geofence.Builder()
    .setRequestId("office")
    .setCircularRegion(37.422, -122.084, 100) // 100m radius
    .setExpirationDuration(Geofence.NEVER_EXPIRE)
    .setTransitionTypes(Geofence.GEOFENCE_TRANSITION_ENTER | Geofence.GEOFENCE_TRANSITION_EXIT)
    .build();

// Register geofence with PendingIntent
GeofencingRequest geofencingRequest = new GeofencingRequest.Builder()
    .addGeofence(geofence)
    .build();

LocationServices.getGeofencingClient(context).addGeofences(
    geofencingRequest, getGeofencePendingIntent())
    .addOnSuccessListener(aVoid -> Log.d("GeoFence", "Registered"))
    .addOnFailureListener(e -> Log.e("GeoFence", e.getMessage()));

In this snippet:

• The app requests high‑accuracy updates only when the geofence is active.
• All location callbacks are delivered via a PendingIntent, ensuring that even if the app is killed, the system can still trigger transitions.
• Implement onLocationChanged() to verify that the received coordinates match the device’s real GPS data (checking isFromMockProvider()) before acting on a transition event.

7. Auditing & Monitoring

• Log geofence registration, updates, and deletions with audit trails that include user ID, timestamp, and device fingerprint.
• Set up alerts for abnormal patterns: e.g., a single device registering dozens of geofences in a short period or rapid back‑and‑forth transitions across a boundary.

8. Summary Checklist

1. Validate GPS authenticity and freshness.
2. Obtain explicit user consent and provide opt‑out mechanisms.
3. Secure data in transit (TLS) and at rest (encryption).
4. Implement strict authentication, authorization, and rate limiting.
5. Handle edge cases gracefully and inform users about battery implications.
6. Maintain audit logs and monitor for suspicious activity.

By addressing these security and privacy considerations, you can confidently deploy GPS‑based virtual boundaries that protect both your system’s integrity and your users’ trust.

Conclusion

FAQ

# In WP Admin
Plugins > Add New > Search “Geolocation Geofence” > Install Now > Activate

[geofence_widget fence_id="123" message="Please allow location access to view content."]

<script>
function sendLocation() {
  navigator.geolocation.getCurrentPosition(function(pos) {
    fetch('/wp-json/geofence/v1/track', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        fence_id: 123,
        latitude: pos.coords.latitude,
        longitude: pos.coords.longitude
      })
    });
  });
}
</script>

<?php
add_action('rest_api_init', function () {
  register_rest_route('geofence/v1', '/track', [
    'methods' => 'POST',
    'callback' => 'handle_geofence_track',
  ]);
});

function handle_geofence_track( WP_REST_Request $request ) {
  $data = $request->get_json_params();
  // Validate coordinates, check against fence geometry
  // Trigger actions (email, logs, etc.)
  return new WP_REST_Response(['status' => 'ok'], 200);
}
?>