OpenFence
Geofencing API for logistics, field service & asset tracking

Geofencing events you can actually trust.

Detect when your vehicles, crews, or assets enter, exit, or dwell at a location — and get a signed webhook you can build billing and dispatch on. Every event is explainable end-to-end and verifiable byte-for-byte against the test vectors we ship with each release. No black box, no silent contract drift.

Start free trial See it work — 2-minute quickstart

Plans from $15/mo · 14-day free trial · multi-tenant · per-tenant signing secrets.

Why OpenFence

Geofencing is easy to demo and hard to trust at scale. OpenFence is built so you never have to take its word for anything.

Explainable end-to-end

Every match and skip is traceable through reason codes and a full evaluation trace. You're never guessing why a rule fired — or why a webhook didn't.

Verifiable byte-for-byte

A generator-backed test-vectors fixture ships with every release. Pin your receiver against the same JSON — the contract can't drift on you silently.

Don't build it yourself

Dwell detection, temporal rules, retries, dead-letter, multi-tenant isolation — months of infrastructure you don't want to own, operated for you.

How it works

Three moving pieces. OpenFence is the middle one. The other two stay yours.

  1. 1

    Devices ping OpenFence

    Vehicles, mobile clients, IoT trackers — anything with a tenant API key — POST location pings to /api/v1/pings. Single-ping or batched up to 100 per request.

  2. 2

    OpenFence detects events

    Geofence enter / exit / dwell, plus a rules engine for temporal predicates (only-during-business-hours), cooldown suppression, and multi-step sequence rules. All evaluation is explainable end-to-end through trace.

  3. 3

    Signed webhooks reach your app

    Authenticated HMAC-SHA256 deliveries with timestamp + replay defense. Retry / backoff / dead-letter built in. Your receiver verifies, dedupes by event_id, and persists raw — then your domain logic decides what to do.

Domain-agnostic by design — your platform interprets the events

OpenFence stays domain-agnostic on purpose. The events it emits are generic primitives — geofence.enter, exit, dwell, rule.triggered. Your platform interprets them in your language.

Logistics & moving

Dispatch knows when crews arrive, depart, or dwell at origin / destination / terminal stops. Tariff-relevant time-on-site flows automatically into BOL evidence.

See the moving & logistics page →

Field service

Technicians arrive on-site → time clock starts. Departure → invoice line closes. No "did you remember to clock in" friction.

See the field-service page →

Asset tracking

Containers leave the yard, trailers enter the port, equipment arrives at the jobsite — your inventory system sees it within seconds.

Built by a moving company

We run a moving company. We're building OpenFence to run it on.

We're building OpenFence to turn crew arrival, on-site dwell, and departure into automatic bill-of-lading evidence — so dispatch stops confirming each job by hand. The same signed-webhook contract and explainable events you'd build on.

Every arrival and departure becomes evidence.

GPS shows you a dot on a map. OpenFence turns each crossing into a signed, delivered event — here, for an example moving company:

openfence.ai/dashboard/events
OpenFence tenant dashboard: a moving company's event feed with a geofence.enter arrival opened, showing the signed event payload and a webhook delivered with HTTP 200 in 118 ms.
Illustrative — example tenant (Acme Moving Co) with sample data. The dashboard UI is the real product.
Read the full story → Try it yourself — watch OpenFence turn movement into evidence on your own phone →

Simple, usage-based pricing

Start free for 14 days. Pick the tier that fits — you only pay for what you use beyond it.

Starter

Small operators getting started

$15/mo

Start 14-Day Trial

Standard

Growing businesses

$49/mo

Start 14-Day Trial

Professional

Multi-crew operations

$149/mo

Start 14-Day Trial

Business

Multi-site operations & larger fleets

$399/mo

Start 14-Day Trial
Compare all plans →

A contract you can verify byte-for-byte

Don't take our word for it — verify the contract yourself. OpenFence ships a generator-backed test-vectors fixture with every release; your receiver pins against the same JSON file. If our signing helper drifts, your tests break loud — no silent contract creep.

See how OpenFence keeps your data isolated, signed & encrypted →

Verify webhook signatures

Wire format, 8-step verifier algorithm, and copy-pasteable Node, Go, and Python samples — pinned against the same fixture below.

Reference

Event payload explorer

Every field, every event type, with real production bytes. Verify your receiver against a live signed delivery in your browser.

Test vectors fixture

11 byte-exact cases — valid, stale, future, tampered, malformed, non-UTF-8 — with expected outcomes. Pin your verifier against the same JSON our generator produces. 

X-OpenFence-Signature: t=<unix_seconds>,v1=<hex_hmac_sha256>
X-OpenFence-Timestamp: <unix_seconds>
X-OpenFence-Webhook-Id: <subscription_uuid>
X-OpenFence-Delivery-Id: <delivery_uuid>        # stable across retries
X-OpenFence-Request-ID:  <correlation_uuid>       # when set
Content-Type: application/json

# signed_input = f"{timestamp}.".encode("ascii") + body_bytes
# Verify: HMAC-SHA256(signing_secret, signed_input).hexdigest()
# Reject: outside ±5 min freshness window, malformed/duplicate keys, hex-shape mismatch

Start building today.

Spin up a tenant, define a geofence, and receive your first signed webhook in minutes. $0 for 14 days — or tell us what you're building and we'll help you scope it.

Start free trial Talk to us

Or read the docs and the test-vectors fixture above first — most technical questions are answered there.