> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreflux.org/llms.txt
> Use this file to discover all available pages before exploring further.

# Webfleet (Bridgestone)

> Client-mode REST API connector for Webfleet (Bridgestone) WEBFLEET.connect: vehicle positions and tracks, trips, standstills, events, orders, drivers, EV and cold chain data, the message queue, and orders, text messages, outputs and Webfleet Plugin data

Technical Preview

## Overview

[Webfleet](https://www.webfleet.com/) is Bridgestone's fleet management service (formerly TomTom Telematics). Its integration API, [WEBFLEET.connect](https://www.webfleet.com/static/help/webfleet-connect/en_gb/index.html), is a single HTTPS endpoint, `https://csv.webfleet.com/extern`, where every operation is selected with an `action` parameter. This template asks for JSON output (`outputformat=json`) and ISO 8601 dates in UTC (`useISO8601=true`).

The app has one client-mode connector, `WebfleetConnect`, with 35 events: 21 reads and 14 writes. Typical uses are putting truck and van positions next to plant data (inbound ETAs at the dock, dwell time at the gate), reacting to Webfleet events and cold chain readings in LoT rules, and sending orders or text messages to drivers when a batch is ready. Each event publishes the reply on `<topic>/response`.

### Reads

| Event | Topic | Action | Limit | Use |
| - | - | - | - | - |
| `ShowObjectReport` | `fleet/webfleet/objects/get` | `showObjectReportExtern` (GET) | 6 / min | All objects (vehicles, assets, people) with master data and the latest position, speed, ignition, odometer, driver |
| `ShowVehicleReport` | `fleet/webfleet/vehicles/get` | `showVehicleReportExtern` (GET) | 10 / min | Vehicles: plate, type, VIN (identnumber), dimensions, fuel type and consumption reference values |
| `ShowObjectGroups` | `fleet/webfleet/object-groups/get` | `showObjectGroups` (GET) | 10 / min | Object groups (depots, fleets, sites) |
| `ShowNearestVehicles` | `fleet/webfleet/vehicles/nearest/get` | `showNearestVehicles` (GET) | 10 / min | Vehicles closest to a point; latitude / longitude in micro degrees (41.1579 -> 41157900) (fields: `latitude`, `longitude`) |
| `ShowTracks` | `fleet/webfleet/tracks/get` | `showTracks` (GET) | 10 / min | Position trail of one vehicle (pos\_time, latitude, longitude, speed, course); range at most 2 days (fields: `objectno`, `range`) |
| `ShowTripReport` | `fleet/webfleet/trips/get` | `showTripReportExtern` (GET) | 1 / min | Trips (start / end time and place, distance, duration, fuel, driver) for the date range; filter applies to the trip end time (fields: `range`) |
| `ShowTripSummaryReport` | `fleet/webfleet/trips/summary/get` | `showTripSummaryReportExtern` (GET) | 10 / min | Trip totals for one object over the date range (fields: `objectno`, `range`) |
| `ShowStandStills` | `fleet/webfleet/standstills/get` | `showStandStills` (GET) | 6 / min | Standstills (where and how long a vehicle stopped), e.g. dwell time at a plant gate or dock (fields: `objectno`, `range`) |
| `ShowIOReport` | `fleet/webfleet/io/get` | `showIOReportExtern` (GET) | 10 / min | Digital input on / off periods (PTO, door, reefer, tipper) for one object (fields: `objectno`, `range`) |
| `ShowEventReport` | `fleet/webfleet/events/get` | `showEventReportExtern` (GET) | 1 / min | Event notifications (alarms, warnings, geofence, plugin events) with level, acknowledged / resolved state (fields: `range`) |
| `ShowOrderReport` | `fleet/webfleet/orders/get` | `showOrderReportExtern` (GET) | 6 / min | Orders with current state (accepted, started, arrived, finished), ETA and assigned object (fields: `range`) |
| `ShowDriverReport` | `fleet/webfleet/drivers/get` | `showDriverReportExtern` (GET) | 10 / min | Drivers with master data and the vehicle each is signed on to |
| `GetRemainingDrivingTimesEU` | `fleet/webfleet/drivers/driving-times/get` | `getRemainingDrivingTimesEU` (GET) | 10 / min | Remaining EU driving and rest times per driver (needs Tachograph Manager / TACHO.RDT) |
| `ShowAddressReport` | `fleet/webfleet/addresses/get` | `showAddressReportExtern` (GET) | 6 / min | Addresses (customer sites, plants, depots) with coordinates and radius |
| `GetObjectKPIs` | `fleet/webfleet/kpis/get` | `getObjectKPIs` (GET) | 10 / min | KPI groups (tripstats, ecostats, optidrive, speedingevents, drivingevents, orders) for one object (fields: `objectno`, `range`, `kpinames`) |
| `GetElectricVehicleData` | `fleet/webfleet/ev/get` | `getElectricVehicleData` (GET) | 6 / min | EV battery level (%), range and charging state for every electric vehicle (LINK 740 / 710 / 640 / 610 / 240 / 245 / 210) |
| `GetDiagnosticFaults` | `fleet/webfleet/diagnostics/faults/get` | `getDiagnosticFaults` (GET) | 10 / min | Diagnostic trouble codes reported by the vehicles in the date range (fields: `range`) |
| `GetCurrentTemperatureData` | `fleet/webfleet/temperature/get` | `getCurrentTemperatureData` (GET) | 10 / min | Latest temperature sensor readings (LINK temperature probes) |
| `GetCurrentColdChainSensorData` | `fleet/webfleet/coldchain/get` | `getCurrentColdChainSensorData` (GET) | 10 / min | Latest reefer / cold chain sensor values (Webfleet Cold Chain) |
| `GetTelemetryDeviceBatteryState` | `fleet/webfleet/device-battery/get` | `getTelemetryDeviceBatteryState` (GET) | 10 / min | Battery state of a battery-powered telemetry device (asset trackers) (fields: `objectuid`) |
| `PopQueueMessages` | `fleet/webfleet/queue/pop` | `popQueueMessagesExtern` (GET) | 10 / min | Next batch (up to 500) of queued messages: positions, order / driver / status / text and LINK.connect messages (fields: `msgclass`) |

### Writes and generic calls

| Event | Topic | Action | Limit | Use |
| - | - | - | - | - |
| `AckQueueMessages` | `fleet/webfleet/queue/ack` | `ackQueueMessagesExtern` (GET) | 10 / min | Acknowledge the last popped batch so it is not returned again; serialise with PopQueueMessages (fields: `msgclass`) |
| `CreateQueue` | `fleet/webfleet/queue/create` | `createQueueExtern` (GET) | 10 / 24 h | Create the message queue for a message class (0 all, 2 all but positions, 4 orders, 5 drivers, 7 status, 8 text, 15 third party) (fields: `msgclass`) |
| `DeleteQueue` | `fleet/webfleet/queue/delete` | `deleteQueueExtern` (GET) | 10 / 24 h | Delete the queue for a message class (fields: `msgclass`) |
| `AcknowledgeEvent` | `fleet/webfleet/events/acknowledge` | `acknowledgeEventExtern` (GET) | 300 / 30 min | Acknowledge an alarm-level event (level drops one step) (fields: `eventid`) |
| `ResolveEvent` | `fleet/webfleet/events/resolve` | `resolveEventExtern` (GET) | 300 / 30 min | Resolve an event (fields: `eventid`) |
| `SendOrder` | `fleet/webfleet/orders/send` | `sendOrderExtern` (GET) | 300 / 30 min | Send a text order to the driver terminal; ordertext must be URL-encoded; empty reply on success (fields: `objectno`, `orderid`, `ordertext`) |
| `SendDestinationOrder` | `fleet/webfleet/orders/destination/send` | `sendDestinationOrderExtern` (POST) | 300 / 30 min | Order with a destination (address or coordinates, waypoints, type, date / time) as a form-encoded POST (fields: `form`) |
| `CancelOrder` | `fleet/webfleet/orders/cancel` | `cancelOrderExtern` (GET) | 300 / 30 min | Cancel an order on the terminal (fields: `orderid`) |
| `SendTextMessage` | `fleet/webfleet/messages/send` | `sendTextMessageExtern` (GET) | 300 / 30 min | Text message to the driver terminal (max 500 chars, URL-encoded) (fields: `objectno`, `messagetext`) |
| `SwitchOutput` | `fleet/webfleet/outputs/switch` | `switchOutput` (GET) | 10 / min | Switch a digital output on the LINK device (status 1 / 0); drives real equipment (fields: `objectno`, `status`, `output_name`) |
| `InsertExternalEvent` | `fleet/webfleet/plugin/events/insert` | `insertExternalEvent` (GET) | 5 / min | Raise an own event on a vehicle (e.g. a broker alarm) from URL-encoded JSON; needs a Webfleet Plugin on the API key (fields: `objectno`, `data`) |
| `SetExternalObjectData` | `fleet/webfleet/plugin/object-data/set` | `setExternalObjectData` (GET) | 10 / min | Show broker data (temperature, load, tyre pressure) on a vehicle in Webfleet from URL-encoded JSON; needs a Webfleet Plugin (fields: `objectno`, `data`) |
| `Extern` | `fleet/webfleet/extern` | any (GET) | per action | Any WEBFLEET.connect action: action plus the remaining query string (query, starting with &; may be empty) (fields: `action`, `query`) |
| `ExternPost` | `fleet/webfleet/extern/post` | any (POST) | per action | Any POST-capable action as a form-encoded body (form = action=...&...) (fields: `form`) |

> [!TIP]
>
> For continuous tracking, use the message queue instead of polling `ShowObjectReport`. Create the queue once with `CreateQueue` (message class `0` for everything including positions, `2` for everything except positions), then call `PopQueueMessages` and, after you have stored the batch, `AckQueueMessages`. Pop and ack must not overlap.

## Prerequisites

* A Webfleet account with WEBFLEET.connect enabled and an **API key** (36 characters). Customers request one through the Webfleet support form (product **Integration**, category **API key request**); .connect partners get one during onboarding.
* A dedicated Webfleet **user** for the API, with the access rights the integration needs (for example read access to all objects, edit access to orders). The API acts as that user, so its rights limit what every event can see and change.
* The **account name**, which goes in every request.
* `InsertExternalEvent` and `SetExternalObjectData` also need a registered Webfleet Plugin tied to the API key and the Webfleet Plugin feature booked on the vehicles.

## Connection and security

* **Base address.** `https://csv.webfleet.com` is the same for every account. Only HTTPS is accepted.
* **Auth.** HTTP Basic (RFC 7617) with the Webfleet user name and password, plus `account` and `apikey` as query parameters. User name and password in the URL were removed at the end of June 2026. Store `Basic <base64(user:password)>` in a broker secret (suggested name `WEBFLEET_AUTHORIZATION`) and the key in `WEBFLEET_APIKEY`, and pass both in the payload with `GET SECRET`.
* **Writes.** Events in the writes table change orders, events or vehicle outputs. `SwitchOutput` drives a real output on the LINK device. Each write is marked `# WRITE` in the `.lot` file; restrict who can publish to those topics with an RBAC rule.
* **Encoding.** Values are placed in the query string as they are. URL-encode free text (`ordertext`, `messagetext`, `data`, the `query` and `form` tails) before publishing, for example `Load%20pallets`. Do not send empty values: Webfleet treats an empty parameter as "clear this value" on update actions.

## Pacing and errors

* Request limits are per action and per account and are listed in the tables. `ShowTripReport` and `ShowEventReport` allow **1 request per minute**, `ShowObjectReport` 6 per minute, most other reads 10 per minute, order and message writes 300 per 30 minutes, and creating or deleting a queue 10 per day. Exceeding a limit blocks further calls until a full limit interval passes without requests.
* `ShowTracks` accepts at most 2 days per call. `PopQueueMessages` returns at most 500 messages per call.
* Errors come back with **HTTP 200** and a JSON body `{"errorCode": <n>, "errorMsg": "..."}`, and in the `X-Webfleet-Errorcode` and `X-Webfleet-Errormessage` headers. For example a wrong key answers `{"errorCode":1143,"errorMsg":"API key is invalid"}`. Check for `errorCode` in the response topic rather than relying on the HTTP status.
* Send and update actions answer with an empty body on success. Reads with no data answer `[]`.
* Field names in the JSON output match the CSV column names in the reference. Positions in `ShowTracks`, `ShowNearestVehicles` and the queue are integers in micro degrees (divide by 1,000,000).

## Payload

| Field | Type | Used by | Notes |
| - | - | - | - |
| `authorization` | string | All events | `Basic <base64(user:password)>`, from `GET SECRET "WEBFLEET_AUTHORIZATION"` |
| `account` | string | All events | Webfleet account name |
| `apikey` | string | All events | API key, from `GET SECRET "WEBFLEET_APIKEY"` |
| `objectno` | string | Per-object reads and writes | Object number (case-sensitive) |
| `range` | string | Date-range reads | `range_pattern=d0` (today), `w-1` (last week), or `range_pattern=ud&rangefrom_string=<ISO>&rangeto_string=<ISO>` |
| `msgclass` | string | Queue events | `0` all, `2` all but positions, `4` orders, `5` drivers, `7` status, `8` text, `15` third party |
| `eventid`, `orderid` | string | Event and order writes | Ids from `ShowEventReport` / your own order id (max 20 bytes) |
| `ordertext`, `messagetext`, `data` | string | Orders, messages, plugin data | URL-encoded text or JSON |
| `action`, `query` | string | `Extern` | Any action name, plus the rest of the query starting with `&` (or `""`) |
| `form` | string | `SendDestinationOrder`, `ExternPost` | URL-encoded `name=value&...` body tail (`ExternPost` must include `action=`) |

```json theme={"theme":"css-variables","languages":{"custom":["/languages/lot.json"]}}
{"authorization":"Basic <from secret>","account":"myaccount","apikey":"<from secret>"}
{"authorization":"...","account":"myaccount","apikey":"...","objectno":"001","range":"range_pattern=d0"}
{"authorization":"...","account":"myaccount","apikey":"...","msgclass":"2"}
{"authorization":"...","account":"myaccount","apikey":"...","objectno":"001","orderid":"CF-1001","ordertext":"Load%20pallets%20at%20dock%203"}
{"authorization":"...","account":"myaccount","apikey":"...","action":"showObjectReportExtern","query":"&objectgroupname=Porto"}
```

## Example actions

These actions read all objects once a minute, pop the message queue every 30 seconds and acknowledge each batch when the reply arrives, and read today's events every 5 minutes, all inside the request limits. Credentials come from broker secrets. In production, acknowledge only after the batch is stored.

```lot theme={"theme":"css-variables","languages":{"custom":["/languages/lot.json"]}}
# Example actions for the WebfleetConnect route (docs page). Not part of the route template.
# Secrets: WEBFLEET_AUTHORIZATION = "Basic <base64(user:password)>" of the Webfleet API user, WEBFLEET_APIKEY = the
#   36-character API key. Replace "myaccount" with the Webfleet account name.
# Inline JSON object literals are not supported when publishing to a topic, so requests use COLLAPSED models sent
#   with PUBLISH MODEL. Request limits: showObjectReportExtern 6 / min, popQueueMessagesExtern 10 / min,
#   showEventReportExtern 1 / min; these actions stay below them.

DEFINE MODEL WebfleetRequest COLLAPSED
    ADD STRING "authorization"
    ADD STRING "account"
    ADD STRING "apikey"

DEFINE MODEL WebfleetQueueRequest COLLAPSED
    ADD STRING "authorization"
    ADD STRING "account"
    ADD STRING "apikey"
    ADD STRING "msgclass"

DEFINE MODEL WebfleetRangeRequest COLLAPSED
    ADD STRING "authorization"
    ADD STRING "account"
    ADD STRING "apikey"
    ADD STRING "range"

DEFINE ACTION WebfleetObjectsEveryMinute
ON EVERY 1 MINUTE DO
    PUBLISH MODEL WebfleetRequest TO "fleet/webfleet/objects/get" WITH
        authorization = (GET SECRET "WEBFLEET_AUTHORIZATION")
        account = "myaccount"
        apikey = (GET SECRET "WEBFLEET_APIKEY")

DEFINE ACTION WebfleetQueuePopEvery30Seconds
ON EVERY 30 SECONDS DO
    PUBLISH MODEL WebfleetQueueRequest TO "fleet/webfleet/queue/pop" WITH
        authorization = (GET SECRET "WEBFLEET_AUTHORIZATION")
        account = "myaccount"
        apikey = (GET SECRET "WEBFLEET_APIKEY")
        msgclass = "2"

DEFINE ACTION WebfleetQueueAckAfterPop
ON TOPIC "fleet/webfleet/queue/pop/response" DO
    PUBLISH MODEL WebfleetQueueRequest TO "fleet/webfleet/queue/ack" WITH
        authorization = (GET SECRET "WEBFLEET_AUTHORIZATION")
        account = "myaccount"
        apikey = (GET SECRET "WEBFLEET_APIKEY")
        msgclass = "2"

DEFINE ACTION WebfleetTodayEventsEvery5Minutes
ON EVERY 5 MINUTES DO
    PUBLISH MODEL WebfleetRangeRequest TO "fleet/webfleet/events/get" WITH
        authorization = (GET SECRET "WEBFLEET_AUTHORIZATION")
        account = "myaccount"
        apikey = (GET SECRET "WEBFLEET_APIKEY")
        range = "range_pattern=d0"
```

## Deployable connector

The base address is already correct for every account. Set the secrets, then deploy.

```lot theme={"theme":"css-variables","languages":{"custom":["/languages/lot.json"]}}
# Coreflux REST_API template — Webfleet (Bridgestone) WEBFLEET.connect, CSV/JSON API with JSON output:
#   objects with latest positions, vehicles, groups, nearest vehicles, position tracks, trips and trip summaries,
#   standstills, digital I/O periods, events, orders, drivers and EU remaining driving times, addresses, KPIs,
#   EV battery level, diagnostic faults, temperature and cold chain sensors, asset tracker battery, the message
#   queue (create / pop / ack / delete), and writes (acknowledge / resolve events, send / cancel orders, destination
#   orders, text messages, switch a LINK output, Webfleet Plugin events and object data, generic action).
# Hugo catalog #191, Tier 2 (fleet). Spec: WEBFLEET.connect 1.75.0 Reference Guide
#   (https://www.webfleet.com/static/help/webfleet-connect/en_gb/index.html), fetched 2026-10-05 into
#   openapi-cache/webfleet/. Hand-curated (Webfleet publishes no OpenAPI).
# Docs: https://docs.coreflux.org/latest/lot-language/routes/rest-api-apps/webfleet
#
# Every call is GET (or form POST) https://csv.webfleet.com/extern?account=..&apikey=..&action=<operation>&...
#   with outputformat=json, useISO8601=true (dates in and out are ISO 8601, results in UTC) and useUTF8=true.
# Auth: HTTP Basic (RFC 7617) for the Webfleet user that has API rights, plus the account name and a 36-character
#   API key as query parameters. User name and password in the URL were removed end of June 2026.
#   Keep "Basic <base64(user:password)>" in broker secret WEBFLEET_AUTHORIZATION and the key in WEBFLEET_APIKEY,
#   and pass both in the payload with GET SECRET. The API user acts with its own Webfleet access rights.
# Errors: HTTP 200 with {"errorCode": <n>, "errorMsg": "..."} in JSON (also X-Webfleet-Errorcode /
#   X-Webfleet-Errormessage headers), e.g. 1143 "API key is invalid". Empty results are []; send / update
#   actions return an empty body on success.
# Request limits are per action and per account (comment above each event). showTripReportExtern and
#   showEventReportExtern allow 1 call per minute; for continuous tracking use the message queue
#   (CreateQueue once, then PopQueueMessages + AckQueueMessages, serialised) instead of polling ShowObjectReport.
# Writes are marked # WRITE. Restrict who can publish to those topics with an RBAC rule.
#
# Payload fields (JSON on the source topic): authorization, account, apikey on every event, plus:
#   objectno (object number), objectuid, latitude / longitude (micro degrees), range (date range query:
#   "range_pattern=d0" or "range_pattern=ud&rangefrom_string=2026-10-05T00:00:00Z&rangeto_string=2026-10-05T23:59:59Z"),
#   kpinames, msgclass, eventid, orderid, ordertext / messagetext / data (URL-encoded), status, output_name,
#   action + query (Extern; query starts with & or is ""), form (POST body tail, URL-encoded name=value pairs).
#     ShowObjectReport     {"authorization":"Basic ...","account":"myaccount","apikey":"..."}
#     ShowTracks           {..., "objectno":"001", "range":"range_pattern=d0"}
#     PopQueueMessages     {..., "msgclass":"2"}
#     SendOrder            {..., "objectno":"001", "orderid":"CF-1001", "ordertext":"Load%20pallets%20at%20dock%203"}
#     Extern               {..., "action":"showObjectReportExtern", "query":"&objectgroupname=Porto"}

DEFINE ROUTE WebfleetConnect WITH TYPE REST_API
    ADD REST_API_CONFIG
        WITH BASE_ADDRESS "https://csv.webfleet.com"
        WITH ENABLE_CLIENT "true"
        WITH USE_SSL "true"
        WITH REQUEST_TIMEOUT '30'
        WITH DEFAULT_CONTENT_TYPE "application/json"
        # BASE_ADDRESS is fixed for every account (https://csv.webfleet.com, path /extern). Only HTTPS is accepted.
        # Smoke: ShowObjectGroups -> ShowObjectReport -> ShowVehicleReport -> CreateQueue (2) -> PopQueueMessages -> AckQueueMessages.
    # Webfleet request limit for showObjectReportExtern: 6 / min.
    ADD EVENT ShowObjectReport
        WITH SOURCE_TOPIC "fleet/webfleet/objects/get"
        WITH DESTINATION_TOPIC "fleet/webfleet/objects/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=showObjectReportExtern"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # Webfleet request limit for showVehicleReportExtern: 10 / min.
    ADD EVENT ShowVehicleReport
        WITH SOURCE_TOPIC "fleet/webfleet/vehicles/get"
        WITH DESTINATION_TOPIC "fleet/webfleet/vehicles/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=showVehicleReportExtern"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # Webfleet request limit for showObjectGroups: 10 / min.
    ADD EVENT ShowObjectGroups
        WITH SOURCE_TOPIC "fleet/webfleet/object-groups/get"
        WITH DESTINATION_TOPIC "fleet/webfleet/object-groups/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=showObjectGroups"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # Webfleet request limit for showNearestVehicles: 10 / min.
    ADD EVENT ShowNearestVehicles
        WITH SOURCE_TOPIC "fleet/webfleet/vehicles/nearest/get"
        WITH DESTINATION_TOPIC "fleet/webfleet/vehicles/nearest/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=showNearestVehicles&latitude={value.json.latitude}&longitude={value.json.longitude}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # Webfleet request limit for showTracks: 10 / min.
    ADD EVENT ShowTracks
        WITH SOURCE_TOPIC "fleet/webfleet/tracks/get"
        WITH DESTINATION_TOPIC "fleet/webfleet/tracks/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=showTracks&objectno={value.json.objectno}&{value.json.range}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # Webfleet request limit for showTripReportExtern: 1 / min.
    ADD EVENT ShowTripReport
        WITH SOURCE_TOPIC "fleet/webfleet/trips/get"
        WITH DESTINATION_TOPIC "fleet/webfleet/trips/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=showTripReportExtern&{value.json.range}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # Webfleet request limit for showTripSummaryReportExtern: 10 / min.
    ADD EVENT ShowTripSummaryReport
        WITH SOURCE_TOPIC "fleet/webfleet/trips/summary/get"
        WITH DESTINATION_TOPIC "fleet/webfleet/trips/summary/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=showTripSummaryReportExtern&objectno={value.json.objectno}&{value.json.range}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # Webfleet request limit for showStandStills: 6 / min.
    ADD EVENT ShowStandStills
        WITH SOURCE_TOPIC "fleet/webfleet/standstills/get"
        WITH DESTINATION_TOPIC "fleet/webfleet/standstills/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=showStandStills&objectno={value.json.objectno}&{value.json.range}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # Webfleet request limit for showIOReportExtern: 10 / min.
    ADD EVENT ShowIOReport
        WITH SOURCE_TOPIC "fleet/webfleet/io/get"
        WITH DESTINATION_TOPIC "fleet/webfleet/io/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=showIOReportExtern&objectno={value.json.objectno}&{value.json.range}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # Webfleet request limit for showEventReportExtern: 1 / min.
    ADD EVENT ShowEventReport
        WITH SOURCE_TOPIC "fleet/webfleet/events/get"
        WITH DESTINATION_TOPIC "fleet/webfleet/events/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=showEventReportExtern&{value.json.range}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # Webfleet request limit for showOrderReportExtern: 6 / min.
    ADD EVENT ShowOrderReport
        WITH SOURCE_TOPIC "fleet/webfleet/orders/get"
        WITH DESTINATION_TOPIC "fleet/webfleet/orders/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=showOrderReportExtern&{value.json.range}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # Webfleet request limit for showDriverReportExtern: 10 / min.
    ADD EVENT ShowDriverReport
        WITH SOURCE_TOPIC "fleet/webfleet/drivers/get"
        WITH DESTINATION_TOPIC "fleet/webfleet/drivers/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=showDriverReportExtern"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # Webfleet request limit for getRemainingDrivingTimesEU: 10 / min.
    ADD EVENT GetRemainingDrivingTimesEU
        WITH SOURCE_TOPIC "fleet/webfleet/drivers/driving-times/get"
        WITH DESTINATION_TOPIC "fleet/webfleet/drivers/driving-times/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=getRemainingDrivingTimesEU"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # Webfleet request limit for showAddressReportExtern: 6 / min.
    ADD EVENT ShowAddressReport
        WITH SOURCE_TOPIC "fleet/webfleet/addresses/get"
        WITH DESTINATION_TOPIC "fleet/webfleet/addresses/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=showAddressReportExtern"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # Webfleet request limit for getObjectKPIs: 10 / min.
    ADD EVENT GetObjectKPIs
        WITH SOURCE_TOPIC "fleet/webfleet/kpis/get"
        WITH DESTINATION_TOPIC "fleet/webfleet/kpis/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=getObjectKPIs&objectno={value.json.objectno}&kpinames={value.json.kpinames}&{value.json.range}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # Webfleet request limit for getElectricVehicleData: 6 / min.
    ADD EVENT GetElectricVehicleData
        WITH SOURCE_TOPIC "fleet/webfleet/ev/get"
        WITH DESTINATION_TOPIC "fleet/webfleet/ev/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=getElectricVehicleData"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # Webfleet request limit for getDiagnosticFaults: 10 / min.
    ADD EVENT GetDiagnosticFaults
        WITH SOURCE_TOPIC "fleet/webfleet/diagnostics/faults/get"
        WITH DESTINATION_TOPIC "fleet/webfleet/diagnostics/faults/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=getDiagnosticFaults&{value.json.range}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # Webfleet request limit for getCurrentTemperatureData: 10 / min.
    ADD EVENT GetCurrentTemperatureData
        WITH SOURCE_TOPIC "fleet/webfleet/temperature/get"
        WITH DESTINATION_TOPIC "fleet/webfleet/temperature/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=getCurrentTemperatureData"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # Webfleet request limit for getCurrentColdChainSensorData: 10 / min.
    ADD EVENT GetCurrentColdChainSensorData
        WITH SOURCE_TOPIC "fleet/webfleet/coldchain/get"
        WITH DESTINATION_TOPIC "fleet/webfleet/coldchain/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=getCurrentColdChainSensorData"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # Webfleet request limit for getTelemetryDeviceBatteryState: 10 / min.
    ADD EVENT GetTelemetryDeviceBatteryState
        WITH SOURCE_TOPIC "fleet/webfleet/device-battery/get"
        WITH DESTINATION_TOPIC "fleet/webfleet/device-battery/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=getTelemetryDeviceBatteryState&objectuid={value.json.objectuid}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # Webfleet request limit for popQueueMessagesExtern: 10 / min.
    ADD EVENT PopQueueMessages
        WITH SOURCE_TOPIC "fleet/webfleet/queue/pop"
        WITH DESTINATION_TOPIC "fleet/webfleet/queue/pop/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=popQueueMessagesExtern&msgclass={value.json.msgclass}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # WRITE: AckQueueMessages changes data in Webfleet or on a vehicle. Restrict who can publish to fleet/webfleet/queue/ack.
    # Webfleet request limit for ackQueueMessagesExtern: 10 / min.
    ADD EVENT AckQueueMessages
        WITH SOURCE_TOPIC "fleet/webfleet/queue/ack"
        WITH DESTINATION_TOPIC "fleet/webfleet/queue/ack/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=ackQueueMessagesExtern&msgclass={value.json.msgclass}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # WRITE: CreateQueue changes data in Webfleet or on a vehicle. Restrict who can publish to fleet/webfleet/queue/create.
    # Webfleet request limit for createQueueExtern: 10 / 24 h.
    ADD EVENT CreateQueue
        WITH SOURCE_TOPIC "fleet/webfleet/queue/create"
        WITH DESTINATION_TOPIC "fleet/webfleet/queue/create/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=createQueueExtern&msgclass={value.json.msgclass}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # WRITE: DeleteQueue changes data in Webfleet or on a vehicle. Restrict who can publish to fleet/webfleet/queue/delete.
    # Webfleet request limit for deleteQueueExtern: 10 / 24 h.
    ADD EVENT DeleteQueue
        WITH SOURCE_TOPIC "fleet/webfleet/queue/delete"
        WITH DESTINATION_TOPIC "fleet/webfleet/queue/delete/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=deleteQueueExtern&msgclass={value.json.msgclass}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # WRITE: AcknowledgeEvent changes data in Webfleet or on a vehicle. Restrict who can publish to fleet/webfleet/events/acknowledge.
    # Webfleet request limit for acknowledgeEventExtern: 300 / 30 min.
    ADD EVENT AcknowledgeEvent
        WITH SOURCE_TOPIC "fleet/webfleet/events/acknowledge"
        WITH DESTINATION_TOPIC "fleet/webfleet/events/acknowledge/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=acknowledgeEventExtern&eventid={value.json.eventid}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # WRITE: ResolveEvent changes data in Webfleet or on a vehicle. Restrict who can publish to fleet/webfleet/events/resolve.
    # Webfleet request limit for resolveEventExtern: 300 / 30 min.
    ADD EVENT ResolveEvent
        WITH SOURCE_TOPIC "fleet/webfleet/events/resolve"
        WITH DESTINATION_TOPIC "fleet/webfleet/events/resolve/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=resolveEventExtern&eventid={value.json.eventid}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # WRITE: SendOrder changes data in Webfleet or on a vehicle. Restrict who can publish to fleet/webfleet/orders/send.
    # Webfleet request limit for sendOrderExtern: 300 / 30 min.
    ADD EVENT SendOrder
        WITH SOURCE_TOPIC "fleet/webfleet/orders/send"
        WITH DESTINATION_TOPIC "fleet/webfleet/orders/send/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=sendOrderExtern&objectno={value.json.objectno}&orderid={value.json.orderid}&ordertext={value.json.ordertext}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # WRITE: SendDestinationOrder changes data in Webfleet or on a vehicle. Restrict who can publish to fleet/webfleet/orders/destination/send.
    # Webfleet request limit for sendDestinationOrderExtern: 300 / 30 min.
    ADD EVENT SendDestinationOrder
        WITH SOURCE_TOPIC "fleet/webfleet/orders/destination/send"
        WITH DESTINATION_TOPIC "fleet/webfleet/orders/destination/send/response"
        WITH METHOD "POST"
        WITH ENDPOINT "/extern"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
            ADD "Content-Type" "application/x-www-form-urlencoded;charset=UTF-8"
        WITH BODY "account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=sendDestinationOrderExtern&{value.json.form}"
    # WRITE: CancelOrder changes data in Webfleet or on a vehicle. Restrict who can publish to fleet/webfleet/orders/cancel.
    # Webfleet request limit for cancelOrderExtern: 300 / 30 min.
    ADD EVENT CancelOrder
        WITH SOURCE_TOPIC "fleet/webfleet/orders/cancel"
        WITH DESTINATION_TOPIC "fleet/webfleet/orders/cancel/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=cancelOrderExtern&orderid={value.json.orderid}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # WRITE: SendTextMessage changes data in Webfleet or on a vehicle. Restrict who can publish to fleet/webfleet/messages/send.
    # Webfleet request limit for sendTextMessageExtern: 300 / 30 min.
    ADD EVENT SendTextMessage
        WITH SOURCE_TOPIC "fleet/webfleet/messages/send"
        WITH DESTINATION_TOPIC "fleet/webfleet/messages/send/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=sendTextMessageExtern&objectno={value.json.objectno}&messagetext={value.json.messagetext}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # WRITE: SwitchOutput changes data in Webfleet or on a vehicle. Restrict who can publish to fleet/webfleet/outputs/switch.
    # Webfleet request limit for switchOutput: 10 / min.
    ADD EVENT SwitchOutput
        WITH SOURCE_TOPIC "fleet/webfleet/outputs/switch"
        WITH DESTINATION_TOPIC "fleet/webfleet/outputs/switch/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=switchOutput&objectno={value.json.objectno}&status={value.json.status}&output_name={value.json.output_name}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # WRITE: InsertExternalEvent changes data in Webfleet or on a vehicle. Restrict who can publish to fleet/webfleet/plugin/events/insert.
    # Webfleet request limit for insertExternalEvent: 5 / min.
    ADD EVENT InsertExternalEvent
        WITH SOURCE_TOPIC "fleet/webfleet/plugin/events/insert"
        WITH DESTINATION_TOPIC "fleet/webfleet/plugin/events/insert/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=insertExternalEvent&objectno={value.json.objectno}&data={value.json.data}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # WRITE: SetExternalObjectData changes data in Webfleet or on a vehicle. Restrict who can publish to fleet/webfleet/plugin/object-data/set.
    # Webfleet request limit for setExternalObjectData: 10 / min.
    ADD EVENT SetExternalObjectData
        WITH SOURCE_TOPIC "fleet/webfleet/plugin/object-data/set"
        WITH DESTINATION_TOPIC "fleet/webfleet/plugin/object-data/set/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action=setExternalObjectData&objectno={value.json.objectno}&data={value.json.data}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # WRITE: Extern changes data in Webfleet or on a vehicle. Restrict who can publish to fleet/webfleet/extern.
    # Webfleet request limit for the chosen action: per action.
    ADD EVENT Extern
        WITH SOURCE_TOPIC "fleet/webfleet/extern"
        WITH DESTINATION_TOPIC "fleet/webfleet/extern/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/extern?account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&action={value.json.action}{value.json.query}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
    # WRITE: ExternPost changes data in Webfleet or on a vehicle. Restrict who can publish to fleet/webfleet/extern/post.
    # Webfleet request limit for the chosen action: per action.
    ADD EVENT ExternPost
        WITH SOURCE_TOPIC "fleet/webfleet/extern/post"
        WITH DESTINATION_TOPIC "fleet/webfleet/extern/post/response"
        WITH METHOD "POST"
        WITH ENDPOINT "/extern"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "Authorization" "{value.json.authorization}"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
            ADD "Content-Type" "application/x-www-form-urlencoded;charset=UTF-8"
        WITH BODY "account={value.json.account}&apikey={value.json.apikey}&lang=en&outputformat=json&useISO8601=true&useUTF8=true&{value.json.form}"
```

## Testing

See `TEST.md` in the package. Static checks against the WEBFLEET.connect reference (every action, parameter and request limit), a local mock of the API and the error controls all pass, and the real endpoint was confirmed to reject calls without a valid key (`errorCode 1143`). A live run needs an account, an API key and an API user: `WEBFLEET_ACCOUNT=... WEBFLEET_APIKEY=... WEBFLEET_USER=... WEBFLEET_PASSWORD=... python3 smoke_webfleet.py`.

## Suggested branches

* `feat/rest-api-route-webfleet`
* `feat/docs-rest-api-webfleet`

Hugo owns GitHub pushes. Nothing was pushed from the factory.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.