Docs / iglooworks / 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 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
}

Get Access List

GET /devices/{id}/access

Path Parameters

Parameter	Type	Required
id	string	Yes

Responses

200 Success

Request Example

curl https://api.igloodeveloper.co/devices/{id}/access \
  -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.getAccessList(params);

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "id": "value",
}
response = igloo.devices.get_access_list(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.GetAccessList(context.Background(), params)
}

<?php

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

import co.igloo.sdk.Client

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

import Foundation

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

Delete Access

DELETE /devices/{id}/access/{accessId}

Path Parameters

Parameter	Type	Required
id	string	Yes
accessId	string	Yes

Responses

204 Deleted

Request Example

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

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

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

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "id": "value",
    "accessId": "value",
}
response = igloo.devices.delete_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",
		"accessId": "value",
	}
	err := client.DeleteAccess(context.Background(), params)
}

<?php

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

import co.igloo.sdk.Client

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

import Foundation

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

Create EKey

POST /devices/{id}/ekey

Path Parameters

Parameter	Type	Required
id	string	Yes

Responses

201 Created

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.createEkey(params);

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "id": "value",
}
response = igloo.devices.create_ekey(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.CreateEkey(context.Background(), params)
}

<?php

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

import co.igloo.sdk.Client

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

import Foundation

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

Create Permanent Algo Pin

POST /devices/{id}/algopin/permanent

Path Parameters

Parameter	Type	Required
id	string	Yes

Body Parameters

Content-Type: application/json

Parameter	Type	Required
schema	string	Optional
accessName	string	Optional
startDate	string	Optional
variance	integer	Optional

Responses

201 Created

Request Example

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

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

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

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "id": "value",
    "schema": "value",
    "accessName": "value",
    "startDate": "value",
    "variance": "value",
}
response = igloo.devices.create_permanent_algo_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",
		"schema": "value",
		"accessName": "value",
		"startDate": "value",
		"variance": "value",
	}
	err := client.CreatePermanentAlgoPin(context.Background(), params)
}

<?php

$client = new \Igloo\Client(getenv("IGLOO_API_KEY"));
$params = [
    "id" => "value",
    "schema" => "value",
    "accessName" => "value",
    "startDate" => "value",
    "variance" => "value",
];
$response = $client->createPermanentAlgoPin($params);

import co.igloo.sdk.Client

val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
    "id" to "value",
    "schema" to "value",
    "accessName" to "value",
    "startDate" to "value",
    "variance" to "value",
)
val response = client.createPermanentAlgoPin(params)

import Foundation

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

Create One-Time Algo Pin

POST /devices/{id}/algopin/onetime

Path Parameters

Parameter	Type	Required
id	string	Yes

Responses

201 Created

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.createOne-TimeAlgoPin(params);

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "id": "value",
}
response = igloo.devices.create_one-time_algo_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.CreateOne-TimeAlgoPin(context.Background(), params)
}

<?php

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

import co.igloo.sdk.Client

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

import Foundation

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

Create Daily Algo Pin

POST /devices/{id}/algopin/daily

Path Parameters

Parameter	Type	Required
id	string	Yes

Responses

201 Created

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.createDailyAlgoPin(params);

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "id": "value",
}
response = igloo.devices.create_daily_algo_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.CreateDailyAlgoPin(context.Background(), params)
}

<?php

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

import co.igloo.sdk.Client

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

import Foundation

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

Create Hourly Algo Pin

POST /devices/{id}/algopin/hourly

Path Parameters

Parameter	Type	Required
id	string	Yes

Responses

201 Created

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.createHourlyAlgoPin(params);

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "id": "value",
}
response = igloo.devices.create_hourly_algo_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.CreateHourlyAlgoPin(context.Background(), params)
}

<?php

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

import co.igloo.sdk.Client

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

import Foundation

let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
    "id": "value",
]
client.createHourlyAlgoPin(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
}

Get Device Jobs

GET /devices/{id}/jobs

Path Parameters

Parameter	Type	Required
id	string	Yes

Responses

200 Success

Request Example

curl https://api.igloodeveloper.co/devices/{id}/jobs \
  -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.getDeviceJobs(params);

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "id": "value",
}
response = igloo.devices.get_device_jobs(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.GetDeviceJobs(context.Background(), params)
}

<?php

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

import co.igloo.sdk.Client

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

import Foundation

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

Create Device Job (Custom Pin)

POST /devices/{id}/jobs

Path Parameters

Parameter	Type	Required
id	string	Yes

Responses

201 Created

Request Example

curl -X POST https://api.igloodeveloper.co/devices/{id}/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 = {
  id: "value",
};
const response = await igloo.devices.createDeviceJob(CustomPin)(params);

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "id": "value",
}
response = igloo.devices.create_device_job_(custom_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.CreateDeviceJob(CustomPin)(context.Background(), params)
}

<?php

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

import co.igloo.sdk.Client

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

import Foundation

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

Get Job Details

GET /devices/{id}/jobs/{jobId}

Path Parameters

Parameter	Type	Required
id	string	Yes
jobId	string	Yes

Responses

200 Success 200 Success

Request Example

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

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

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

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "id": "value",
    "jobId": "value",
}
response = igloo.devices.get_job_details(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",
		"jobId": "value",
	}
	err := client.GetJobDetails(context.Background(), params)
}

<?php

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

import co.igloo.sdk.Client

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

import Foundation

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

Create Bridge Proxied Job

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

Path Parameters

Parameter	Type	Required
deviceId	string	Yes
bridgeId	string	Yes

Responses

201 Created

Request Example

curl -X POST https://api.igloodeveloper.co/devices/{deviceId}/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 = {
  deviceId: "value",
  bridgeId: "value",
};
const response = await igloo.devices.createBridgeProxiedJob(params);

from igloo import Igloo
import os

igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
    "deviceId": "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{}{
		"deviceId": "value",
		"bridgeId": "value",
	}
	err := client.CreateBridgeProxiedJob(context.Background(), params)
}

<?php

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

import co.igloo.sdk.Client

val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
    "deviceId" 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] = [
    "deviceId": "value",
    "bridgeId": "value",
]
client.createBridgeProxiedJob(params) { result in
    // handle result
}