# igloo Platform Monolithic Context Corpus
> This file contains the entire documentation suite inlined for AI agents and LLMs.
## API Reference
### FILE: home/api_account
Title: Account
Category: API Reference
----------------------------------------
# Account API Reference
Enterprise API endpoints for managing account.
## Get Account
GET/account
### Responses
200 Success
### Request Example
```curl
curl https://api.igloodeveloper.co/account \
-H "Authorization: Bearer $API_KEY"
```
```node
import { Igloo } from "@igloo/sdk";
const igloo = new Igloo(process.env.IGLOO_API_KEY);
const response = await igloo.account.getAccount();
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
response = igloo.account.get_account()
```
```go
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.GetAccount(context.Background())
}
```
```php
getAccount();
```
```kotlin
import co.igloo.sdk.Client
val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val response = client.getAccount()
```
```swift
import Foundation
let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
client.getAccount { result in
// handle result
}
```
### FILE: home/api_devices
Title: Devices
Category: API Reference
----------------------------------------
# Devices API Reference
Enterprise API endpoints for managing devices.
## Get Devices
GET/devices
### Responses
200 Success
### Request Example
```curl
curl https://api.igloodeveloper.co/devices \
-H "Authorization: Bearer $API_KEY"
```
```node
import { Igloo } from "@igloo/sdk";
const igloo = new Igloo(process.env.IGLOO_API_KEY);
const response = await igloo.devices.getDevices();
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
response = igloo.devices.get_devices()
```
```go
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
getDevices();
```
```kotlin
import co.igloo.sdk.Client
val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val response = client.getDevices()
```
```swift
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
curl https://api.igloodeveloper.co/devices/support-pins \
-H "Authorization: Bearer $API_KEY"
```
```node
import { Igloo } from "@igloo/sdk";
const igloo = new Igloo(process.env.IGLOO_API_KEY);
const response = await igloo.devices.getSupportPinDevices();
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
response = igloo.devices.get_support_pin_devices()
```
```go
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
getSupportPinDevices();
```
```kotlin
import co.igloo.sdk.Client
val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val response = client.getSupportPinDevices()
```
```swift
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
curl https://api.igloodeveloper.co/devices/{id} \
-H "Authorization: Bearer $API_KEY"
```
```node
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);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
}
response = igloo.devices.get_device(params)
```
```go
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
"value",
];
$response = $client->getDevice($params);
```
```kotlin
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)
```
```swift
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
curl -X PUT https://api.igloodeveloper.co/devices/{id} \
-H "Authorization: Bearer $API_KEY" \
-d '{
"schema": "value",
"name": "value"
}'
```
```node
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);
```
```python
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)
```
```go
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
"value",
"schema" => "value",
"name" => "value",
];
$response = $client->updateDevice($params);
```
```kotlin
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)
```
```swift
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
curl https://api.igloodeveloper.co/devices/{id}/masterpin \
-H "Authorization: Bearer $API_KEY"
```
```node
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);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
}
response = igloo.devices.get_master_pin(params)
```
```go
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
"value",
];
$response = $client->getMasterPin($params);
```
```kotlin
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)
```
```swift
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
curl -X POST https://api.igloodeveloper.co/devices/{id}/algopin/permanent \
-H "Authorization: Bearer $API_KEY" \
-d '{"key": "value"}'
```
```node
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);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
}
response = igloo.devices.create_permanent_pin(params)
```
```go
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
"value",
];
$response = $client->createPermanentPin($params);
```
```kotlin
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)
```
```swift
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
curl -X POST https://api.igloodeveloper.co/devices/{id}/algopin/onetime \
-H "Authorization: Bearer $API_KEY" \
-d '{"key": "value"}'
```
```node
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);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
}
response = igloo.devices.create_otp_pin(params)
```
```go
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
"value",
];
$response = $client->createOtpPin($params);
```
```kotlin
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)
```
```swift
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
curl -X POST https://api.igloodeveloper.co/devices/{id}/algopin/hourly \
-H "Authorization: Bearer $API_KEY" \
-d '{"key": "value"}'
```
```node
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);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
}
response = igloo.devices.create_hourly_pin(params)
```
```go
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
"value",
];
$response = $client->createHourlyPin($params);
```
```kotlin
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)
```
```swift
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
curl -X POST https://api.igloodeveloper.co/devices/{id}/algopin/daily \
-H "Authorization: Bearer $API_KEY" \
-d '{"key": "value"}'
```
```node
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);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
}
response = igloo.devices.create_daily_pin(params)
```
```go
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
"value",
];
$response = $client->createDailyPin($params);
```
```kotlin
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)
```
```swift
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
curl -X POST https://api.igloodeveloper.co/devices/{id}/ekey \
-H "Authorization: Bearer $API_KEY" \
-d '{"key": "value"}'
```
```node
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);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
}
response = igloo.devices.create_ekey_access(params)
```
```go
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
"value",
];
$response = $client->createEkeyAccess($params);
```
```kotlin
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)
```
```swift
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
curl https://api.igloodeveloper.co/devices/{id}/activity \
-H "Authorization: Bearer $API_KEY"
```
```node
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);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
}
response = igloo.devices.get_device_activity(params)
```
```go
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
"value",
];
$response = $client->getDeviceActivity($params);
```
```kotlin
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)
```
```swift
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
curl -X POST https://api.igloodeveloper.co/devices/{id}/activity \
-H "Authorization: Bearer $API_KEY" \
-d '{
"schema": "value",
"logsPayload": "value"
}'
```
```node
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);
```
```python
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)
```
```go
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
"value",
"schema" => "value",
"logsPayload" => "value",
];
$response = $client->pushDeviceActivity($params);
```
```kotlin
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)
```
```swift
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
curl -X POST https://api.igloodeveloper.co/devices/{lockId}/jobs/bridges/{bridgeId} \
-H "Authorization: Bearer $API_KEY" \
-d '{"key": "value"}'
```
```node
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);
```
```python
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)
```
```go
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
"value",
"bridgeId" => "value",
];
$response = $client->createBridgeProxiedJob($params);
```
```kotlin
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)
```
```swift
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
curl -X POST https://api.igloodeveloper.co/devices/{bridgeId}/jobs \
-H "Authorization: Bearer $API_KEY" \
-d '{"key": "value"}'
```
```node
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);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"bridgeId": "value",
}
response = igloo.devices.create_bridge_targeted_job(params)
```
```go
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
"value",
];
$response = $client->createBridgeTargetedJob($params);
```
```kotlin
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)
```
```swift
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
}
```
### FILE: home/api_jobs
Title: Jobs
Category: API Reference
----------------------------------------
# Jobs API Reference
Enterprise API endpoints for managing jobs.
## Get Job Status
GET/jobs/{id}
### Path Parameters
Parameter
Type
Required
id
string
Yes
### Responses
200 Success
### Request Example
```curl
curl https://api.igloodeveloper.co/jobs/{id} \
-H "Authorization: Bearer $API_KEY"
```
```node
import { Igloo } from "@igloo/sdk";
const igloo = new Igloo(process.env.IGLOO_API_KEY);
const params = {
id: "value",
};
const response = await igloo.jobs.getJobStatus(params);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
}
response = igloo.jobs.get_job_status(params)
```
```go
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.GetJobStatus(context.Background(), params)
}
```
```php
"value",
];
$response = $client->getJobStatus($params);
```
```kotlin
import co.igloo.sdk.Client
val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
"id" to "value",
)
val response = client.getJobStatus(params)
```
```swift
import Foundation
let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
"id": "value",
]
client.getJobStatus(params) { result in
// handle result
}
```
### FILE: home/api_properties
Title: Properties
Category: API Reference
----------------------------------------
# Properties API Reference
Enterprise API endpoints for managing properties.
## Get Properties
GET/properties
### Responses
200 Success
### Request Example
```curl
curl https://api.igloodeveloper.co/properties \
-H "Authorization: Bearer $API_KEY"
```
```node
import { Igloo } from "@igloo/sdk";
const igloo = new Igloo(process.env.IGLOO_API_KEY);
const response = await igloo.properties.getProperties();
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
response = igloo.properties.get_properties()
```
```go
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.GetProperties(context.Background())
}
```
```php
getProperties();
```
```kotlin
import co.igloo.sdk.Client
val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val response = client.getProperties()
```
```swift
import Foundation
let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
client.getProperties { result in
// handle result
}
```
## Get Property
GET/properties/{id}
### Path Parameters
Parameter
Type
Required
id
string
Yes
### Responses
200 Success
### Request Example
```curl
curl https://api.igloodeveloper.co/properties/{id} \
-H "Authorization: Bearer $API_KEY"
```
```node
import { Igloo } from "@igloo/sdk";
const igloo = new Igloo(process.env.IGLOO_API_KEY);
const params = {
id: "value",
};
const response = await igloo.properties.getProperty(params);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
}
response = igloo.properties.get_property(params)
```
```go
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.GetProperty(context.Background(), params)
}
```
```php
"value",
];
$response = $client->getProperty($params);
```
```kotlin
import co.igloo.sdk.Client
val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
"id" to "value",
)
val response = client.getProperty(params)
```
```swift
import Foundation
let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
"id": "value",
]
client.getProperty(params) { result in
// handle result
}
```
## Get Property Devices
GET/properties/{id}/devices
### Path Parameters
Parameter
Type
Required
id
string
Yes
### Responses
200 Success
### Request Example
```curl
curl https://api.igloodeveloper.co/properties/{id}/devices \
-H "Authorization: Bearer $API_KEY"
```
```node
import { Igloo } from "@igloo/sdk";
const igloo = new Igloo(process.env.IGLOO_API_KEY);
const params = {
id: "value",
};
const response = await igloo.properties.getPropertyDevices(params);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
}
response = igloo.properties.get_property_devices(params)
```
```go
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.GetPropertyDevices(context.Background(), params)
}
```
```php
"value",
];
$response = $client->getPropertyDevices($params);
```
```kotlin
import co.igloo.sdk.Client
val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
"id" to "value",
)
val response = client.getPropertyDevices(params)
```
```swift
import Foundation
let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
"id": "value",
]
client.getPropertyDevices(params) { result in
// handle result
}
```
### FILE: home/api_server_health
Title: Server Health
Category: API Reference
----------------------------------------
# Server Health API Reference
Enterprise API endpoints for managing server health.
## Server Health
GET/server-health
### Responses
200 Success
### Request Example
```curl
curl https://api.igloodeveloper.co/server-health \
-H "Authorization: Bearer $API_KEY"
```
```node
import { Igloo } from "@igloo/sdk";
const igloo = new Igloo(process.env.IGLOO_API_KEY);
const response = await igloo.server health.serverHealth();
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
response = igloo.server health.server_health()
```
```go
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.ServerHealth(context.Background())
}
```
```php
serverHealth();
```
```kotlin
import co.igloo.sdk.Client
val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val response = client.serverHealth()
```
```swift
import Foundation
let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
client.serverHealth { result in
// handle result
}
```
### FILE: home/api_token
Title: Token
Category: API Reference
----------------------------------------
# Token API Reference
Enterprise API endpoints for managing token.
### Request Example
```curl
curl -X POST https://api.igloodeveloper.co/token/revoke \
-H "Authorization: Bearer $API_KEY" \
-d '{
"schema": "value",
"refreshToken": "value",
"clientId": "value",
"clientSecret": "value"
}'
```
```node
import { Igloo } from "@igloo/sdk";
const igloo = new Igloo(process.env.IGLOO_API_KEY);
const params = {
schema: "value",
refreshToken: "value",
clientId: "value",
clientSecret: "value",
};
const response = await igloo.token.revokeToken(params);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"schema": "value",
"refreshToken": "value",
"clientId": "value",
"clientSecret": "value",
}
response = igloo.token.revoke_token(params)
```
```go
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{}{
"schema": "value",
"refreshToken": "value",
"clientId": "value",
"clientSecret": "value",
}
err := client.RevokeToken(context.Background(), params)
}
```
```php
"value",
"refreshToken" => "value",
"clientId" => "value",
"clientSecret" => "value",
];
$response = $client->revokeToken($params);
```
```kotlin
import co.igloo.sdk.Client
val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
"schema" to "value",
"refreshToken" to "value",
"clientId" to "value",
"clientSecret" to "value",
)
val response = client.revokeToken(params)
```
```swift
import Foundation
let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
"schema": "value",
"refreshToken": "value",
"clientId": "value",
"clientSecret": "value",
]
client.revokeToken(params) { result in
// handle result
}
```
### FILE: works/api_account
Title: Account
Category: API Reference
----------------------------------------
# Account API Reference
Enterprise API endpoints for managing account.
## Get Account
GET/account
### Responses
200 Success
### Request Example
```curl
curl https://api.igloodeveloper.co/account \
-H "Authorization: Bearer $API_KEY"
```
```node
import { Igloo } from "@igloo/sdk";
const igloo = new Igloo(process.env.IGLOO_API_KEY);
const response = await igloo.account.getAccount();
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
response = igloo.account.get_account()
```
```go
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.GetAccount(context.Background())
}
```
```php
getAccount();
```
```kotlin
import co.igloo.sdk.Client
val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val response = client.getAccount()
```
```swift
import Foundation
let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
client.getAccount { result in
// handle result
}
```
### FILE: works/api_bridge
Title: Bridge
Category: API Reference
----------------------------------------
# Bridge API Reference
Enterprise API endpoints for managing bridge.
## Get Bridge Job Details
GET/bridge/jobs/{jobId}
### Path Parameters
Parameter
Type
Required
jobId
string
Yes
### Responses
200 Success
### Request Example
```curl
curl https://api.igloodeveloper.co/bridge/jobs/{jobId} \
-H "Authorization: Bearer $API_KEY"
```
```node
import { Igloo } from "@igloo/sdk";
const igloo = new Igloo(process.env.IGLOO_API_KEY);
const params = {
jobId: "value",
};
const response = await igloo.bridge.getBridgeJobDetails(params);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"jobId": "value",
}
response = igloo.bridge.get_bridge_job_details(params)
```
```go
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{}{
"jobId": "value",
}
err := client.GetBridgeJobDetails(context.Background(), params)
}
```
```php
"value",
];
$response = $client->getBridgeJobDetails($params);
```
```kotlin
import co.igloo.sdk.Client
val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
"jobId" to "value",
)
val response = client.getBridgeJobDetails(params)
```
```swift
import Foundation
let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
"jobId": "value",
]
client.getBridgeJobDetails(params) { result in
// handle result
}
```
### FILE: works/api_departments
Title: Departments
Category: API Reference
----------------------------------------
# Departments API Reference
Enterprise API endpoints for managing departments.
## Get Departments
GET/departments
### Responses
200 Success
### Request Example
```curl
curl https://api.igloodeveloper.co/departments \
-H "Authorization: Bearer $API_KEY"
```
```node
import { Igloo } from "@igloo/sdk";
const igloo = new Igloo(process.env.IGLOO_API_KEY);
const response = await igloo.departments.getDepartments();
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
response = igloo.departments.get_departments()
```
```go
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.GetDepartments(context.Background())
}
```
```php
getDepartments();
```
```kotlin
import co.igloo.sdk.Client
val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val response = client.getDepartments()
```
```swift
import Foundation
let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
client.getDepartments { result in
// handle result
}
```
## Get Department Devices
GET/departments/{id}/devices
### Path Parameters
Parameter
Type
Required
id
string
Yes
### Responses
200 Success
### Request Example
```curl
curl https://api.igloodeveloper.co/departments/{id}/devices \
-H "Authorization: Bearer $API_KEY"
```
```node
import { Igloo } from "@igloo/sdk";
const igloo = new Igloo(process.env.IGLOO_API_KEY);
const params = {
id: "value",
};
const response = await igloo.departments.getDepartmentDevices(params);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
}
response = igloo.departments.get_department_devices(params)
```
```go
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.GetDepartmentDevices(context.Background(), params)
}
```
```php
"value",
];
$response = $client->getDepartmentDevices($params);
```
```kotlin
import co.igloo.sdk.Client
val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
"id" to "value",
)
val response = client.getDepartmentDevices(params)
```
```swift
import Foundation
let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
"id": "value",
]
client.getDepartmentDevices(params) { result in
// handle result
}
```
## Get Department Properties
GET/departments/{department_id}/properties
### Path Parameters
Parameter
Type
Required
department_id
string
Yes
### Responses
200 Success
### Request Example
```curl
curl https://api.igloodeveloper.co/departments/{department_id}/properties \
-H "Authorization: Bearer $API_KEY"
```
```node
import { Igloo } from "@igloo/sdk";
const igloo = new Igloo(process.env.IGLOO_API_KEY);
const params = {
department_id: "value",
};
const response = await igloo.departments.getDepartmentProperties(params);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"department_id": "value",
}
response = igloo.departments.get_department_properties(params)
```
```go
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{}{
"department_id": "value",
}
err := client.GetDepartmentProperties(context.Background(), params)
}
```
```php
"value",
];
$response = $client->getDepartmentProperties($params);
```
```kotlin
import co.igloo.sdk.Client
val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
"department_id" to "value",
)
val response = client.getDepartmentProperties(params)
```
```swift
import Foundation
let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
"department_id": "value",
]
client.getDepartmentProperties(params) { result in
// handle result
}
```
## Get Department Access
GET/departments/{id}/access
### Path Parameters
Parameter
Type
Required
id
string
Yes
### Responses
200 Success
### Request Example
```curl
curl https://api.igloodeveloper.co/departments/{id}/access \
-H "Authorization: Bearer $API_KEY"
```
```node
import { Igloo } from "@igloo/sdk";
const igloo = new Igloo(process.env.IGLOO_API_KEY);
const params = {
id: "value",
};
const response = await igloo.departments.getDepartmentAccess(params);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
}
response = igloo.departments.get_department_access(params)
```
```go
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.GetDepartmentAccess(context.Background(), params)
}
```
```php
"value",
];
$response = $client->getDepartmentAccess($params);
```
```kotlin
import co.igloo.sdk.Client
val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
"id" to "value",
)
val response = client.getDepartmentAccess(params)
```
```swift
import Foundation
let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
"id": "value",
]
client.getDepartmentAccess(params) { result in
// handle result
}
```
### FILE: works/api_devices
Title: Devices
Category: API Reference
----------------------------------------
# Devices API Reference
Enterprise API endpoints for managing devices.
## Get Devices
GET/devices
### Responses
200 Success
### Request Example
```curl
curl https://api.igloodeveloper.co/devices \
-H "Authorization: Bearer $API_KEY"
```
```node
import { Igloo } from "@igloo/sdk";
const igloo = new Igloo(process.env.IGLOO_API_KEY);
const response = await igloo.devices.getDevices();
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
response = igloo.devices.get_devices()
```
```go
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
getDevices();
```
```kotlin
import co.igloo.sdk.Client
val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val response = client.getDevices()
```
```swift
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
curl https://api.igloodeveloper.co/devices/{id} \
-H "Authorization: Bearer $API_KEY"
```
```node
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);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
}
response = igloo.devices.get_device(params)
```
```go
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
"value",
];
$response = $client->getDevice($params);
```
```kotlin
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)
```
```swift
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
curl https://api.igloodeveloper.co/devices/{id}/access \
-H "Authorization: Bearer $API_KEY"
```
```node
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);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
}
response = igloo.devices.get_access_list(params)
```
```go
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
"value",
];
$response = $client->getAccessList($params);
```
```kotlin
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)
```
```swift
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
curl https://api.igloodeveloper.co/devices/{id}/access/{accessId} \
-H "Authorization: Bearer $API_KEY"
```
```node
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);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
"accessId": "value",
}
response = igloo.devices.delete_access(params)
```
```go
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
"value",
"accessId" => "value",
];
$response = $client->deleteAccess($params);
```
```kotlin
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)
```
```swift
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
curl -X POST https://api.igloodeveloper.co/devices/{id}/ekey \
-H "Authorization: Bearer $API_KEY" \
-d '{"key": "value"}'
```
```node
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);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
}
response = igloo.devices.create_ekey(params)
```
```go
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
"value",
];
$response = $client->createEkey($params);
```
```kotlin
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)
```
```swift
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
}
```
### Request Example
```curl
curl -X POST https://api.igloodeveloper.co/devices/{id}/algopin/onetime \
-H "Authorization: Bearer $API_KEY" \
-d '{"key": "value"}'
```
```node
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);
```
```python
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)
```
```go
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
"value",
];
$response = $client->createOne-TimeAlgoPin($params);
```
```kotlin
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)
```
```swift
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
curl -X POST https://api.igloodeveloper.co/devices/{id}/algopin/daily \
-H "Authorization: Bearer $API_KEY" \
-d '{"key": "value"}'
```
```node
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);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
}
response = igloo.devices.create_daily_algo_pin(params)
```
```go
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
"value",
];
$response = $client->createDailyAlgoPin($params);
```
```kotlin
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)
```
```swift
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
curl -X POST https://api.igloodeveloper.co/devices/{id}/algopin/hourly \
-H "Authorization: Bearer $API_KEY" \
-d '{"key": "value"}'
```
```node
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);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
}
response = igloo.devices.create_hourly_algo_pin(params)
```
```go
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
"value",
];
$response = $client->createHourlyAlgoPin($params);
```
```kotlin
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)
```
```swift
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
curl https://api.igloodeveloper.co/devices/{id}/activity \
-H "Authorization: Bearer $API_KEY"
```
```node
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);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
}
response = igloo.devices.get_device_activity(params)
```
```go
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
"value",
];
$response = $client->getDeviceActivity($params);
```
```kotlin
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)
```
```swift
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
curl -X POST https://api.igloodeveloper.co/devices/{id}/activity \
-H "Authorization: Bearer $API_KEY" \
-d '{
"schema": "value",
"logsPayload": "value"
}'
```
```node
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);
```
```python
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)
```
```go
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
"value",
"schema" => "value",
"logsPayload" => "value",
];
$response = $client->pushDeviceActivity($params);
```
```kotlin
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)
```
```swift
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
curl https://api.igloodeveloper.co/devices/{id}/jobs \
-H "Authorization: Bearer $API_KEY"
```
```node
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);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
}
response = igloo.devices.get_device_jobs(params)
```
```go
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
"value",
];
$response = $client->getDeviceJobs($params);
```
```kotlin
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)
```
```swift
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
curl -X POST https://api.igloodeveloper.co/devices/{id}/jobs \
-H "Authorization: Bearer $API_KEY" \
-d '{"key": "value"}'
```
```node
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);
```
```python
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)
```
```go
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
"value",
];
$response = $client->createDeviceJob(CustomPin)($params);
```
```kotlin
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)
```
```swift
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 Success200 Success
### Request Example
```curl
curl https://api.igloodeveloper.co/devices/{id}/jobs/{jobId} \
-H "Authorization: Bearer $API_KEY"
```
```node
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);
```
```python
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)
```
```go
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
"value",
"jobId" => "value",
];
$response = $client->getJobDetails($params);
```
```kotlin
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)
```
```swift
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
curl -X POST https://api.igloodeveloper.co/devices/{deviceId}/jobs/bridges/{bridgeId} \
-H "Authorization: Bearer $API_KEY" \
-d '{"key": "value"}'
```
```node
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);
```
```python
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)
```
```go
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
"value",
"bridgeId" => "value",
];
$response = $client->createBridgeProxiedJob($params);
```
```kotlin
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)
```
```swift
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
}
```
### FILE: works/api_health
Title: Health
Category: API Reference
----------------------------------------
# Health API Reference
Enterprise API endpoints for managing health.
## Health Check
GET/health
### Responses
200 Success
### Request Example
```curl
curl https://api.igloodeveloper.co/health \
-H "Authorization: Bearer $API_KEY"
```
```node
import { Igloo } from "@igloo/sdk";
const igloo = new Igloo(process.env.IGLOO_API_KEY);
const response = await igloo.health.healthCheck();
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
response = igloo.health.health_check()
```
```go
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.HealthCheck(context.Background())
}
```
```php
healthCheck();
```
```kotlin
import co.igloo.sdk.Client
val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val response = client.healthCheck()
```
```swift
import Foundation
let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
client.healthCheck { result in
// handle result
}
```
### FILE: works/api_properties
Title: Properties
Category: API Reference
----------------------------------------
# Properties API Reference
Enterprise API endpoints for managing properties.
## Get Properties
GET/properties
### Responses
200 Success
### Request Example
```curl
curl https://api.igloodeveloper.co/properties \
-H "Authorization: Bearer $API_KEY"
```
```node
import { Igloo } from "@igloo/sdk";
const igloo = new Igloo(process.env.IGLOO_API_KEY);
const response = await igloo.properties.getProperties();
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
response = igloo.properties.get_properties()
```
```go
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.GetProperties(context.Background())
}
```
```php
getProperties();
```
```kotlin
import co.igloo.sdk.Client
val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val response = client.getProperties()
```
```swift
import Foundation
let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
client.getProperties { result in
// handle result
}
```
## Get Property
GET/properties/{id}
### Path Parameters
Parameter
Type
Required
id
string
Yes
### Responses
200 Success
### Request Example
```curl
curl https://api.igloodeveloper.co/properties/{id} \
-H "Authorization: Bearer $API_KEY"
```
```node
import { Igloo } from "@igloo/sdk";
const igloo = new Igloo(process.env.IGLOO_API_KEY);
const params = {
id: "value",
};
const response = await igloo.properties.getProperty(params);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
}
response = igloo.properties.get_property(params)
```
```go
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.GetProperty(context.Background(), params)
}
```
```php
"value",
];
$response = $client->getProperty($params);
```
```kotlin
import co.igloo.sdk.Client
val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
"id" to "value",
)
val response = client.getProperty(params)
```
```swift
import Foundation
let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
"id": "value",
]
client.getProperty(params) { result in
// handle result
}
```
## Get Property Devices
GET/properties/{id}/devices
### Path Parameters
Parameter
Type
Required
id
string
Yes
### Responses
200 Success
### Request Example
```curl
curl https://api.igloodeveloper.co/properties/{id}/devices \
-H "Authorization: Bearer $API_KEY"
```
```node
import { Igloo } from "@igloo/sdk";
const igloo = new Igloo(process.env.IGLOO_API_KEY);
const params = {
id: "value",
};
const response = await igloo.properties.getPropertyDevices(params);
```
```python
from igloo import Igloo
import os
igloo = Igloo(os.environ["IGLOO_API_KEY"])
params = {
"id": "value",
}
response = igloo.properties.get_property_devices(params)
```
```go
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.GetPropertyDevices(context.Background(), params)
}
```
```php
"value",
];
$response = $client->getPropertyDevices($params);
```
```kotlin
import co.igloo.sdk.Client
val client = Client(apiKey = System.getenv("IGLOO_API_KEY"))
val params = mapOf(
"id" to "value",
)
val response = client.getPropertyDevices(params)
```
```swift
import Foundation
let client = IglooClient(apiKey: ProcessInfo.processInfo.environment["IGLOO_API_KEY"] ?? "")
let params: [String: Any] = [
"id": "value",
]
client.getPropertyDevices(params) { result in
// handle result
}
```
## Getting started
### FILE: how-it-works
Title: How It Works
Category: Getting started
----------------------------------------
# How It Works
Orion parses Markdown files containing metadata frontmatter and compiles them into a static documentation portal matching the high-fidelity brand guideline of Igloo.
## Core Features
- **Automated Directory Foldering**: Subdirectories (`docs/home` and `docs/works`) isolate product-specific document lists so that navigating inside a product keeps the sidebar clean and focused.
- **Local Assets & Styling**: Embedded CSS style assets and Prism syntax highlights work offline.
- **AI friendly index**: Generates `llms.txt` automatically to allow easy consumption by agents and custom models.
### FILE:
Title: Documentation
Category: Getting started
----------------------------------------
Igloo Developer Platform
# Documentation
Integrate smart locks, keypads and bridges into your product. One REST API, 4 SDKs and an MCP server for AI agents.
Append .md to any URL, or use Copy Page on any page.
Docs MCP server
Agents search and read these docs directly. Set up MCP
Base URL
https://api.igloodeveloper.co/v1
Authenticate every request with a bearer token. Keys are issued per workspace from the console.
### FILE: mcp
Title: MCP Server
Category: Getting started
----------------------------------------
# MCP Server Tutorial
Deploy our secure, OAuth-secured AWS Lambda MCP server to integrate with custom AI agents and automate access-control operations natively.
## OAuth Authentication
Our Model Context Protocol (MCP) server secures sensitive door lock and access pin tools using standard OAuth 2.0 bearer handshakes. Before deploying, obtain your OAuth credentials (client id and secret) from the console.
## Install with Claude Code
Instruct Claude to add the MCP server using client credential grants:
```bash
claude mcp add igloo -e IGLOO_OAUTH_CLIENT_ID=client_abc123 -e IGLOO_OAUTH_CLIENT_SECRET=secret_xyz789 -- npx -y @igloo/mcp
```
## Configuration
Claude Desktop and other MCP clients can load the OAuth metadata dynamically from the standard configuration file:
```json
{
"mcpServers": {
"igloo": {
"command": "npx",
"args": ["-y", "@igloo/mcp"],
"env": {
"IGLOO_OAUTH_CLIENT_ID": "client_abc123",
"IGLOO_OAUTH_CLIENT_SECRET": "secret_xyz789",
"IGLOO_AUTH_SERVER": "https://auth.igloodeveloper.co"
}
}
}
}
```
## Available Tools
- `list_devices` (Read): List all locks, readers, and controllers. Requires scope `locks:read`.
- `create_pin` (Write): Generate a time-bound offline residential or hourly PIN. Requires scope `locks:write`.
## igloohome
### FILE: home/mcp
Title: MCP Server
Category: igloohome
----------------------------------------
# igloohome MCP Server
Give AI agents secure access to your igloohome residential devices using OAuth-secured MCP server adapters.
## OAuth Configuration
The igloohome MCP server authenticates and authorizes lock commands using standard OAuth 2.0. Generate a client credential pair in your portal under Settings → Developer Credentials.
## Claude Desktop Integration
Add this server config block to your desktop client config file:
```json
{
"mcpServers": {
"igloo-home": {
"command": "npx",
"args": ["-y", "@igloo/home-mcp"],
"env": {
"IGLOO_HOME_CLIENT_ID": "client_home_123",
"IGLOO_HOME_CLIENT_SECRET": "secret_home_456"
}
}
}
}
```
### FILE: home/quickstart
Title: Quickstart
Category: igloohome
----------------------------------------
# Quickstart
Get started with your igloohome smart lock integration in 3 easy steps.
## 1. Retrieve your API Key
API keys are issued via your igloohome portal. Be sure to keep this safe and set it in your environment:
```bash
export IGLOOHOME_API_KEY="ig_home_test_..."
```
## 2. Make your first request
List all locks currently associated with your account:
```bash
curl https://api.igloohome.co/v1/locks \
-H "Authorization: Bearer $IGLOOHOME_API_KEY"
```
## 3. Create a residential PIN
```bash
curl -X POST https://api.igloohome.co/v1/locks/LK123/pins \
-H "Authorization: Bearer $IGLOOHOME_API_KEY" \
-d '{"duration_hours": 24}'
```
### FILE: home
Title: Introduction
Category: igloohome
----------------------------------------
# igloohome Documentation
Welcome to the igloohome Developer Platform. igloohome provides smart lock APIs and SDKs built specifically for residential setups, single-family houses, and vacation rentals.
## Core Features
- **Offline PIN computation**: PINs can be calculated and issued without any active internet connection on the lock.
- **Easy SDK installation**: Integrate with our lightweight native clients across Go, Python, and Node.
## Base API Endpoint
```bash
https://api.igloohome.co/v1
```
## iglooworks
### FILE: works/mcp
Title: MCP Server
Category: iglooworks
----------------------------------------
# iglooworks MCP Server
Deploy our secure enterprise AWS Lambda MCP server to integrate with custom AI agents and automate property access operations safely.
## OAuth Bearer Authentication
The iglooworks MCP server secures its administrative building controls using OAuth 2.0. AI agents must present a valid bearer access token issued by our enterprise authorization server (`https://auth.igloodeveloper.co`) with scopes `locks:write` and `devices:read`.
## Configuration
Set up client environment keys inside your server deployment package:
```json
{
"mcpServers": {
"igloo-works": {
"command": "npx",
"args": ["-y", "@igloo/works-mcp"],
"env": {
"IGLOO_WORKS_CLIENT_ID": "client_works_789",
"IGLOO_WORKS_CLIENT_SECRET": "secret_works_012",
"IGLOO_WORKS_AUTH_ISSUER": "https://auth.igloodeveloper.co"
}
}
}
}
```
### FILE: works/quickstart
Title: Quickstart
Category: iglooworks
----------------------------------------
# Quickstart
Get started with your iglooworks enterprise installation in 4 easy steps.
## 1. Retrieve your B2B API Key
API keys are issued via your iglooworks enterprise portal. Be sure to keep this safe and set it in your environment:
```bash
export IGLOOWORKS_API_KEY="ig_works_test_..."
```
## 2. List devices in your building
List all readers, locksets, and bridges currently associated with your zone:
```bash
curl https://api.iglooworks.co/v1/devices \
-H "Authorization: Bearer $IGLOOWORKS_API_KEY"
```
## 3. Create an access preset
Set up time-bound offline PIN rules:
```bash
curl -X POST https://api.iglooworks.co/v1/devices/LK456/pins/hourly \
-H "Authorization: Bearer $IGLOOWORKS_API_KEY" \
-d '{"startDate": "2026-07-15T14:00:00", "endDate": "2026-07-15T18:00:00"}'
```
### FILE: works
Title: Introduction
Category: iglooworks
----------------------------------------
# iglooworks Documentation
Welcome to the iglooworks Developer Platform. iglooworks provides B2B SaaS property management integration tools, enabling facilities managers, co-living managers, and commercial building operators to oversee access groups and lock permissions.
## Core Features
- **Door groups & zones**: Group multiple locks, readers, and controllers into logical zones.
- **Enterprise dashboard sync**: Direct integration with hardware panels and bridges.
- **Docs MCP server**: Fully compatible server deployable on AWS Lambda for AI-assisted operations.
## Base API Endpoint
```bash
https://api.iglooworks.co/v1
```