Platform Overview

What is Live Objects?

Live Objects is a Software-as-a-Service (SaaS) solution that securely connects devices and business applications and helps you ingest, store, process, and route telemetry at scale. It is part of Orange’s IoT & Data Analytics services.

Designed for IoT/M2M solution integrators, it provides tools to simplify interactions between devices (connected “things”) and business applications.

Key capabilities include:

  • Connectivity interfaces to collect data, send commands, or trigger notifications to/from IoT/M2M devices

  • Device management: inventory, supervision, configuration, resources, and campaign management

  • Data processing: storage with advanced search, message enrichment/decoding, and custom pipelines

  • Message routing: rule‑based delivery to applications via FIFO topics (Application mode) or HTTP push, with at‑least‑once semantics

Interactive
Figure 1. Live Objects Overview

The platform operates in SaaS mode and supports multiple tenants with full data isolation. Public interfaces are accessible via the Internet; dedicated IoT networks like LoRaWAN are interfaced through their network servers.

A web portal provides administration features to manage messages and events, supervise devices, and control tenant access.

Architecture

The Live Objects SaaS architecture consists of two main layers:

  • Connectivity layer: manages communications with client devices and applications

  • Service layer: provides high‑level services such as device management, data processing, routing, and storage

Interactive
Figure 2. Live Objects Architecture

Connectivity Layer

Live Objects offers two complementary ways to bring data into the platform:

  • device connectivity interfaces (device session or network‑level path),

  • data ingestion without a device session (server-side/IT systems).

Terminology: - “Device connectivity interfaces” are publicly available platform interfaces for devices on IP networks (MQTT, LwM2M), IoT LPWAN (LoRaWAN), or SMS. - The only “private interface” is the External Connector, used by your backend as a protocol bridge.

Device connectivity interfaces (devices)

Use this when a device communicates with the platform (over IP, LPWAN, or SMS):

  • MQTT(S)

    • Lightweight, bidirectional, near real time. Small-footprint clients. Default choice for IP-capable devices.

  • LwM2M/CoAP

    • For constrained devices needing standardized device management (resources, configuration, firmware). Secured with DTLS‑PSK.

  • LoRaWAN (LoRa®)

    • Dedicated IoT LPWAN: long‑range, low‑power, very small payloads. Uplink‑first (Class A by default); downlinks sent in RX windows. Devices identified by DevEUI; join/auth handled by the LoRa Network Server (LNS).

  • SMS

    • Fallback or sparse uplinks when IP is unavailable (very small payloads, higher latency).

Security (recap)

  • MQTT(S) (devices) — Authentication with an API key (used as MQTT credentials). See API Key and MQTT.

  • LwM2M/CoAP (devices) — DTLS‑PSK authentication (identity/secret per LwM2M endpoint). See LwM2M.

  • LoRaWAN (devices) — LoRaWAN‑layer credentials via the LNS (OTAA/ABP). Devices are linked by DevEUI in Live Objects. See LoRa®.

  • SMS (devices) — Identification by sender (MSISDN/IMEI) per connector configuration; application access via API key. See SMS.

Data ingestion without device session (HTTP emulated interface)

Use this to inject data produced by servers, enterprise IT systems, batch jobs, or simulators — without a device connection:

  • No SaaS→device push over HTTP; for device commands, use a device connectivity interface (e.g., MQTT or LwM2M).

  • Authentication is via API key. Injected messages enter the same pipelines: storage, search, routing, rules/alerts, consumption via FIFO.

Private interface

If your devices cannot use the public device interfaces, implement your backend that translates your proprietary protocol into Live Objects messages and connect it over MQTT:

  • External Connector mode — your backend acts as a private bridge/protocol adapter to Live Objects (authentication via API key).

Service Layer

Beyond connectivity, Live Objects provides ready-to-use services to accelerate your IoT workflows.

  • Data collection and processing: internal enrichment, decoding, and custom external pipelines

  • Application access and delivery: publish data to a FIFO, these data can be consumed from a FIFO queue using MQTT Application mode; optionally deliver via HTTP push

  • FIFO: ensures at‑least‑once delivery; messages are stored until acknowledged. Supports multiple consumers with load balancing. FIFO Mode

  • Application mode: real-time exchanges between Live Objects and business applications (built on FIFO). Application Mode

Device Management

Operators can:

  • Manage the fleet at scale: inventory, tags/groups, search/filters, bulk actions and campaigns

  • Monitor device connectivity and health

  • Manage configuration parameters (per device or in bulk)

  • Send commands and track execution status

  • Deploy resources (binary files) and monitor delivery (per device or via campaigns)

"Device and Connectivity Inventory" "Device Connectors" "Device Management"

Data Management

Data Transformation

Transform messages using data enrichment, decoding, and external pipelines.

"Data Transformation"

LoRa payload decoders

Use decoders to parse binary LoRaWAN uplinks into structured fields (and optionally encode downlinks). You can also enrich messages during decoding (units, normalization, derived metrics).

  • Create or import decoders for your device payload format

  • Version and test decoders in the portal before enabling them in production

  • Apply decoders per device type or routing context; decoded/enriched fields are available to rules, search, and routing

See the “Decoders” subsection in Data Transformation.

Custom Pipeline Tutorial

Use custom pipelines to enrich, decode, or transform your data before storage

Data Analysis and Display

Store collected data and retrieve it via REST/HTTPS APIs. Analyze stored data using a full‑text search engine (Elasticsearch).

"Data Analysis"

Message routing

Message routing is a service that delivers selected device data and platform events to your applications. Define routing rules to forward messages to applications and services:

  • Destinations: FIFO topics consumed by your backend (via Application mode) or HTTP push (webhooks) to external endpoints.

  • Rules and filters: Unconditional (by source or topic), device attributes/tags, or content‑based rules, integration with event processing (SEP/AP/SP) to route only when conditions are met.

  • Management & monitoring: configure via portal or APIs; monitor with metrics and the Audit Log feature.

To learn more, See also Message routing, FIFO Mode and Application Mode.

Message and Event Processing

Routing and notifications can forward messages via FIFO or HTTP push based on these processing outcomes.

Troubleshooting (first checks)

  • Permissions: verify your API key scopes.

  • Identifiers: Device ID / endpoint / DevEUI consistent across steps.

  • Payload: conforms to message data model.

  • Portal: confirm ingestion in Data Explorer (filter by deviceId/topic and time range).

  • Logs: check Audit Log for recent errors.

Access Control

API Keys

API keys control access for devices, applications, and users. Create and manage them via APIs or the portal. "API Key" · "Roles"

User Management

Administrators can create users and assign roles to manage permissions in the Live Objects web portal.

Edge Computing

For advanced scenarios, integrate edge computing platforms to:

  • Process data locally with low latency

  • Ensure interoperability with industrial protocols

  • Keep sensitive business data on site

Edge Integration Video

Illustration of integrating Live Objects with a large IoT ecosystem

Also in this guide

Version 2026.7.0 • Updated date 2026-08-11 12:37:29 UTC