NIKA

NIKA Route Engine

Optimize, dispatch, and track every delivery — from one headless API

A developer-first route optimization API for last-mile and fleet operations: optimize multi-stop routes, ingest live GPS, compute ETAs from a travel-time model that learns your roads, and stream map-ready data and signed webhooks into your own apps. You build the UI — NIKA runs the delivery brain.

Built for fleets, field teams, and delivery networks — identity-free by design.

Where NIKA goes further

Two advantages that change the route.

HIPAA-ready architecture

Use the address. Never keep it.

NIKA can purge destination coordinates and raw GPS at trip completion, while names and contact details stay in your system.

Opaque IDsBAA-ready deployment

Bring your own data (BYOD)

Upload your road network. Route on it.

A hospital can send private service roads and an ambulance-only gate. NIKA merges them with public streets before optimization.

Private roads become routableNot just a map overlay

Compared with public Google documentation: Fleet Engine retention, HIPAA coverage, route modifiers, and a developer estate-road example. Compliance depends on deployment and agreements.

Route Optimization API

Optimization, not manual assignment.

Post your riders and stops with their real constraints — shift windows, vehicle capacity and cold-chain, delivery windows, per-stop service time, priority. The solver returns balanced trips and the time and distance you saved, in well under a second.

  • Every limit is a per-request parameter — never a hidden system cap
  • Choose the objective: minimize time, distance, or balanced
  • Re-optimize the remainder live when a rider drops or traffic hits
  • Drive time9.4 h
  • Distance142 km
  • Routes1 · crosses

One rider, backtracking, no time-window respect.

Live Tracking API

One stream, scoped to every audience.

Ingest rider GPS at the edge and fan it back out as GeoJSON over WebSocket. Ops sees the whole fleet; each recipient gets a tokenized link that reveals the rider only on its active leg — never while it serves someone else.

  • Capability tokens scope each link to a single delivery
  • Per-leg gating — the rider appears only when it's your stop
  • WebSocket or SSE, with map-ready GeoJSON frames

Delivery Events API

Events out — your stack sends the messages.

NIKA emits signed delivery.* events carrying a tracking link; your existing messaging maps them to its own SMS, WhatsApp, or push templates and sends. You keep full control of channels, language, and consent — and we never touch a phone number.

  • HMAC-SHA256 signed, retried with backoff for 24 h
  • Identity-free — events carry an opaque route_id, never your order
  • Drop-in receiver if your CRM has no webhook pattern yet
NIKA Route Engineemits signed events
Your stack sends itSMS · WhatsApp · push — your templates, channels, consent

Travel-Time & ETA API

The map is wrong. Your deliveries fix it.

Off-the-shelf routing is only as good as its map — and in most of the world, local roads, informal routes, and real traffic aren’t in it. Every tracked delivery produces de-identified, k-anonymized segment travel-times that train a model unique to your operation. ETA and route quality compound, corridor by corridor, with volume.

The data flywheel

  1. 1Deliveriesevery tracked trip
  2. 2De-identifiedsegment travel-times
  3. 3Trained matrixby time-of-day
  4. 4Sharper ETA + routingaccuracy compounds

Where the world’s map is wrong, your own deliveries become the map. You own the learning loop — not a vendor’s.

Route Engine API

Three calls from zero to live tracking.

JSON over HTTPS, versioned under /v1. The optimization request models Google’s Route Optimization API shapes, so it’s familiar from the first call.

Optimize riders + deliveries into trips

Post your vehicles and stops with their constraints. Every limit is a parameter, never a system cap.

POST /v1/route-optimization        X-API-Key: ‹key›
{
  "optimize_for": "time",          // time | distance | balanced
  "riders": [
    { "ref": "r_204", "shift": {"start":"08:00","end":"16:00"},
      "max_stops": 20, "capacity": { "cold_chain": 4 } }
  ],
  "deliveries": [
    { "dropoff": {"lat":5.6037,"lng":-0.1870},
      "window": {"start":"08:00","end":"16:00"},
      "service_time_min": 4, "priority": "normal" }
  ]
}

200  { "trips":[ {"rider_ref":"r_204","drive_min":312,"km":58} ],
       "savings": {"hours": 5.2, "km": 54} }

Map-Ready Geometry API

Headless geometry that drops into any map library.

Everything geometric leaves the API as GeoJSON or encoded polylines — basemap-independent overlay data that renders unchanged over your tiles, with stable feature IDs so the client updates layers in place instead of redrawing.

  • OnlyMap
  • MapLibre GL
  • Mapbox GL JS
  • Google Maps JS
  • deck.gl

Headless Routing Architecture

You keep the platform. NIKA runs the routing brain.

A decoupled service that never touches your order database — two inbound calls and one signed outbound webhook contract. Drop it in beside what you already run.

You keep
  • Your database as the source of truth
  • Your identity provider (JWT) — your sole IdP
  • Your SMS, email & push — you do the sending
  • Your UIs and your map library — fully headless
NIKA owns
  • On-demand route optimization
  • GPS ingestion & real-time fan-out
  • Routing, ETA & geocoding
  • Signed webhooks out — your messaging consumes

Identity-free by default — portable to HIPAA.

No NIKA component holds identity — only an opaque route_id, coordinates, and derived travel-time matrices. TLS everywhere, capability tokens for public links, an append-only audit log, and raw GPS purged on completion. When a BAA or HIPAA applies, the same component design redeploys into a BAA-eligible region — only the hosting target changes, never the design.

Route Engine Integrations

Have a fleet, a clinic network, or a delivery operation? Let’s scope it.

See it at work in logistics & supply chain