Monitor Recon Robots

Two kinds of reads cover a robot fleet: the state operations say what each robot is doing now, and the events operation says what it did. The examples use the robot_api helper from the overview.

You need an API key with read-only access to the robots' locations.

Fleet state

getMinimalStateList returns one entry per robot:

for robot in robot_api("getMinimalStateList", {})["minimalStates"]:
    progress = ""
    if robot.get("activity") == "ROUTE_RUN" and robot.get("waypointTotal"):
        progress = f"stop {robot['waypointIndex'] + 1} of {robot['waypointTotal']}"
    print(f"{robot['name']}: {robot['connectionStatus']}, {robot.get('batteryPercent')}%, {robot.get('activity')} {progress}")

For one robot, getFullState returns the same fields plus the robot's capabilities. Include force (false is fine); the call is refused without it:

state = robot_api("getFullState", {"deviceUuid": ROBOT_UUID, "force": False})["fullState"]
capability = state.get("robotPlatformCapability") or {}
print(state["activity"], state.get("phase"), capability.get("supportedActions"))

Use activity and phase to tell whether a robot is docked, charging or out working; the mode and charging fields aren't reported.

Activities

New values can be added. Treat one you don't recognize as busy.

Event history

findRobotEvents returns what a robot did between startMs (inclusive) and endMs (exclusive). The response is newline-delimited JSON (application/x-ndjson), one event per line, newest first:

import json
import time

def robot_events(robot_uuid, start_ms, end_ms):
    response = requests.post(
        f"{API}/findRobotEvents",
        headers=HEADERS,
        json={"deviceUuid": robot_uuid, "startMs": start_ms, "endMs": end_ms},
        timeout=60,
    )
    response.raise_for_status()
    events = []
    for line in response.text.splitlines():
        if not line.strip():
            continue
        event = json.loads(line)
        if "_error" in event:
            raise RuntimeError(f"findRobotEvents stopped early: {event.get('_message')}")
        events.append(event)
    return events

now = int(time.time() * 1000)
for event in robot_events(ROBOT_UUID, now - 24 * 3600 * 1000, now):
    print(event["timestampMs"], event.get("activity"), event.get("event"), event.get("phase"), event.get("failureReason"))

• There's no paging. Ask for a window you can handle, a day for example, and walk back window by window for longer periods.
• A last line with _error means the stream stopped before the end, though the status is 200. Retry that window.
• Events can arrive late. A robot that was offline uploads what it recorded when it reconnects, with the original timestampMs. When you collect events on a schedule, overlap the windows and skip events whose uuid you've already stored.

Each activity follows the same lifecycle: STARTED, then PROGRESS events as it moves through its phases (arriving at a stop is a PROGRESS event whose phaseEvent is COMPLETED), possibly SUSPENDED and RESUMED when something with higher priority interrupts it, and exactly one of COMPLETED, FAILED or CANCELED at the end. An activity the robot refused is a single REJECTED event, with preemptedBy naming what blocked it.

Alert on what matters

Polling the state list every minute or two is far below your rate limit. Robot events don't arrive on the event WebSocket or on organization webhooks; for real-time updates, connect to the robot live socket.