Docs / igloohome / API Reference / Devices

Open in Claude ↗ Open in ChatGPT ↗ llms.txt

Devices API Reference

Enterprise API endpoints for managing devices.

Get Devices

GET /devices

Responses

200 Success

Request Example

curl https://api.igloodeveloper.co/devices \
  -H "Authorization: Bearer $API_KEY"

import { Igloo } from "@igloo/sdk";

const igloo = new Igloo(process.env.IGLOO_API_KEY);
const response = await igloo.devices.getDevices();

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
response = igloo.devices.get_devices()

package main

import (
	"context"
	"os"
	"go.igloohome.co/orion/sdk"
)

func main() {
	client := sdk.NewClient(sdk.ClientOptions{
		APIKey: os.Getenv("IGLOO_API_KEY"),
	})
	err := client.GetDevices(context.Background())
}

<?php

$client = new \Igloo\Client(getenv("IGLOO_API_KEY"));
$response = $client->getDevices();

import co.igloo.sdk.Client

val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val response = client.getDevices()

import Foundation

let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
client.getDevices { result in
    // handle result
}

Get Support Pin Devices

GET /devices/support-pins

Responses

200 Success

Request Example

curl https://api.igloodeveloper.co/devices/support-pins \
  -H "Authorization: Bearer $API_KEY"

import { Igloo } from "@igloo/sdk";

const igloo = new Igloo(process.env.IGLOO_API_KEY);
const response = await igloo.devices.getSupportPinDevices();

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
response = igloo.devices.get_support_pin_devices()

package main

import (
	"context"
	"os"
	"go.igloohome.co/orion/sdk"
)

func main() {
	client := sdk.NewClient(sdk.ClientOptions{
		APIKey: os.Getenv("IGLOO_API_KEY"),
	})
	err := client.GetSupportPinDevices(context.Background())
}

<?php

$client = new \Igloo\Client(getenv("IGLOO_API_KEY"));
$response = $client->getSupportPinDevices();

import co.igloo.sdk.Client

val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val response = client.getSupportPinDevices()

import Foundation

let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
client.getSupportPinDevices { result in
    // handle result
}

Get Device

GET /devices/{id}

Path Parameters

Parameter	Type	Required
id	string	Yes

Responses

200 Success

Request Example

curl https://api.igloodeveloper.co/devices/{id} \
  -H "Authorization: Bearer $API_KEY"

import { Igloo } from "@igloo/sdk";

const igloo = new Igloo(process.env.IGLOO_API_KEY);
const params = {
  id: "value",
};
const response = await igloo.devices.getDevice(params);

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "id": "value",
}
response = igloo.devices.get_device(params)

package main

import (
	"context"
	"os"
	"go.igloohome.co/orion/sdk"
)

func main() {
	client := sdk.NewClient(sdk.ClientOptions{
		APIKey: os.Getenv("IGLOO_API_KEY"),
	})
	params := map[string]interface{}{
		"id": "value",
	}
	err := client.GetDevice(context.Background(), params)
}

<?php

$client = new \Igloo\Client(getenv("IGLOO_API_KEY"));
$params = [
    "id" => "value",
];
$response = $client->getDevice($params);

import co.igloo.sdk.Client

val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
    "id" to "value",
)
val response = client.getDevice(params)

import Foundation

let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
    "id": "value",
]
client.getDevice(params) { result in
    // handle result
}

Update Device

PUT /devices/{id}

Path Parameters

Parameter	Type	Required
id	string	Yes

Body Parameters

Content-Type: application/json

Parameter	Type	Required
schema	string	Optional
name	string	Optional

Responses

200 Success

Request Example

curl -X PUT https://api.igloodeveloper.co/devices/{id} \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "schema": "value",
    "name": "value"
  }'

import { Igloo } from "@igloo/sdk";

const igloo = new Igloo(process.env.IGLOO_API_KEY);
const params = {
  id: "value",
  schema: "value",
  name: "value",
};
const response = await igloo.devices.updateDevice(params);

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "id": "value",
    "schema": "value",
    "name": "value",
}
response = igloo.devices.update_device(params)

package main

import (
	"context"
	"os"
	"go.igloohome.co/orion/sdk"
)

func main() {
	client := sdk.NewClient(sdk.ClientOptions{
		APIKey: os.Getenv("IGLOO_API_KEY"),
	})
	params := map[string]interface{}{
		"id": "value",
		"schema": "value",
		"name": "value",
	}
	err := client.UpdateDevice(context.Background(), params)
}

<?php

$client = new \Igloo\Client(getenv("IGLOO_API_KEY"));
$params = [
    "id" => "value",
    "schema" => "value",
    "name" => "value",
];
$response = $client->updateDevice($params);

import co.igloo.sdk.Client

val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
    "id" to "value",
    "schema" to "value",
    "name" to "value",
)
val response = client.updateDevice(params)

import Foundation

let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
    "id": "value",
    "schema": "value",
    "name": "value",
]
client.updateDevice(params) { result in
    // handle result
}

Get Master Pin

GET /devices/{id}/masterpin

Path Parameters

Parameter	Type	Required
id	string	Yes

Responses

200 Success

Request Example

curl https://api.igloodeveloper.co/devices/{id}/masterpin \
  -H "Authorization: Bearer $API_KEY"

import { Igloo } from "@igloo/sdk";

const igloo = new Igloo(process.env.IGLOO_API_KEY);
const params = {
  id: "value",
};
const response = await igloo.devices.getMasterPin(params);

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "id": "value",
}
response = igloo.devices.get_master_pin(params)

package main

import (
	"context"
	"os"
	"go.igloohome.co/orion/sdk"
)

func main() {
	client := sdk.NewClient(sdk.ClientOptions{
		APIKey: os.Getenv("IGLOO_API_KEY"),
	})
	params := map[string]interface{}{
		"id": "value",
	}
	err := client.GetMasterPin(context.Background(), params)
}

<?php

$client = new \Igloo\Client(getenv("IGLOO_API_KEY"));
$params = [
    "id" => "value",
];
$response = $client->getMasterPin($params);

import co.igloo.sdk.Client

val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
    "id" to "value",
)
val response = client.getMasterPin(params)

import Foundation

let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
    "id": "value",
]
client.getMasterPin(params) { result in
    // handle result
}

Create Permanent Pin

POST /devices/{id}/algopin/permanent

Path Parameters

Parameter	Type	Required
id	string	Yes

Responses

200 Success

Request Example

curl -X POST https://api.igloodeveloper.co/devices/{id}/algopin/permanent \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"key": "value"}'

import { Igloo } from "@igloo/sdk";

const igloo = new Igloo(process.env.IGLOO_API_KEY);
const params = {
  id: "value",
};
const response = await igloo.devices.createPermanentPin(params);

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "id": "value",
}
response = igloo.devices.create_permanent_pin(params)

package main

import (
	"context"
	"os"
	"go.igloohome.co/orion/sdk"
)

func main() {
	client := sdk.NewClient(sdk.ClientOptions{
		APIKey: os.Getenv("IGLOO_API_KEY"),
	})
	params := map[string]interface{}{
		"id": "value",
	}
	err := client.CreatePermanentPin(context.Background(), params)
}

<?php

$client = new \Igloo\Client(getenv("IGLOO_API_KEY"));
$params = [
    "id" => "value",
];
$response = $client->createPermanentPin($params);

import co.igloo.sdk.Client

val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
    "id" to "value",
)
val response = client.createPermanentPin(params)

import Foundation

let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
    "id": "value",
]
client.createPermanentPin(params) { result in
    // handle result
}

Create OTP Pin

POST /devices/{id}/algopin/onetime

Path Parameters

Parameter	Type	Required
id	string	Yes

Responses

200 Success

Request Example

curl -X POST https://api.igloodeveloper.co/devices/{id}/algopin/onetime \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"key": "value"}'

import { Igloo } from "@igloo/sdk";

const igloo = new Igloo(process.env.IGLOO_API_KEY);
const params = {
  id: "value",
};
const response = await igloo.devices.createOtpPin(params);

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "id": "value",
}
response = igloo.devices.create_otp_pin(params)

package main

import (
	"context"
	"os"
	"go.igloohome.co/orion/sdk"
)

func main() {
	client := sdk.NewClient(sdk.ClientOptions{
		APIKey: os.Getenv("IGLOO_API_KEY"),
	})
	params := map[string]interface{}{
		"id": "value",
	}
	err := client.CreateOtpPin(context.Background(), params)
}

<?php

$client = new \Igloo\Client(getenv("IGLOO_API_KEY"));
$params = [
    "id" => "value",
];
$response = $client->createOtpPin($params);

import co.igloo.sdk.Client

val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
    "id" to "value",
)
val response = client.createOtpPin(params)

import Foundation

let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
    "id": "value",
]
client.createOtpPin(params) { result in
    // handle result
}

Create Hourly Pin

POST /devices/{id}/algopin/hourly

Path Parameters

Parameter	Type	Required
id	string	Yes

Responses

200 Success

Request Example

curl -X POST https://api.igloodeveloper.co/devices/{id}/algopin/hourly \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"key": "value"}'

import { Igloo } from "@igloo/sdk";

const igloo = new Igloo(process.env.IGLOO_API_KEY);
const params = {
  id: "value",
};
const response = await igloo.devices.createHourlyPin(params);

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "id": "value",
}
response = igloo.devices.create_hourly_pin(params)

package main

import (
	"context"
	"os"
	"go.igloohome.co/orion/sdk"
)

func main() {
	client := sdk.NewClient(sdk.ClientOptions{
		APIKey: os.Getenv("IGLOO_API_KEY"),
	})
	params := map[string]interface{}{
		"id": "value",
	}
	err := client.CreateHourlyPin(context.Background(), params)
}

<?php

$client = new \Igloo\Client(getenv("IGLOO_API_KEY"));
$params = [
    "id" => "value",
];
$response = $client->createHourlyPin($params);

import co.igloo.sdk.Client

val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
    "id" to "value",
)
val response = client.createHourlyPin(params)

import Foundation

let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
    "id": "value",
]
client.createHourlyPin(params) { result in
    // handle result
}

Create Daily Pin

POST /devices/{id}/algopin/daily

Path Parameters

Parameter	Type	Required
id	string	Yes

Responses

200 Success

Request Example

curl -X POST https://api.igloodeveloper.co/devices/{id}/algopin/daily \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"key": "value"}'

import { Igloo } from "@igloo/sdk";

const igloo = new Igloo(process.env.IGLOO_API_KEY);
const params = {
  id: "value",
};
const response = await igloo.devices.createDailyPin(params);

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "id": "value",
}
response = igloo.devices.create_daily_pin(params)

package main

import (
	"context"
	"os"
	"go.igloohome.co/orion/sdk"
)

func main() {
	client := sdk.NewClient(sdk.ClientOptions{
		APIKey: os.Getenv("IGLOO_API_KEY"),
	})
	params := map[string]interface{}{
		"id": "value",
	}
	err := client.CreateDailyPin(context.Background(), params)
}

<?php

$client = new \Igloo\Client(getenv("IGLOO_API_KEY"));
$params = [
    "id" => "value",
];
$response = $client->createDailyPin($params);

import co.igloo.sdk.Client

val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
    "id" to "value",
)
val response = client.createDailyPin(params)

import Foundation

let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
    "id": "value",
]
client.createDailyPin(params) { result in
    // handle result
}

Create Ekey Access

POST /devices/{id}/ekey

Path Parameters

Parameter	Type	Required
id	string	Yes

Responses

200 Success

Request Example

curl -X POST https://api.igloodeveloper.co/devices/{id}/ekey \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"key": "value"}'

import { Igloo } from "@igloo/sdk";

const igloo = new Igloo(process.env.IGLOO_API_KEY);
const params = {
  id: "value",
};
const response = await igloo.devices.createEkeyAccess(params);

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "id": "value",
}
response = igloo.devices.create_ekey_access(params)

package main

import (
	"context"
	"os"
	"go.igloohome.co/orion/sdk"
)

func main() {
	client := sdk.NewClient(sdk.ClientOptions{
		APIKey: os.Getenv("IGLOO_API_KEY"),
	})
	params := map[string]interface{}{
		"id": "value",
	}
	err := client.CreateEkeyAccess(context.Background(), params)
}

<?php

$client = new \Igloo\Client(getenv("IGLOO_API_KEY"));
$params = [
    "id" => "value",
];
$response = $client->createEkeyAccess($params);

import co.igloo.sdk.Client

val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
    "id" to "value",
)
val response = client.createEkeyAccess(params)

import Foundation

let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
    "id": "value",
]
client.createEkeyAccess(params) { result in
    // handle result
}

Get Device Activity

GET /devices/{id}/activity

Path Parameters

Parameter	Type	Required
id	string	Yes

Responses

200 Success

Request Example

curl https://api.igloodeveloper.co/devices/{id}/activity \
  -H "Authorization: Bearer $API_KEY"

import { Igloo } from "@igloo/sdk";

const igloo = new Igloo(process.env.IGLOO_API_KEY);
const params = {
  id: "value",
};
const response = await igloo.devices.getDeviceActivity(params);

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "id": "value",
}
response = igloo.devices.get_device_activity(params)

package main

import (
	"context"
	"os"
	"go.igloohome.co/orion/sdk"
)

func main() {
	client := sdk.NewClient(sdk.ClientOptions{
		APIKey: os.Getenv("IGLOO_API_KEY"),
	})
	params := map[string]interface{}{
		"id": "value",
	}
	err := client.GetDeviceActivity(context.Background(), params)
}

<?php

$client = new \Igloo\Client(getenv("IGLOO_API_KEY"));
$params = [
    "id" => "value",
];
$response = $client->getDeviceActivity($params);

import co.igloo.sdk.Client

val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
    "id" to "value",
)
val response = client.getDeviceActivity(params)

import Foundation

let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
    "id": "value",
]
client.getDeviceActivity(params) { result in
    // handle result
}

Push Device Activity

POST /devices/{id}/activity

Path Parameters

Parameter	Type	Required
id	string	Yes

Body Parameters

Content-Type: application/json

Parameter	Type	Required
schema	string	Optional
logsPayload	array	Optional

Responses

200 Success

Request Example

curl -X POST https://api.igloodeveloper.co/devices/{id}/activity \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "schema": "value",
    "logsPayload": "value"
  }'

import { Igloo } from "@igloo/sdk";

const igloo = new Igloo(process.env.IGLOO_API_KEY);
const params = {
  id: "value",
  schema: "value",
  logsPayload: "value",
};
const response = await igloo.devices.pushDeviceActivity(params);

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "id": "value",
    "schema": "value",
    "logsPayload": "value",
}
response = igloo.devices.push_device_activity(params)

package main

import (
	"context"
	"os"
	"go.igloohome.co/orion/sdk"
)

func main() {
	client := sdk.NewClient(sdk.ClientOptions{
		APIKey: os.Getenv("IGLOO_API_KEY"),
	})
	params := map[string]interface{}{
		"id": "value",
		"schema": "value",
		"logsPayload": "value",
	}
	err := client.PushDeviceActivity(context.Background(), params)
}

<?php

$client = new \Igloo\Client(getenv("IGLOO_API_KEY"));
$params = [
    "id" => "value",
    "schema" => "value",
    "logsPayload" => "value",
];
$response = $client->pushDeviceActivity($params);

import co.igloo.sdk.Client

val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
    "id" to "value",
    "schema" to "value",
    "logsPayload" to "value",
)
val response = client.pushDeviceActivity(params)

import Foundation

let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
    "id": "value",
    "schema": "value",
    "logsPayload": "value",
]
client.pushDeviceActivity(params) { result in
    // handle result
}

Create Bridge Proxied Job

POST /devices/{lockId}/jobs/bridges/{bridgeId}

Path Parameters

Parameter	Type	Required
lockId	string	Yes
bridgeId	string	Yes

Responses

200 Success

Request Example

curl -X POST https://api.igloodeveloper.co/devices/{lockId}/jobs/bridges/{bridgeId} \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"key": "value"}'

import { Igloo } from "@igloo/sdk";

const igloo = new Igloo(process.env.IGLOO_API_KEY);
const params = {
  lockId: "value",
  bridgeId: "value",
};
const response = await igloo.devices.createBridgeProxiedJob(params);

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "lockId": "value",
    "bridgeId": "value",
}
response = igloo.devices.create_bridge_proxied_job(params)

package main

import (
	"context"
	"os"
	"go.igloohome.co/orion/sdk"
)

func main() {
	client := sdk.NewClient(sdk.ClientOptions{
		APIKey: os.Getenv("IGLOO_API_KEY"),
	})
	params := map[string]interface{}{
		"lockId": "value",
		"bridgeId": "value",
	}
	err := client.CreateBridgeProxiedJob(context.Background(), params)
}

<?php

$client = new \Igloo\Client(getenv("IGLOO_API_KEY"));
$params = [
    "lockId" => "value",
    "bridgeId" => "value",
];
$response = $client->createBridgeProxiedJob($params);

import co.igloo.sdk.Client

val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
    "lockId" to "value",
    "bridgeId" to "value",
)
val response = client.createBridgeProxiedJob(params)

import Foundation

let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
    "lockId": "value",
    "bridgeId": "value",
]
client.createBridgeProxiedJob(params) { result in
    // handle result
}

Create Bridge Targeted Job

POST /devices/{bridgeId}/jobs

Path Parameters

Parameter	Type	Required
bridgeId	string	Yes

Responses

200 Success

Request Example

curl -X POST https://api.igloodeveloper.co/devices/{bridgeId}/jobs \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"key": "value"}'

import { Igloo } from "@igloo/sdk";

const igloo = new Igloo(process.env.IGLOO_API_KEY);
const params = {
  bridgeId: "value",
};
const response = await igloo.devices.createBridgeTargetedJob(params);

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "bridgeId": "value",
}
response = igloo.devices.create_bridge_targeted_job(params)

package main

import (
	"context"
	"os"
	"go.igloohome.co/orion/sdk"
)

func main() {
	client := sdk.NewClient(sdk.ClientOptions{
		APIKey: os.Getenv("IGLOO_API_KEY"),
	})
	params := map[string]interface{}{
		"bridgeId": "value",
	}
	err := client.CreateBridgeTargetedJob(context.Background(), params)
}

<?php

$client = new \Igloo\Client(getenv("IGLOO_API_KEY"));
$params = [
    "bridgeId" => "value",
];
$response = $client->createBridgeTargetedJob($params);

import co.igloo.sdk.Client

val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
    "bridgeId" to "value",
)
val response = client.createBridgeTargetedJob(params)

import Foundation

let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
    "bridgeId": "value",
]
client.createBridgeTargetedJob(params) { result in
    // handle result
}