Skip to content

Sending requests

Once you are connected to an IoTize Tap, you can perform requests.

Available commands are organized into services. See the list of services and functions.

There are two ways to send requests to your Tap:

Service API

The Service API is a wrapper on the IoTize client that lists availables services and handles requestbuilding and binary parsing of responses.

If you want to send raw requests, you can use the client directly (see Client API)

Accessing service object

import { IoTizeDevice } from "@iotize/device-client.js/device";
import { BundleService } from "@iotize/device-client.js/device/service/bundle-service";
import { TargetService } from "@iotize/device-client.js/device/service/target-service";
import { FirmwareService } from "@iotize/device-client.js/device/service/firwmare-service";

IoTizeDevice device = ...;

let bundleService: BundleService = device.service.bundle;
let targetService: TargetService =;
let firmwareService: FirmwareService = device.service.firmware;
// ...

IoTizeDevice device = // ... ;

// Access different services:
BundleService bundleService = device.service.bundle;
TargetService targetService =;
FirmwareService firmwareService = device.service.firmware;
// ...

Performing calls

You can make synchronous or asynchronous calls to the tap device.


// Only available if you are in an ASYNC function
let response: Response<string> = await device.service.device.getSerialNumber();
Call<String> call = device.service.device.getSerialNumber();
Response<String> response = call.execute();

Asynchronously, with callbacks

let response: Promise<Response<string>> = device.service.device.getSerialNumber();

    .then((response: Response<string>) => {
        console.log('Device response:', response);
    .catch((error) => {
        console.error('An error occured:', error);
Call<String> call =;
commandCall.enqueue(new ICallback<String>() {
    public void onResponse(Call<String> call, Response<String> response) {
        // Do what you need here

    public void onFailure(Call<String> call, Throwable throwable) {
        Log.e("yourlogtag", "Error occured: " + throwable.getMessage(), throwable);

Client API

Command format

IoTize LwM2M commands are composed of:

  • header: command type (GET, PUT or POST) and command path string with <Object ID>/<Object Instance ID>/<Resource ID>.
  • payload: in bytes.

Building a command

Commands are built by a Command Object. You can use helper methods to instantiate it according to the request type you want to use.

import { Command } from '@iotize/device-client.js/client/impl/request';
// Get command
let command = Command.GET("/1/2/3")
// Put command
let command = Command.PUT("/1/2/3")
// Post command
let command = Command.POST("/1/2/3")

// Get command
Command command = Command.GET("/1/2/3")
// Put command
Command command = Command.PUT("/1/2/3")
// Post command
Command command = Command.POST("/1/2/3")
// Get command
let command = IoTizeDeviceClient.Client.Command.GET("/1/2/3");
// Put command
let command = IoTizeDeviceClient.Client.Command.PUT("/1/2/3")
// Post command
let command = IoTizeDeviceClient.Client.Command.POST("/1/2/3")

If resource id is null, omit it (meaning it's a singleton object)

// Get command with resource id null
let command = Command.GET("/1//3")
// Get command with resource id null
Command command = Command.GET("/1//3")

You can add a command payload with the second parameter (optional):

let data = new Uint8Array([1,2,3]);
let command = Command.POST("/1/2/3", data)
byte[] data = // Your data...
Command command = Command.POST("/1/2/3", data)

Sending command

You can use a client implementation:

import { Command } from "@iotize/device-client.js/client/impl/request";
import { DefaultIoTizeClient } from "@iotize/device-client.js/client/impl";
import { Response } from '@iotize/device-client.js/client/impl/response';

let protocol: ComProtocol = // ...;
let client = new DefaultIoTizeClient.create(protocol);

    .then(function() {
        // Command to read tap device serial number
        let command: Command = Command.GET("/1024//2");
        return client.send(command);
    .then(function(response: Reponse<Uint8Array>){
        console.log(`Response: ${response}`);

ComProtocol protocol = // your communication protocol;
IoTize client = new IoTizeClient(protocol);

// Command to read tap device serial number
Command command = Command.GET("/1024//2");
byte[] response = client.send(command);

Handling Response

A response is composed of

  • result code: See the list of result code returns by a Tap.
  • payload (optionally): encoded data (bytes)

A Response can be configured with a Converter class to decode bytes into the corresponding type.

If you are using the Service API, Response is preconfigured with the proper Converter instance.

We suppose in the following examples that we have a response for the getSerialNumber command which returns an ASCII string.

import { Response } from "@iotize/device-client.js/client/impl/response"

let response: Response<string> = //...;

if (response.isSuccess()){
    // If you are using Service API
    let serialNumber = response.body();

    // Or if you build request with the client, you can give the converter type
    let serialNumber = resonse.body(StringConverter.instance());
else {
    // Handle invalid response
    console.error(`Response error: ${response.codeRet()}`);

Response<String> response = // ...;

// Check if command was successful
if (response.isSuccessful()){
    String serialNumber = response.body();
    Log.i("yourlogtag", "Serial number is : " + serialNumber);
    // If command is not successful we can check error code to know why
    Log.w("yourtag", "Iotize error code: " + response.codeRet());

You can also access raw body (without any decoding)

let body: Uint8Array = response.rawBody();
byte[] body = response.rawBody();