cloudloop

The cloudloop Developer Hub

Welcome to the cloudloop developer hub. You'll find comprehensive guides and documentation to help you start working with cloudloop as quickly as possible, as well as support if you get stuck. Let's jump right in!

Get Started    
Suggest Edits

Hello

Welcome to cloudloop

 

cloudloop is a contract management and billing platform for the Iridium Satellite network.

Through a self-service web-based management console and an extensive API, cloudloop can offer extremely competitive rates for Iridium SBD and Telephony plans.

Suggest Edits

Authentication

 

Access Tokens

All requests require a token parameter to be provided.

For security purposes, we recommend that you create a new token using User/DoGenerateToken when you first receive your token.

Once generated tokens cannot be recovered; it's therefore very important that you securely retain your token for future invocations.

Suggest Edits

Workflows

Typical workflows for Telephony/Iridium GO!

 

Creating & Activating Iridium Go! Contract

  • /Sim/CreateSim - with ICCID of SIM

  • /Hardware/CreateHardware - with IMEI of Iridium Go! device

  • /Telephony/CreateSubscriber - with CloudLoop Sim Id (and optional name/reference)

  • /Telephony/GetPlans - retrieve available plans

  • /Telephony/DoActivateSubscriber - with CloudLoop Subscriber Id, Hardware Id and Plan NAME

Deactivating Iridium Go! Contract

  • /Telephony/DoDeactivate - with CloudLoop Subscriber Id

Retrieve Itemised Usage

  • /Telephony/GetUsage - with CloudLoop Subscriber Id, Year and Month

Retrieve Usage Summary

Review inclusive usage for given period

  • /Telephony/GetUsageSummary - with CloudLoop Subscriber Id, Year and Month

Retrieve Pool Summary

Review inclusive usage for any Pooled plans

  • /Telephony/GetPoolSummary - with Year and Month
Suggest Edits

Create Subscriber

Create new Subscriber from CloudLoop Sim Id

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Telephony/CreateSubscriber
curl --request GET \
  --url https://api.cloudloop.com/Telephony/CreateSubscriber
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Telephony/CreateSubscriber' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Telephony/CreateSubscriber")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Telephony/CreateSubscriber");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Telephony/CreateSubscriber"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "subscriber": {
    "createdAt": "2018-05-04T08:50:47.267",
    "sim": "VkqZoXzLRdyeJGnwKOnYwbQalDrPxMAj",
    "contract": null,
    "name": "Example Subscriber",
    "id": "gKbONwVrMLJxkeWGAzBPDyqjAvGQXzoZ",
    "account": "XgwyNPpDmebJLWXaaqEoARqxMdZOVGva"
  }
}
{
  "at": 1525423899542,
  "error": "DispatcherInputException"
}
{
  "at": 1525423986189,
  "error": "DispatcherValidationException",
  "exceptions": [
    {
      "name": "Sim already used",
      "id": 2003
    }
  ]
}

Query Params

sim
string

Cloudloop Sim Id

name
string

Optional

 
Suggest Edits

Get Subscriber

Retrieve Subscriber by CloudLoop Subscriber Id or CloudLoop Sim Id

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Telephony/GetSubscriber
curl --request GET \
  --url https://api.cloudloop.com/Telephony/GetSubscriber
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Telephony/GetSubscriber' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Telephony/GetSubscriber")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Telephony/GetSubscriber");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Telephony/GetSubscriber"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "subscriber": {
    "createdAt": "2018-05-15T11:00:24",
    "sim": {
      "iccid": "1234567812345678123",
      "id": "joGRxQrXpzkPJEgKkGEydwYZbqmDagNA"
    },
    "contract": null,
    "name": "Test Subscriber",
    "id": "XgwyNPpDmebJLWXzqdBoARqxMdZOVGva",
    "account": "oDmGzOePxrJZKWADgbnagyQXlpAkvMwj",
    "hardware": null
  }
}
{
  "subscriber": {
    "createdAt": "2018-05-15T11:00:23",
    "sim": {
      "iccid": "1234567812345678123",
      "id": "mRbxMoAQkLdKJWkkjdWqYZpaOgjPwlyN"
    },
    "contract": {
      "subscriber": "JGjpPobLlmOdaEVkNOBAKYzNMgwVZkrR",
      "networkStatus": "ACTIVATING",
      "from": "2018-05-15T11:00:23",
      "id": "YAlRXzwrdjymbEKNXgWKLNxvPkMeqgGJ",
      "state": "NEW",
      "to": null,
      "plan": {
        "inclusive": 123,
        "pooled": false,
        "suspendible": false,
        "name": "CLOUDLOOP_PLAN_TEST",
        "description": "This is an example plan",
        "increment": 0,
        "commitment": 0,
        "id": "GjlwJvdrxpDoOWekbOBKbPLkQXeVAZgz",
        "minimum": 0
      },
      "hardware": "JGjpPobLlmOdanVaOABAKYzNMgwVZkrR"
    },
    "name": "Test Subscriber",
    "id": "JGjpPobLlmOdaEVkNOBAKYzNMgwVZkrR",
    "account": "KbONwVrMLJxkeWGdDdEPDyqjAvGQXzoZ",
    "hardware": {
      "imei": "123456789012345",
      "id": "JGjpPobLlmOdanVaOABAKYzNMgwVZkrR",
      "type": "IRIDIUM_TELEPHONY"
    }
  }
}
{
  "at": 1525424523296,
  "error": "DispatcherInputException"
}

Query Params

subscriber
string

CloudLoop Subscriber Id

 
Suggest Edits

Get Usage

Retrieve itemised usage for Subscriber in given month

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Telephony/GetUsage
curl --request GET \
  --url https://api.cloudloop.com/Telephony/GetUsage
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Telephony/GetUsage' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Telephony/GetUsage")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Telephony/GetUsage");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Telephony/GetUsage"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "usage": [
    {
      "duration": 41,
      "at": "2018-05-04T09:08:56",
      "cost": 4.100,
      "fee": "TELEPHONY_DATA_DIRECT_INTERNET_GO",
      "contract": "wbpYqLdxyzVrAEYRjDBQmgRMjGOvoeZk"
    },
    {
      "duration": 80,
      "at": "2018-05-04T09:08:57",
      "cost": 8.000,
      "fee": "TELEPHONY_VOICE_IRIDIUM_TO_PSTN",
      "contract": "wbpYqLdxyzVrAEYRjDBQmgRMjGOvoeZk"
    },
    {
      "duration": 58,
      "at": "2018-05-04T09:08:58",
      "cost": 5.800,
      "fee": "TELEPHONY_DATA_DIRECT_INTERNET_GO",
      "contract": "wbpYqLdxyzVrAEYRjDBQmgRMjGOvoeZk"
    },
    {
      "duration": 56,
      "at": "2018-05-04T09:08:59",
      "cost": 5.600,
      "fee": "TELEPHONY_VOICE_LOCAL_TO_IRIDIUM",
      "contract": "wbpYqLdxyzVrAEYRjDBQmgRMjGOvoeZk"
    },
    {
      "duration": 84,
      "at": "2018-05-04T09:09:00",
      "cost": 8.400,
      "fee": "TELEPHONY_DATA_DIRECT_INTERNET_GO",
      "contract": "wbpYqLdxyzVrAEYRjDBQmgRMjGOvoeZk"
    },
    {
      "duration": 56,
      "at": "2018-05-04T09:09:01",
      "cost": 5.600,
      "fee": "TELEPHONY_VOICE_IRIDIUM_TO_PSTN",
      "contract": "wbpYqLdxyzVrAEYRjDBQmgRMjGOvoeZk"
    },
    {
      "duration": 31,
      "at": "2018-05-04T09:09:02",
      "cost": 3.100,
      "fee": "TELEPHONY_DATA_DIRECT_INTERNET_GO",
      "contract": "wbpYqLdxyzVrAEYRjDBQmgRMjGOvoeZk"
    },
    {
      "duration": 33,
      "at": "2018-05-04T09:09:03",
      "cost": 3.300,
      "fee": "TELEPHONY_VOICE_LOCAL_TO_IRIDIUM",
      "contract": "wbpYqLdxyzVrAEYRjDBQmgRMjGOvoeZk"
    },
    {
      "duration": 86,
      "at": "2018-05-04T09:09:04",
      "cost": 8.600,
      "fee": "TELEPHONY_DATA_DIRECT_INTERNET_GO",
      "contract": "wbpYqLdxyzVrAEYRjDBQmgRMjGOvoeZk"
    },
    {
      "duration": 57,
      "at": "2018-05-04T09:09:05",
      "cost": 5.700,
      "fee": "TELEPHONY_VOICE_IRIDIUM_TO_PSTN",
      "contract": "wbpYqLdxyzVrAEYRjDBQmgRMjGOvoeZk"
    }
  ]
}
{
  "at": 1525425009448,
  "error": "DispatcherInputException"
}
{
  "at": 1527861082868,
  "error": "DispatcherUnavailableException"
}

Query Params

subscriber
string

CloudLoop Subscriber Id

year
int32
month
int32

1-12

 
Suggest Edits

Get Usage Summary

Retrieve summary of pool usage for given subscriber in given month

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Telephony/GetUsageSummary
curl --request GET \
  --url 'https://api.cloudloop.com/Telephony/GetUsageSummary?subscriber=subscriber&year=2018'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Telephony/GetUsageSummary',
  qs:
   { subscriber: 'subscriber',
     year: '2018' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Telephony/GetUsageSummary?subscriber=subscriber&year=2018")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Telephony/GetUsageSummary?subscriber=subscriber&year=2018");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Telephony/GetUsageSummary"

querystring = {"subscriber":"subscriber","year":"2018"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "summary": [
    {
      "month": 5,
      "year": 2018,
      "contract": "PONAKwlzdYZQrbELDREjaoLkJqpevRyX",
      "id": "DgXeoxwVPMyrdOBJeEGlqKRJLbajQkzZ",
      "calculatedAt": "2018-05-04T09:16:19",
      "remaining": 1000,
      "utilisation": 0.5,
      "allocated": 2000
    }
  ]
}
{
  "summary": [
    {
      "month": 5,
      "year": 2018,
      "contract": "RoDmGzOePxrJZKWAgyBagyQXlpAkvMwj",
      "id": "xQzagvADYwKoPeBQvnlMrXJpVORdjyZm",
      "calculatedAt": "2018-05-04T09:25:00",
      "remaining": 1000,
      "utilisation": 0.5,
      "allocated": 2000
    },
    {
      "month": 5,
      "year": 2018,
      "contract": "pjvzwyOMVbPZgeBPZOWaYqQDAJGxkKLr",
      "id": "NwbpYqLdxyzVrAEYZBQmgRMjGOvoeZkK",
      "calculatedAt": "2018-05-04T09:24:59",
      "remaining": 1000,
      "utilisation": 1.0,
      "allocated": 1000
    }
  ]
}
{
  "at": 1525425988297,
  "error": "DispatcherInputException"
}
{
  "at": 1527861082868,
  "error": "DispatcherUnavailableException"
}

Query Params

subscriber
string
required

Cloudloop Subscriber Id

year
int32
required
month
int32

1-12

 

Multiple Records

If a contract has changed during the specified period (e.g. suspended/resumed) there will be multiple records returned.

Suggest Edits

Get Pool Summary

Retrieve summary of poolable plan usage for given month

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Telephony/GetPoolSummary
curl --request GET \
  --url 'https://api.cloudloop.com/Telephony/GetPoolSummary?year=2018&month=month'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Telephony/GetPoolSummary',
  qs:
   { year: '2018',
     month: 'month' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Telephony/GetPoolSummary?year=2018&month=month")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Telephony/GetPoolSummary?year=2018&month=month");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Telephony/GetPoolSummary"

querystring = {"year":"2018","month":"month"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "summary": [
    {
      "month": 5,
      "year": 2018,
      "id": "aJYXyvGekqxMKAWvqAnzbRDgVQZOwmdp",
      "plan": "RoDmGzOePxrJZKWAvEagyQXlpAkvMwjY",
      "calculatedAt": "2018-05-04T09:53:44",
      "remaining": 10,
      "utilisation": 0.9,
      "allocated": 100
    },
    {
      "month": 5,
      "year": 2018,
      "id": "LpwjgJyDQqreRkExmYBAGYmVlazNdOMX",
      "plan": "DgXeoxwVPMyrdOBJeEGlqKRJLbajQkzZ",
      "calculatedAt": "2018-05-04T09:53:44",
      "remaining": 0,
      "utilisation": 1.0,
      "allocated": 100
    }
  ]
}
{
  "at": 1525427764526,
  "error": "DispatcherInputException"
}
{
  "at": 1527861082868,
  "error": "DispatcherUnavailableException"
}

Query Params

year
int32
required
month
int32
required
 
Suggest Edits

Get Plans

Retrieve available plans

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Telephony/GetPlans
curl --request GET \
  --url https://api.cloudloop.com/Telephony/GetPlans
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Telephony/GetPlans' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Telephony/GetPlans")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Telephony/GetPlans");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Telephony/GetPlans"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "plans": [
    {
      "inclusive": 0,
      "pooled": false,
      "suspendible": false,
      "name": "TEST PLAN 2",
      "description": "This is an example plan",
      "increment": 0,
      "commitment": 0,
      "id": "OJvLGDrkRelwaXBDojEKgAoZPMQmdzbY",
      "minimum": 0
    },
    {
      "inclusive": 0,
      "pooled": false,
      "suspendible": false,
      "name": "TEST PLAN 1",
      "description": "This is an example plan",
      "increment": 0,
      "commitment": 0,
      "id": "grOvMZelJoLYNkBMrAnPRKbywQXjxGzV",
      "minimum": 0
    }
  ]
}
 
Suggest Edits

Get Contracts

Retrieve all contracts for given Subscriber

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Telephony/GetContracts
curl --request GET \
  --url 'https://api.cloudloop.com/Telephony/GetContracts?subscriber=subscriber'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Telephony/GetContracts',
  qs: { subscriber: 'subscriber' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Telephony/GetContracts?subscriber=subscriber")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Telephony/GetContracts?subscriber=subscriber");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Telephony/GetContracts"

querystring = {"subscriber":"subscriber"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "contracts": [
    {
      "subscriber": "GjlwJvdrxpDoOWepXjnKbPLkQXeVAZgz",
      "networkStatus": "ACTIVATING",
      "from": "2018-06-28T08:14:57",
      "id": "wbpYqLdxyzVrAEYRjDBQmgRMjGOvoeZk",
      "state": "NEW",
      "to": null,
      "committedTo": null,
      "imsi": null,
      "msisdn": null,
      "localNumberAccess": false,
    	"localNumber": null, 
      "plan": {
        "feeMonthly": 13.990,
        "inclusive": 123,
        "pooled": false,
        "suspendible": false,
        "name": "PLAN B",
        "description": "This is an example plan",
        "increment": 0,
        "commitment": 0,
        "id": "AagLlVGjyNzQbnObaNBoRXPekmOvrxJY",
        "minimum": 0
      },
      "hardware": "rOvMZelJoLYNkBMADjBPRKbywQXjxGzV"
    },
    {
      "subscriber": "GjlwJvdrxpDoOWepXjnKbPLkQXeVAZgz",
      "networkStatus": "DEACTIVATED",
      "from": "2018-06-28T08:14:56",
      "id": "JaKzYmyeDdjGPWagxPBLrlVqgZxNXApv",
      "state": "NEW",
      "to": "2018-06-28T08:14:56",
      "committedTo": "2018-06-28T08:14:56",
      "imsi": "901234123412341",
      "msisdn": "881612341234",
      "localNumberAccess": false,
    	"localNumber": null,
      "plan": {
        "feeMonthly": 13.990,
        "inclusive": 123,
        "pooled": false,
        "suspendible": false,
        "name": "PLAN A",
        "description": "This is an example plan",
        "increment": 0,
        "commitment": 0,
        "id": "MPAjovqQGZaLRENvpeElKkpxwgdzDYXb",
        "minimum": 0
      },
      "hardware": "rOvMZelJoLYNkBMADjBPRKbywQXjxGzV"
    }
  ]
}
{
  "at": 1525428629338,
  "error": "DispatcherInputException"
}

Query Params

subscriber
string
required

CloudLoop Subscriber Id

 

Multiple Records

If a Contract has changed (e.g. suspended/resumed) there will be multiple records returned.

Suggest Edits

Activate Subscriber

Activate Subscriber with a new plan

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Telephony/DoActivateSubscriber
curl --request GET \
  --url 'https://api.cloudloop.com/Telephony/DoActivateSubscriber?subscriber=subscriber&hardware=hardware&plan=plan'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Telephony/DoActivateSubscriber',
  qs:
   { subscriber: 'subscriber',
     hardware: 'hardware',
     plan: 'plan' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Telephony/DoActivateSubscriber?subscriber=subscriber&hardware=hardware&plan=plan")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Telephony/DoActivateSubscriber?subscriber=subscriber&hardware=hardware&plan=plan");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Telephony/DoActivateSubscriber"

querystring = {"subscriber":"subscriber","hardware":"hardware","plan":"plan"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "contract": {
    "subscriber": "vobXGALqOdlzpanrrZnNkwRPZgJjmyre",
    "networkStatus": "ACTIVATING",
    "from": "2018-05-04T10:11:26.642",
    "id": "yPQkYomwxvAZaJWqNkEDbdOXgezVKjGM",
    "state": "NEW",
    "to": null,
    "localNumberAccess": false,
    "localNumber": null,  
    "plan": {
      "inclusive": 0,
      "pooled": false,
      "suspendible": false,
      "name": "CLOUDLOOP_PLAN_TEST",
      "description": "This is an example plan",
      "increment": 0,
      "commitment": 0,
      "id": "zolNGxekOvAKmanjLbERdpyLgXjMbVPZ",
      "minimum": 0
    },
    "hardware": "OVdRorbmlwqkNBpayznJYPZvxaXpzjLg"
  }
}
{
  "at": 1525428860259,
  "error": "DispatcherOperationException"
}
{
  "at": 1525428973526,
  "error": "DispatcherInputException"
}

Query Params

subscriber
string
required

CloudLoop Subscriber Id

hardware
string
required

CloudLoop Hardware Id

plan
string
required

CloudLoop Plan NAME

localNumberAccess
boolean

If Local Number Access should be enabled

 

A Contract object represents your binding agreement with cloudloop.

All contracts will report a network status parameter.

Network Status

ACTIVATING - Contract is in the process of being activated
ACTIVATED - Contract is active
DEACTIVATING - Contract is in the process of being deactivated
DEACTIVATED - Contract is deactivated
SUSPENDING - Contract is in the process of being suspended
SUSPENDED - Contract is suspended
RESUMING - Contract is in the process of being resumed

Suggest Edits

Deactivate Subscriber

Deactivate specified Subscriber

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Telephony/DoDeactivateSubscriber
curl --request GET \
  --url 'https://api.cloudloop.com/Telephony/DoDeactivateSubscriber?subscriber=subscriber'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Telephony/DoDeactivateSubscriber',
  qs: { subscriber: 'subscriber' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Telephony/DoDeactivateSubscriber?subscriber=subscriber")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Telephony/DoDeactivateSubscriber?subscriber=subscriber");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Telephony/DoDeactivateSubscriber"

querystring = {"subscriber":"subscriber"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "contract": {
    "subscriber": "AQKgLZjVmdexJrnZbmnMlyRpaNOkDoXb",
    "networkStatus": "DEACTIVATING",
    "from": "2018-05-04T10:20:02",
    "id": "PONAKwlzdYZQrbnLXRnjaoLkJqpevRyX",
    "state": "NEW",
    "to": "2018-05-04T10:20:02.078",
    "plan": {
      "inclusive": 0,
      "pooled": false,
      "suspendible": false,
      "name": "CLOUDLOOP_PLAN_TEST",
      "description": "This is an example plan",
      "increment": 0,
      "commitment": 0,
      "id": "xQzagvADYwKoPeBQPlElMrXJpVORdjyZ",
      "minimum": 0
    },
    "hardware": "labgrGXzpmLqPnykwgEOyoKJdkeVNvwQ"
  }
}
{
  "at": 1525429301202,
  "error": "DispatcherOperationException"
}
{
  "at": 1525429406397,
  "error": "DispatcherInputException"
}

Query Params

subscriber
string
required

CloudLoop Subscriber Id

 
Suggest Edits

Resume Subscriber

Resume previously suspended Subscriber

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Telephony/DoResumeSubscriber
curl --request GET \
  --url 'https://api.cloudloop.com/Telephony/DoResumeSubscriber?subscriber=subscriber'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Telephony/DoResumeSubscriber',
  qs: { subscriber: 'subscriber' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Telephony/DoResumeSubscriber?subscriber=subscriber")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Telephony/DoResumeSubscriber?subscriber=subscriber");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Telephony/DoResumeSubscriber"

querystring = {"subscriber":"subscriber"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "contract": {
    "subscriber": "eorLzVjdQqPgkaElLqEpRyKbJZONAGYD",
    "networkStatus": "RESUMING",
    "from": "2018-05-04T11:47:55.748",
    "id": "eorLzVjdQqPgkanlxmnpRyKbJZONAGYD",
    "state": "RESUMED",
    "to": null,
    "plan": {
      "inclusive": 0,
      "pooled": false,
      "suspendible": true,
      "name": "CLOUDLOOP_PLAN_TEST",
      "description": "This is an example plan",
      "increment": 0,
      "commitment": 0,
      "id": "aLyjrgkpAemZqGBRLwWRvNVKxQPXdYoO",
      "minimum": 0
    },
    "hardware": "wbpYqLdxyzVrAnYyGenQmgRMjGOvoeZk"
  }
}
{
  "at": 1525439618009,
  "error": "DispatcherOperationException"
}
{
  "at": 1525439588516,
  "error": "DispatcherInputException"
}

Query Params

subscriber
string
required

CloudLoop Subscriber Id

 
Suggest Edits

Suspend Subscriber

Suspend current Contract associated to Subscriber

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Telephony/DoSuspendSubscriber
curl --request GET \
  --url 'https://api.cloudloop.com/Telephony/DoSuspendSubscriber?subscriber=subscriber'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Telephony/DoSuspendSubscriber',
  qs: { subscriber: 'subscriber' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Telephony/DoSuspendSubscriber?subscriber=subscriber")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Telephony/DoSuspendSubscriber?subscriber=subscriber");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Telephony/DoSuspendSubscriber"

querystring = {"subscriber":"subscriber"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "contract": {
    "subscriber": "zolNGxekOvAKmanjddERdpyLgXjMbVPZ",
    "networkStatus": "SUSPENDING",
    "from": "2018-05-04T13:17:42",
    "id": "aYAlRXzwrdjymbEKYZnKLNxvPkMeqgGJ",
    "state": "NEW",
    "to": "2018-05-04T13:17:42.396",
    "plan": {
      "inclusive": 0,
      "pooled": false,
      "suspendible": true,
      "name": "CLOUDLOOP_PLAN_TEST",
      "description": "This is an example plan",
      "increment": 0,
      "commitment": 0,
      "id": "QKgLZjVmdexJrnZRjrnMlyRpaNOkDoXb",
      "minimum": 0
    },
    "hardware": "OVdRorbmlwqkNBpajonJYPZvxaXpzjLg"
  }
}
{
  "at": 1525439893302,
  "error": "DispatcherOperationException"
}
{
  "at": 1525439964869,
  "error": "DispatcherInputException"
}

Query Params

subscriber
string
required

CloudLoop Subscriber Id

 

Suspension Fee

Plans may incur additional fees whilst suspended; please refer to pricing matrix.

Suspended Contracts

When a Subscriber is Suspended; we create a new contract to reflect the suspended period.

Suggest Edits

Change Subscriber

Change an already active contract

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Telephony/DoChangeSubscriber
curl --request GET \
  --url 'https://api.cloudloop.com/Telephony/DoChangeSubscriber?subscriber=subscriber&plan=plan'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Telephony/DoChangeSubscriber',
  qs:
   { subscriber: 'subscriber',
     plan: 'plan' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Telephony/DoChangeSubscriber?subscriber=subscriber&plan=plan")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Telephony/DoChangeSubscriber?subscriber=subscriber&plan=plan");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Telephony/DoChangeSubscriber"

querystring = {"subscriber":"subscriber","plan":"plan"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "contract": {
    "subscriber": "rXgwyNPpDmebJLWXKZnoARqxMdZOVGva",
    "networkStatus": "CHANGING",
    "from": "2018-05-04T13:25:29.056",
    "id": "DgXeoxwVPMyrdOWJamnGlqKRJLbajQkz",
    "state": "CHANGED",
    "to": null,
    "plan": {
      "inclusive": 0,
      "pooled": false,
      "suspendible": false,
      "name": "Another Plan",
      "description": "This is an example plan",
      "increment": 0,
      "commitment": 0,
      "id": "OVdRorbmlwqkNBpaqLnJYPZvxaXpzjLg",
      "minimum": 0
    },
    "hardware": "pwjgJyDQqreRkExwxYWAGYmVlazNdOMX"
  }
}
{
  "at": 1525440391664,
  "error": "DispatcherOperationException"
}
{
  "at": 1525440391664,
  "error": "DispatcherOperationException"
}
{
  "at": 1525440513029,
  "error": "DispatcherInputException"
}

Query Params

subscriber
string
required

CloudLoop Subscriber Id

plan
string
required

CloudLoop Plan NAME

 
Suggest Edits

Reassociate Subscriber

Change Hardware/Sim associated to Subscriber

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Telephony/DoReassociateSubscriber
curl --request GET \
  --url 'https://api.cloudloop.com/Telephony/DoReassociateSubscriber?subscriber=subscriber&sim=sim&hardware=hardware'
var request = require("request");

var options = { method: 'GET',
  url:
   'https://api.cloudloop.com/Telephony/DoReassociateSubscriber',
  qs:
   { subscriber: 'subscriber',
     sim: 'sim',
     hardware: 'hardware' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Telephony/DoReassociateSubscriber?subscriber=subscriber&sim=sim&hardware=hardware")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Telephony/DoReassociateSubscriber?subscriber=subscriber&sim=sim&hardware=hardware");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Telephony/DoReassociateSubscriber"

querystring = {"subscriber":"subscriber","sim":"sim","hardware":"hardware"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "subscriber": {
    "createdAt": "2018-05-15T11:00:24",
    "sim": {
      "iccid": "1234567812345678123",
      "id": "joGRxQrXpzkPJEgKkGEydwYZbqmDagNA"
    },
    "contract": null,
    "name": "Test Subscriber",
    "id": "XgwyNPpDmebJLWXzqdBoARqxMdZOVGva",
    "account": "oDmGzOePxrJZKWADgbnagyQXlpAkvMwj",
    "hardware": null
  }
}

Query Params

subscriber
string
required

CloudLoop subscriber id

sim
string
required

CloudLoop sim id

hardware
string
required

CloudLoop hardware id

 

This action can be used to change the SIM / Hardware associated to a Subscriber.

It's only possible to reassociate a subscriber if its networkState is INVALID

Suggest Edits

Create Subscriber

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Sbd/CreateSubscriber
curl --request GET \
  --url 'https://api.cloudloop.com/Sbd/CreateSubscriber?hardware=hardware'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Sbd/CreateSubscriber',
  qs: { hardware: 'hardware' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Sbd/CreateSubscriber?hardware=hardware")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Sbd/CreateSubscriber?hardware=hardware");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Sbd/CreateSubscriber"

querystring = {"hardware":"hardware"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "subscriber": {
    "createdAt": "2018-05-04T13:45:15.48",
    "contract": null,
    "name": "Dan test",
    "id": "aLyjrgkpAemZqGWRQqnRvNVKxQPXdYoO",
    "account": "labgrGXzpmLqPEypgMWOyoKJdkeVNvwQ",
    "hardware": "meJwgzdpXVxNRnoOMmnMDlQGLPvAbkyr"
  }
}
{
  "at": 1525423899542,
  "error": "DispatcherInputException"
}
{
  "at": 1525441790044,
  "error": "DispatcherValidationException",
  "exceptions": [
    {
      "name": "Hardware already used",
      "id": 2004
    }
  ]
}

Query Params

hardware
string
required

cloudloop hardware id

name
string

optional reference

 
Suggest Edits

Get Subscriber

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Sbd/GetSubscriber
curl --request GET \
  --url https://api.cloudloop.com/Sbd/GetSubscriber
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Sbd/GetSubscriber' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Sbd/GetSubscriber")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Sbd/GetSubscriber");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Sbd/GetSubscriber"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "subscriber": {
    "createdAt": "2018-05-15T11:06:07",
    "contract": null,
    "destinations": [],
    "name": "Test Subscriber",
    "id": "JYXyvGekqxMKAWvqNlnzbRDgVQZOwmdp",
    "account": "LyjrgkpAemZqGBRNZwBRvNVKxQPXdYoO",
    "hardware": {
      "imei": "123456789012345",
      "id": "pwjgJyDQqreRknxoOyBAGYmVlazNdOMX",
      "type": "IRIDIUM_SBD"
    }
  }
}
{
  "subscriber": {
    "createdAt": "2018-05-15T11:06:07",
    "contract": {
      "subscriber": "meJwgzdpXVxNRnoXNzWMDlQGLPvAbkyr",
      "networkStatus": "ACTIVATING",
      "from": "2018-05-15T11:06:07",
      "id": "wbpYqLdxyzVrAEYyKZEQmgRMjGOvoeZk",
      "state": "NEW",
      "to": null
    },
    "destinations": [],
    "name": "Test Subscriber",
    "id": "meJwgzdpXVxNRnoXNzWMDlQGLPvAbkyr",
    "account": "OVdRorbmlwqkNBpNymWJYPZvxaXpzjLg",
    "hardware": {
      "imei": "123456789012345",
      "id": "orLzVjdQqPgkaElpmbEpRyKbJZONAGYD",
      "type": "IRIDIUM_SBD"
    }
  }
}

Query Params

subscriber
string

cloudloop subscriber id

imei
string

IMEI of Subscriber

 

This endpoint will return the Subscriber identified by the supplied id; or alternatively the subscriber associated to the supplied imei.

Suggest Edits

Search Subscribers

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Sbd/GetSubscribers
curl --request GET \
  --url https://api.cloudloop.com/Sbd/GetSubscribers
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Sbd/GetSubscribers' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Sbd/GetSubscribers")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Sbd/GetSubscribers");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Sbd/GetSubscribers"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "subscribers": [
    {
      "createdAt": "2018-05-04T13:54:38",
      "contract": "yJGjpPobLlmOdaEVAKWAKYzNMgwVZkrR",
      "name": "Test Subscriber 1",
      "id": "eorLzVjdQqPgkaEljrnpRyKbJZONAGYD",
      "account": "GjlwJvdrxpDoOWeYegWKbPLkQXeVAZgz",
      "hardware": "rOvMZelJoLYNkWMNYVEPRKbywQXjxGzV"
    },
    {
      "createdAt": "2018-05-04T13:54:38",
      "contract": null,
      "name": "Test Subscriber 2",
      "id": "aJYXyvGekqxMKABvllWzbRDgVQZOwmdp",
      "account": "GjlwJvdrxpDoOWeYegWKbPLkQXeVAZgz",
      "hardware": "KXeNzdgDqZwrQWbxLJBxMLlmoGpaOARV"
    }
  ]
}
 
Suggest Edits

Get Usage

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Sbd/GetUsage
curl --request GET \
  --url 'https://api.cloudloop.com/Sbd/GetUsage?subscriber=subscriber&year=2018&month=month'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Sbd/GetUsage',
  qs:
   { subscriber: 'subscriber',
     year: '2018',
     month: 'month' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Sbd/GetUsage?subscriber=subscriber&year=2018&month=month")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Sbd/GetUsage?subscriber=subscriber&year=2018&month=month");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Sbd/GetUsage"

querystring = {"subscriber":"subscriber","year":"2018","month":"month"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "usage": [
    {
      "momsn": 510,
      "at": "2018-05-04T13:58:30",
      "cost": 0.617,
      "size": 290,
      "fee": "SBD_DATA",
      "contract": "wbpYqLdxyzVrAEYRjDBQmgRMjGOvoeZk"
    },
    {
      "momsn": 267,
      "at": "2018-05-04T13:58:30",
      "cost": 0.576,
      "size": 99,
      "fee": "SBD_DATA",
      "contract": "wbpYqLdxyzVrAEYRjDBQmgRMjGOvoeZk"
    },
    {
      "momsn": 235,
      "at": "2018-05-04T13:58:30",
      "cost": 0.103,
      "size": 172,
      "fee": "SBD_DATA",
      "contract": "wbpYqLdxyzVrAEYRjDBQmgRMjGOvoeZk"
    },
    {
      "momsn": 897,
      "at": "2018-05-04T13:58:30",
      "cost": 0.153,
      "size": 253,
      "fee": "SBD_DATA",
      "contract": "wbpYqLdxyzVrAEYRjDBQmgRMjGOvoeZk"
    },
    {
      "momsn": 863,
      "at": "2018-05-04T13:58:30",
      "cost": 0.789,
      "size": 235,
      "fee": "SBD_DATA",
      "contract": "wbpYqLdxyzVrAEYRjDBQmgRMjGOvoeZk"
    },
    {
      "momsn": 204,
      "at": "2018-05-04T13:58:30",
      "cost": 0.619,
      "size": 83,
      "fee": "SBD_DATA",
      "contract": "wbpYqLdxyzVrAEYRjDBQmgRMjGOvoeZk"
    },
    {
      "momsn": 597,
      "at": "2018-05-04T13:58:30",
      "cost": 0.109,
      "size": 211,
      "fee": "SBD_DATA",
      "contract": "wbpYqLdxyzVrAEYRjDBQmgRMjGOvoeZk"
    },
    {
      "momsn": 516,
      "at": "2018-05-04T13:58:30",
      "cost": 0.280,
      "size": 253,
      "fee": "SBD_DATA",
      "contract": "wbpYqLdxyzVrAEYRjDBQmgRMjGOvoeZk"
    },
    {
      "momsn": 376,
      "at": "2018-05-04T13:58:30",
      "cost": 0.654,
      "size": 158,
      "fee": "SBD_DATA",
      "contract": "wbpYqLdxyzVrAEYRjDBQmgRMjGOvoeZk"
    },
    {
      "momsn": 707,
      "at": "2018-05-04T13:58:30",
      "cost": 0.320,
      "size": 33,
      "fee": "SBD_DATA",
      "contract": "wbpYqLdxyzVrAEYRjDBQmgRMjGOvoeZk"
    },
    {
      "momsn": 709,
      "at": "2018-05-04T13:58:30",
      "cost": 0.128,
      "size": 11,
      "fee": "SBD_DATA",
      "contract": "wbpYqLdxyzVrAEYRjDBQmgRMjGOvoeZk"
    }
  ]
}
{
  "at": 1525442344541,
  "error": "DispatcherInputException"
}
{
  "at": 1527861082868,
  "error": "DispatcherUnavailableException"
}

Query Params

subscriber
string
required

cloudloop subscriber id

year
int32
required
month
int32
required

1-12

 
Suggest Edits

Get Usage Summary

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Sbd/GetUsageSummary
curl --request GET \
  --url 'https://api.cloudloop.com/Sbd/GetUsageSummary?subscriber=subscriber&year=2018&month=month'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Sbd/GetUsageSummary',
  qs:
   { subscriber: 'subscriber',
     year: '2018',
     month: 'month' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Sbd/GetUsageSummary?subscriber=subscriber&year=2018&month=month")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Sbd/GetUsageSummary?subscriber=subscriber&year=2018&month=month");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Sbd/GetUsageSummary"

querystring = {"subscriber":"subscriber","year":"2018","month":"month"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "summary": [
    {
      "month": 5,
      "year": 2018,
      "contract": "MAagLlVGjyNzQbEOQDnoRXPekmOvrxJY",
      "id": "grOvMZelJoLYNkWMKBPRKbywQXjxGzVp",
      "calculatedAt": "2018-05-04T13:59:55",
      "remaining": 100,
      "utilisation": 0.5,
      "allocated": 200
    }
  ]
}
{
  "at": 1525442472979,
  "error": "DispatcherInputException"
}
{
  "at": 1527861082868,
  "error": "DispatcherUnavailableException"
}

Query Params

subscriber
string
required

cloudloop subscriber id

year
int32
required
month
int32
required

1-12

 
Suggest Edits

Get Plans

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Sbd/GetPlans
curl --request GET \
  --url https://api.cloudloop.com/Sbd/GetPlans
var request = require("request");

var options = { method: 'GET', url: 'https://api.cloudloop.com/Sbd/GetPlans' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Sbd/GetPlans")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Sbd/GetPlans");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Sbd/GetPlans"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "plans": [
    {
      "inclusive": 0,
      "pooled": false,
      "suspendible": false,
      "name": "Plan B",
      "description": "TEST",
      "increment": 0,
      "commitment": 0,
      "id": "XgwyNPpDmebJLWXzrABoARqxMdZOVGva",
      "minimum": 0
    },
    {
      "inclusive": 0,
      "pooled": false,
      "suspendible": false,
      "name": "Plan A",
      "description": "TEST",
      "increment": 0,
      "commitment": 0,
      "id": "JGjpPobLlmOdaEVkrvBAKYzNMgwVZkrR",
      "minimum": 0
    }
  ]
}
 
Suggest Edits

Get Contracts

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Sbd/GetContracts
curl --request GET \
  --url 'https://api.cloudloop.com/Sbd/GetContracts?subscriber=subscriber'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Sbd/GetContracts',
  qs: { subscriber: 'subscriber' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Sbd/GetContracts?subscriber=subscriber")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Sbd/GetContracts?subscriber=subscriber");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Sbd/GetContracts"

querystring = {"subscriber":"subscriber"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "contracts": [
    {
      "subscriber": "VkqZoXzLRdyeJGEwGLEYwbQalDrPxMAj",
      "networkStatus": "ACTIVATING",
      "from": "2018-05-04T14:03:34",
      "id": "AQzoKyLgvpDZOYBzkznGrxVMjqdlakeX",
      "state": "NEW",
      "to": null,
      "committedTo": null,
      "plan": {
        "inclusive": 0,
        "pooled": false,
        "suspendible": false,
        "name": "CLOUDLOOP_SBD_PLAN_TEST",
        "description": "TEST",
        "increment": 0,
        "commitment": 0,
        "id": "pwjgJyDQqreRkExwvrWAGYmVlazNdOMX",
        "minimum": 0
      }
    }
  ]
}
{
  "contracts": [
    {
      "subscriber": "PKXeNzdgDqZwrQBblDWxMLlmoGpaOARV",
      "networkStatus": "ACTIVATING",
      "from": "2018-05-04T14:05:35",
      "id": "PONAKwlzdYZQrbnLpQnjaoLkJqpevRyX",
      "state": "NEW",
      "to": null,
      "plan": {
        "inclusive": 0,
        "pooled": false,
        "suspendible": false,
        "name": "CLOUDLOOP_SBD_PLAN_TEST",
        "description": "TEST",
        "increment": 0,
        "commitment": 0,
        "id": "MPAjovqQGZaLRnNGOXWlKkpxwgdzDYXb",
        "minimum": 0
      }
    },
    {
      "subscriber": "PKXeNzdgDqZwrQBblDWxMLlmoGpaOARV",
      "networkStatus": "DEACTIVATED",
      "from": "2018-05-04T14:05:33",
      "id": "aYAlRXzwrdjymbEKjZWKLNxvPkMeqgGJ",
      "state": "NEW",
      "to": "2018-05-04T14:05:33"
    }
  ]
}
{
  "at": 1525442843521,
  "error": "DispatcherInputException"
}

Query Params

subscriber
string
required

cloudloop subscriber id

 
Suggest Edits

Activate Subscriber

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Sbd/DoActivateSubscriber
curl --request GET \
  --url 'https://api.cloudloop.com/Sbd/DoActivateSubscriber?subscriber=subscriber&plan=plan'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Sbd/DoActivateSubscriber',
  qs:
   { subscriber: 'subscriber',
     plan: 'plan' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Sbd/DoActivateSubscriber?subscriber=subscriber&plan=plan")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Sbd/DoActivateSubscriber?subscriber=subscriber&plan=plan");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Sbd/DoActivateSubscriber"

querystring = {"subscriber":"subscriber","plan":"plan"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "contract": {
    "subscriber": "AQKgLZjVmdexJrEZaVWMlyRpaNOkDoXb",
    "networkStatus": "ACTIVATING",
    "from": "2018-05-04T14:07:48.566",
    "id": "grOvMZelJoLYNkWMajWPRKbywQXjxGzV",
    "state": "NEW",
    "to": null,
    "plan": {
      "inclusive": 0,
      "pooled": false,
      "suspendible": false,
      "name": "CLOUDLOOP_SBD_PLAN_TEST",
      "description": "TEST",
      "increment": 0,
      "commitment": 0,
      "id": "GjlwJvdrxpDoOBerKNnKbPLkQXeVAZgz",
      "minimum": 0
    }
  }
}
{
  "at": 1525442999261,
  "error": "DispatcherOperationException"
}
{
  "at": 1525443344564,
  "error": "DispatcherInputException"
}

Query Params

subscriber
string
required

cloudloop subscriber id

plan
string
required

cloudloop plan NAME

 
Suggest Edits

Deactivate Subscriber

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Sbd/DoDeactivateSubscriber
curl --request GET \
  --url 'https://api.cloudloop.com/Sbd/DoDeactivateSubscriber?subscriber=subscriber'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Sbd/DoDeactivateSubscriber',
  qs: { subscriber: 'subscriber' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Sbd/DoDeactivateSubscriber?subscriber=subscriber")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Sbd/DoDeactivateSubscriber?subscriber=subscriber");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Sbd/DoDeactivateSubscriber"

querystring = {"subscriber":"subscriber"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "contract": {
    "subscriber": "RoDmGzOePxrJZKWAxPnagyQXlpAkvMwj",
    "networkStatus": "DEACTIVATING",
    "from": "2018-05-04T14:17:38",
    "id": "RoDmGzOePxrJZKWAwrBagyQXlpAkvMwj",
    "state": "NEW",
    "to": "2018-05-04T14:17:39.573",
    "plan": {
      "inclusive": 0,
      "pooled": false,
      "suspendible": false,
      "name": "CLOUDLOOP_SBD_PLAN_TEST",
      "description": "TEST",
      "increment": 0,
      "commitment": 0,
      "id": "obXGALqOdlzpanrQxDBNkwRPZgJjmyre",
      "minimum": 0
    }
  }
}
{
  "at": 1525443535863,
  "error": "DispatcherOperationException"
}
{
  "at": 1525443581528,
  "error": "DispatcherInputException"
}

Query Params

subscriber
string
required

cloudloop subscriber id

 
Suggest Edits

Resume Subscriber

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Sbd/DoResumeSubscriber
curl --request GET \
  --url 'https://api.cloudloop.com/Sbd/DoResumeSubscriber?subscriber=subscriber'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Sbd/DoResumeSubscriber',
  qs: { subscriber: 'subscriber' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Sbd/DoResumeSubscriber?subscriber=subscriber")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Sbd/DoResumeSubscriber?subscriber=subscriber");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Sbd/DoResumeSubscriber"

querystring = {"subscriber":"subscriber"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "contract": {
    "subscriber": "dYrLZzemNQwPagWmbAEyOqXbvMVjAoDG",
    "networkStatus": "RESUMING",
    "from": "2018-05-04T14:22:51.128",
    "id": "zolNGxekOvAKmanjgKWRdpyLgXjMbVPZ",
    "state": "RESUMED",
    "to": null,
    "plan": {
      "inclusive": 0,
      "pooled": false,
      "suspendible": true,
      "name": "CLOUDLOOP_SBD_PLAN_TEST",
      "description": "TEST",
      "increment": 0,
      "commitment": 0,
      "id": "QKgLZjVmdexJrnZRDGnMlyRpaNOkDoXb",
      "minimum": 0
    }
  }
}
{
  "at": 1525443837436,
  "error": "DispatcherOperationException"
}
{
  "at": 1525443882403,
  "error": "DispatcherInputException"
}

Query Params

subscriber
string
required

cloudloop subscriber id

 
Suggest Edits

Suspend Subscriber

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Sbd/DoSuspendSubscriber
curl --request GET \
  --url 'https://api.cloudloop.com/Sbd/DoSuspendSubscriber?subscriber=subscriber'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Sbd/DoSuspendSubscriber',
  qs: { subscriber: 'subscriber' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Sbd/DoSuspendSubscriber?subscriber=subscriber")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Sbd/DoSuspendSubscriber?subscriber=subscriber");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Sbd/DoSuspendSubscriber"

querystring = {"subscriber":"subscriber"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "contract": {
    "subscriber": "zolNGxekOvAKmanjLbERdpyLgXjMbVPZ",
    "networkStatus": "SUSPENDING",
    "from": "2018-05-04T14:26:48",
    "id": "MJaKzYmyeDdjGPWayvWLrlVqgZxNXApv",
    "state": "NEW",
    "to": "2018-05-04T14:26:49.138",
    "plan": {
      "inclusive": 0,
      "pooled": false,
      "suspendible": true,
      "name": "CLOUDLOOP_SBD_PLAN_TEST",
      "description": "TEST",
      "increment": 0,
      "commitment": 0,
      "id": "KbONwVrMLJxkeBGaxGWPDyqjAvGQXzoZ",
      "minimum": 0
    }
  }
}
{
  "at": 1525444081634,
  "error": "DispatcherOperationException"
}
{
  "at": 1525444124706,
  "error": "DispatcherInputException"
}

Query Params

subscriber
string
required

cloudloop subscriber id

 
Suggest Edits

Change Subscriber

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Sbd/DoChangeSubscriber
curl --request GET \
  --url 'https://api.cloudloop.com/Sbd/DoChangeSubscriber?subscriber=subscriber&plan=plan'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Sbd/DoChangeSubscriber',
  qs:
   { subscriber: 'subscriber',
     plan: 'plan' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Sbd/DoChangeSubscriber?subscriber=subscriber&plan=plan")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Sbd/DoChangeSubscriber?subscriber=subscriber&plan=plan");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Sbd/DoChangeSubscriber"

querystring = {"subscriber":"subscriber","plan":"plan"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "contract": {
    "subscriber": "MJaKzYmyeDdjGPWavNELrlVqgZxNXApv",
    "networkStatus": "CHANGING",
    "from": "2018-05-04T14:30:40.001",
    "id": "RlabgrGXzpmLqPnyvRWOyoKJdkeVNvwQ",
    "state": "CHANGED",
    "to": null,
    "plan": {
      "inclusive": 0,
      "pooled": false,
      "suspendible": false,
      "name": "PLAN B",
      "description": "TEST",
      "increment": 0,
      "commitment": 0,
      "id": "gXeoxwVPMyrdOWJGVVEGlqKRJLbajQkz",
      "minimum": 0
    }
  }
}
{
  "at": 1525444326813,
  "error": "DispatcherOperationException"
}
{
  "at": 1525444388712,
  "error": "DispatcherInputException"
}

Query Params

subscriber
string
required

cloudloop subscriber id

plan
string
required

cloudloop sbd plan NAME

 
Suggest Edits

Create Destination

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/sbd/CreateDestination
curl --request GET \
  --url 'https://api.cloudloop.com/sbd/CreateDestination?subscriber=subscriber&destination=destination&type=type&moack=moack&geodata=geodata'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/sbd/CreateDestination',
  qs:
   { subscriber: 'subscriber',
     destination: 'destination',
     type: 'type',
     moack: 'moack',
     geodata: 'geodata' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/sbd/CreateDestination?subscriber=subscriber&destination=destination&type=type&moack=moack&geodata=geodata")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/sbd/CreateDestination?subscriber=subscriber&destination=destination&type=type&moack=moack&geodata=geodata");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/sbd/CreateDestination"

querystring = {"subscriber":"subscriber","destination":"destination","type":"type","moack":"moack","geodata":"geodata"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "destination": {
    "moack": true,
    "destination": "rock7.com:9999",
    "id": "xQzagvADYwKoPeBQGNWlMrXJpVORdjyZ",
    "type": "DIRECT_IP",
    "geodata": true
  }
}

Query Params

subscriber
string
required

cloudloop subscriber id

destination
string
required
type
string
required

DIRECT_IP, EMAIL, IMEI

moack
boolean
required
geodata
boolean
required
 
Suggest Edits

Delete Destination

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Sbd/DeleteDestination
curl --request GET \
  --url 'https://api.cloudloop.com/Sbd/DeleteDestination?destination=destination'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Sbd/DeleteDestination',
  qs: { destination: 'destination' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Sbd/DeleteDestination?destination=destination")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Sbd/DeleteDestination?destination=destination");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Sbd/DeleteDestination"

querystring = {"destination":"destination"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "result": true
}

Query Params

destination
string
required
 
Suggest Edits

Reassociate Subscriber

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Sbd/DoReassociateSubscriber
curl --request GET \
  --url 'https://api.cloudloop.com/Sbd/DoReassociateSubscriber?subscriber=subscriber&hardware=hardware'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Sbd/DoReassociateSubscriber',
  qs:
   { subscriber: 'subscriber',
     hardware: 'hardware' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Sbd/DoReassociateSubscriber?subscriber=subscriber&hardware=hardware")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Sbd/DoReassociateSubscriber?subscriber=subscriber&hardware=hardware");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Sbd/DoReassociateSubscriber"

querystring = {"subscriber":"subscriber","hardware":"hardware"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "contract": {
    "subscriber": "MJaKzYmyeDdjGPWavNELrlVqgZxNXApv",
    "networkStatus": "CHANGING",
    "from": "2018-05-04T14:30:40.001",
    "id": "RlabgrGXzpmLqPnyvRWOyoKJdkeVNvwQ",
    "state": "CHANGED",
    "to": null,
    "plan": {
      "inclusive": 0,
      "pooled": false,
      "suspendible": false,
      "name": "PLAN B",
      "description": "TEST",
      "increment": 0,
      "commitment": 0,
      "id": "gXeoxwVPMyrdOWJGVVEGlqKRJLbajQkz",
      "minimum": 0
    }
  }
}
{
  "at": 1525444326813,
  "error": "DispatcherOperationException"
}
{
  "at": 1525444388712,
  "error": "DispatcherInputException"
}

Query Params

subscriber
string
required

cloudloop subscriber id

hardware
string
required

hardware id

 

This action facilitates replacing the hardware associated with a subscriber. Typically this is used for replacing faulty hardware whilst retaining the same contract.

Suggest Edits

Create Hardware

Create CloudLoop Hardware from IMEI and Type

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Hardware/CreateHardware
curl --request GET \
  --url https://api.cloudloop.com/Hardware/CreateHardware
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Hardware/CreateHardware' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Hardware/CreateHardware")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Hardware/CreateHardware");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Hardware/CreateHardware"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "hardware": {
    "imei": "123456789012345",
    "id": "LyjrgkpAemZqGBRDYvWRvNVKxQPXdYoO",
    "type": "IRIDIUM_SBD"
  }
}
{
  "at": 1525444449633,
  "error": "DispatcherValidationException",
  "exceptions": [
    {
      "name": "Duplicate IMEI",
      "id": 1002
    }
  ]
}
{
  "at": 1525444471066,
  "error": "DispatcherInputException"
}

Query Params

imei
string
type
string

Type (IRIDIUM_SBD, IRIDIUM_TELEPHONY)

 
Suggest Edits

Get Hardware

Retrieve CloudLoop Hardware from CloudLoop Hardware Id or IMEI

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Hardware/GetHardware
curl --request GET \
  --url https://api.cloudloop.com/Hardware/GetHardware
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Hardware/GetHardware' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Hardware/GetHardware")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Hardware/GetHardware");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Hardware/GetHardware"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "hardware": {
    "imei": "123456789012345",
    "id": "NMPAjovqQGZaLRnNpElKkpxwgdzDYXbr",
    "type": "IRIDIUM_SBD"
  }
}
{
  "at": 1525445030774,
  "error": "DispatcherInputException"
}

Query Params

hardware
string

Cloudloop Hardware Id

imei
string
 
Suggest Edits

Search Hardware

Retrieve all hardware

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Sim/GetSims
curl --request GET \
  --url https://api.cloudloop.com/Sim/GetSims
var request = require("request");

var options = { method: 'GET', url: 'https://api.cloudloop.com/Sim/GetSims' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Sim/GetSims")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Sim/GetSims");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Sim/GetSims"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "hardwares": [
    {
      "imei": "123456789012345",
      "id": "KXeNzdgDqZwrQWbpNpBxMLlmoGpaOARV",
      "type": "IRIDIUM_SBD"
    }
  ]
}
 
Suggest Edits

Create Sim

Create CloudLoop Sim from ICCID

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Sim/CreateSim
curl --request GET \
  --url 'https://api.cloudloop.com/Sim/CreateSim?iccid=iccid'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Sim/CreateSim',
  qs: { iccid: 'iccid' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Sim/CreateSim?iccid=iccid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Sim/CreateSim?iccid=iccid");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Sim/CreateSim"

querystring = {"iccid":"iccid"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "sim": {
    "iccid": "1234567812345678123",
    "id": "JYXyvGekqxMKABvPqeWzbRDgVQZOwmdp"
  }
}
{
  "at": 1525445030774,
  "error": "DispatcherInputException"
}

Query Params

iccid
string
required
 
Suggest Edits

Get Sim

Retrieve CloudLoop Sim from Cloud Loop Sim Id or ICCID

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Sim/GetSim
curl --request GET \
  --url 'https://api.cloudloop.com/Sim/GetSim?sim=sim'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Sim/GetSim',
  qs: { sim: 'sim' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Sim/GetSim?sim=sim")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Sim/GetSim?sim=sim");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Sim/GetSim"

querystring = {"sim":"sim"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "sim": {
    "sim": "8988169234002662328",
    "id": "RoDmGzOePxrJZKWAvEagyQXlpAkvMwjY"
  }
}
{
  "at": 1525445124264,
  "error": "DispatcherInputException"
}

Query Params

sim
string
required

CloudLoop Sim Id

 
Suggest Edits

Search Sims

Retrieve all sims

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Sim/GetSims
curl --request GET \
  --url https://api.cloudloop.com/Sim/GetSims
var request = require("request");

var options = { method: 'GET', url: 'https://api.cloudloop.com/Sim/GetSims' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Sim/GetSims")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Sim/GetSims");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Sim/GetSims"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "sims": [
    {
      "iccid": "1234567812345678123",
      "id": "kqZoXzLRdyeJGEwgDJEYwbQalDrPxMAj"
    }
  ]
}
 
Suggest Edits

Generate Token

Generate a new Access Token

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/User/DoGenerateToken
curl --request GET \
  --url https://api.cloudloop.com/User/DoGenerateToken
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/User/DoGenerateToken' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/User/DoGenerateToken")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/User/DoGenerateToken");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/User/DoGenerateToken"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
    "token": "ec650591-422e-40ba-9027-c8b862025c13"
}
 

Existing Access Token

Generating a new Access Token will immediately invalidate your existing token.

Suggest Edits

Ping

Verify access to CloudLoop

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.cloudloop.com/Platform/Ping
curl --request GET \
  --url https://api.cloudloop.com/Platform/Ping
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.cloudloop.com/Platform/Ping' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.cloudloop.com/Platform/Ping")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.cloudloop.com/Platform/Ping");

xhr.send(data);
import requests

url = "https://api.cloudloop.com/Platform/Ping"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "ping": "pong"
}
{
  "at": 1523628422232,
  "error": "DispatcherAuthenticationException"
}