With the industry’s first Message-based pricing model, Octave brings simplicity and predictability, and control to cellular IoT pricing. This topic provides full details on the Octave pricing model.

Overview

Octave pricing is metered on a simple model with two components:

1. a platform fee that includes full access to the Sierra Wireless Global Wireless Network, development tools, and cloud APIs.
2. a usage fee based on the number of Messages sent and received. A Message is a payload with up to 20 datapoints.

Your overall monthly fee is determined by the number of communicating devices on your platform, the total number of Messages transmitted, and the region where those devices are located. The table below shows the pricing structure.

Example

You want to set up a connected water monitoring deployment with 500 solar powered telemetry systems. Let’s figure out what your monthly budget should look like.

You set up your Octave edge device to monitor three Datapoints:

• Groundwater level
• Acidity
• Battery level

You want to log these Datapoints every hour but don’t need real-time updates - you’re happy to get the data every 6 hours. With Octave, that will generate 4 Messages per day x 30 days x 500 devices = 60,000 Messages per month.

Your deployment is in Region A, so your rate is $1 monthly per connected device plus $1 for every 1000 Messages. This works out to a monthly total of $560 per month, or $1.12 per telemetry system.

Pricing Details

Platform Fee

The monthly platform fee for your deployment covers:

• Secure network connectivity in over 160 countries via the Sierra Wireless Global Wireless Network.
• Device and connectivity management for monitoring and configuring your devices​.
• Ongoing security patches, including two over-the-air software updates for your Octave edge devices per year.
• Use of Octave APIs and graphical user interface.

The billing rules are as follows:

• The platform fee is calculated by the number of communicating devices in each month. Any device that sends or receives a Message at any point during a month will generate a platform fee charge for that month. There is no prorating of the platform fee.
• Devices can be removed and added at any time.
• If a registered device doesn't communicate for 12 consecutive months, it's subscription will be automatically revoked.

📘

Example

On March 1, you have 1200 devices registered on Octave, communicating on a daily basis. On March 15 you add 300 devices to your fleet. Your platform fee for March will be calculated on 1500 devices.

Messages and Datapoints

An Octave Message consists of one or more Events, transmitted from device to cloud or vice versa. Messages are metered by the number of Datapoints they contain. A Datapoint is a single data value (e.g., temperature reading) which can be represented as a "key" : "value" pair where the value is a JavaScript primitive data type (e.g., number, boolean, or string up to 25 characters). JSON objects and arrays are metered by the number of Datapoints contained in those objects.

📘

Note

Additional metadata (e.g., location, time) sent by Octave is not counted as a Datapoint.

Example Events and Messages

Event with 2 Datapoints
This event has 2 datapoints and would be sent as one message

{
    "light": 537, 
    "temperature": "29.3"
}

Datapoints in nested objects and arrays
Values in nested objects and arrays are counted as Datapoints. The following Event has 4 Datapoints.

{
    "lightvalues": [537, 532], 
    "tempvalues": [29.3, 30.1]
}

Strings
Strings are measured as 1 Datapoint per 25 characters, rounded up. For example, a string of up to 25 characters is one Datapoint, a string of up to 50 characters is 2 Datapoints, and so on. The below Message has 3 Datapoints in total.

{
    "shortstring": "i am one datapoint", 
    "longstring": "this string has two datapoints"
}

Large Events
Events can exceed 20 Datapoints - in this case they are metered as multiple Messages. The number of Messages needed to transmit an event is the total number of datapoints divided by 20, rounded up. For example, the below Event would be counted as 2 messages.

{
  "elems": {
    "virtual": {
      "report": {
        "ten_datapoints": [0,1,2,3,4,5,6,7,8,9],
        "ten_more_datapoints": [10,11,12,13,14,15,16,17,18,19],
        "another_datapoint": "I am the 21st datapoint"
      }
    }
  },
  "generatedDate": 1592283014052}

Event Elements and Metadata
In Octave, Event data is augmented by metadata which is not counted towards the Datapoint total. Only the values of elems are counted. The below Event has 2 Datapoints.

{
  "creationDate": 1592283014996,
  "creatorId": "i000000000000000000000001",
  "elems": {
    "virtual": {
      "report": {
        "light": 537, // first datapoint
        "temperature": "29.3" // second datapoint
      }
    }
  },
  "generatedDate": 1592283014052,
  "hash": null,
  "id": "e5ee84f865dc8dd427148cc2e",
  "lastEditDate": 1592283014996,
  "lastEditorId": "i000000000000000000000001",
  "location": null,
  "metadata": {
  },
  "path": "/test_1/devices/mangohred_test1/report",
  "streamId": "s5e9641aeb20f2739ae2f7d77",
  "tags": {
  }
}

Aggregating Events
Octave automatically aggregates events together at the edge before transmitting to the cloud. By using Store and Forward Events, you can combine different events into the same message. For example, the two events below would together count as 12 Datapoints, so 1 message.

// one Event with 10 datapoints
    {
      "elems": {
        "virtual": {
          "report": {
            "ten_datapoints": [0,1,2,3,4,5,6,7,8,9]
          }
        }
      },
      "generatedDate": 1592283016052}

// one Event with 2 datapoints
      {
        "elems": {
          "virtual": {
            "report": {
              "aboolean": true,
              "anumber":12
            }
          }
        },
        "generatedDate": 1592283016052}

👍

Optimizing your data usage

To optimize your data usage and minimize your Message count, you should make use of Octave's Store and Forward to bundle events into a single Message. You should also set up the device to minimize messages.

Regions

All your Octave devices are automatically assigned to one of four pricing regions, depending on where they are in the given monthly billing cycle. Devices are not locked to a specific region - they can move from one to another without any change to the subscription. At the end of each month, all charges for your entire global deployment are aggregated on a single invoice.

For a complete listing of countries and regions, please take a look at our pricing tool.

Devices which move from one region to another in a given billing period will have the platform fee billed to the higher-cost region. Messages will be billed according to where they are sent/received.

Developer Mode

When you first start to prototype your solution with Octave, you will want a continuous link between device and cloud to make frequent updates and configuration changes. This will result in a high number of messages. Developer Mode is designed to simplify the development process without incurring excessive costs to the user.

Devices in Developer Mode are automatically synchronized with the cloud, so all settings are continually updated. In addition, devices in Developer Mode can transmit up to 20 thousand messages at a discounted flat rate. Developer Mode can be enabled on any device at any time - it’s not a separate data plan.

Messages sent past the 20K threshold are charged normally. There is a limit of 50 developer mode devices per account at any one time.

Firmware Over-the-Air Updates (FOTA)

Your Octave account is permitted two firmware over-the-air updates per year per device. These include necessary “push” updates, such as security patches, initiated by Sierra Wireless. You can also perform an unlimited number of updates to your device locally (i.e., by directly connecting a laptop directly to your device) via the command line (see the device-specific tutorials in the Upgrade your Device topics in the table of contents).

Firmware refers to the software on the Octave edge device, including modem-level firmware, operating system, Octave services, and customer applications built on the Legato framework. Firmware excludes any data orchestration elements created by the customer such as Resources, Observations, and Edge Actions. These can be updated dynamically without consuming a FOTA update.

Customers wishing to execute additional FOTA updates can do so at the rate plan listed below: