Get started with Akiles locks

Learn how to connect and control Akiles locks with the Seam API.

Akiles smart locks

Overview

Seam provides a universal API to connect and control many brands of IoT devices and systems, including smart locks, access control systems (ACSs), thermostats, and noise sensors.

This guide gives you a rapid introduction to connecting and controlling your Akiles lock using the Seam API. For application developers, you can use the Seam API in your app, and your users can authorize your app to control their devices using Seam.

For detailed information about the Akiles devices that Seam supports, see the following table and our Akiles Supported Devices page:

To learn more about other IoT device and system brands that Seam supports—such as Yale, Schlage, Google Nest, and many more—visit our integration page.

This guide shows you how to install a Seam SDK and then control your Akiles lock using the Seam API.

Another easy way to learn about what you can do with the Seam API is to explore the interactive Seam CLI, which you can access from directly within the Seam Console.

▶️ Go to the Seam Console!

---

Step 1: Install a Seam SDK

Seam provides client libraries for many languages, including JavaScript, Python, Ruby, PHP, and others, as well as a Postman collection and an OpenAPI spec.

• JavaScript / TypeScript (npm, GitHub)

• Python (pip, GitHub)

• Ruby Gem (rubygem, GitHub)

• PHP (packagist, GitHub)

• Java (GitHub)

• C# (nuget, GitHub)

• Go (GitHub)

First, install a Seam SDK, as follows:

JavaScript

npm i seam

Python

pip install seam
# For some development environments, use pip3 in this command instead of pip.

Ruby

bundle add seam

PHP

composer require seamapi/seam

Java

Gradle:

// build.gradle
dependencies {
    implementation 'io.github.seamapi:java:0.x.x'
}

Maven:

<!-- pom.xml -->
<dependency>
    <groupId>io.github.seamapi</groupId>
    <artifactId>java</artifactId>
    <version>0.x.x</version>
</dependency>

C#

Install using nuget.

Go

go get github.com/seamapi/go

Next, go to https://console.seam.co/ and sign up for Seam to get your API key.

Then, export your API key as an environment variable.

$ export SEAM_API_KEY=seam_test2bMS_94SrGUXuNR2JmJkjtvBQDg5c

This guide uses a sandbox workspace. You can only connect virtual devices and systems in this type of workspace. If you want to connect a real Akiles lock, use a non-sandbox workspace and API key.

---

Step 2: Link your Akiles account with Seam

To control your Akiles lock using the Seam API, you must first authorize your Seam workspace to connect to your Akiles account. If your application needs to connect to your users' Akiles accounts, Seam provides fully-embedded, customizable client-side Connect Webviews to collect their authorization securely. These user-friendly pre-built authorization flows walk your users through the process of granting your Seam workspace permission to control their Akiles locks. The Connect Webview presents a flow that prompts your users to enter their credentials for their Akiles account.

In this guide, you create a Connect Webview object. Then, you display the graphical component of the created Connect Webview and enter a set of sample credentials to connect a sandbox Akiles account.

This guide shows you how to create a Connect Webview programmatically using the Seam API.

The Seam Console provides another easy way to connect devices to your Seam workspace.

Go to https://console.seam.co/. On the Devices page, click + Add Devices. Then, see Authorize your workspace in this guide to complete the Connect Webview authorization flow.

Create a Connect Webview

Create a connect_webview object and then note the returned URL.

Python

Code:

from seam import Seam

seam = Seam()  # Seam automatically uses your exported SEAM_API_KEY.

connect_webview = seam.connect_webviews.create(accepted_providers=["akiles"])

assert connect_webview.login_successful is False

# Use the returned Connect Webview URL to display
# the Connect Webview authorization flow to your user.
print(connect_webview.url)

Output:

https://connect.getseam.com/connect_webviews/view?connect_webview_id=12345678-1234-1234-1234-123456789012&auth_token=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

cURL (bash)

Code:

curl -X 'POST' \
  'https://connect.getseam.com/connect_webviews/create' \
  -H 'accept: application/json' \
  -H "Authorization: Bearer ${SEAM_API_KEY}" \
  -H 'Content-Type: application/json' \
  -d '{
  "accepted_providers": ["akiles"]
}' | jq -r '"Login Successful (false): " + (.connect_webview.login_successful | tostring),
  "URL: " + .connect_webview.url'
  # Use the returned Connect Webview URL to display
  # the Connect Webview authorization flow to your user.

Output:

Login Successful (false): false
https://connect.getseam.com/connect_webviews/view?connect_webview_id=12345678-1234-1234-1234-123456789012&auth_token=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

JavaScript

Code:

import { Seam } from "seam";

const seam = new Seam(); // Seam automatically uses your exported SEAM_API_KEY.

const connectWebview = await seam.connectWebviews.create({
  accepted_providers: ['akiles']
});

console.log(connectWebview.login_successful); // false

// Use the returned Connect Webview URL to display
// the Connect Webview authorization flow to your user.
console.log(connectWebview.url);

Output:

false
https://connect.getseam.com/connect_webviews/view?connect_webview_id=12345678-1234-1234-1234-123456789012&auth_token=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Ruby

Code:

require "seam"

seam = Seam.new() # Seam automatically uses your exported SEAM_API_KEY.

connect_webview = seam.connect_webviews.create(
  accepted_providers: ["akiles"]
)

puts connect_webview.login_successful # false

# Use the returned Connect Webview URL to display
# the Connect Webview authorization flow to your user.
puts connect_webview.url

Output:

false
https://connect.getseam.com/connect_webviews/view?connect_webview_id=12345678-1234-1234-1234-123456789012&auth_token=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

PHP

Code:

<?php
require 'vendor/autoload.php';

$seam = new Seam\SeamClient(); // Seam automatically uses your exported SEAM_API_KEY.

$connect_webview = $seam->connect_webviews->create(
  accepted_providers: ["akiles"]
);

echo $connect_webview->login_successful ? 'true' : 'false', "\n"; // false

// Use the returned Connect Webview URL to display
// the Connect Webview authorization flow to your user.
echo $connect_webview->url;

Output:

false
https://connect.getseam.com/connect_webviews/view?connect_webview_id=12345678-1234-1234-1234-123456789012&auth_token=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

C#

Code:

using Seam.Client;

var seam = new SeamClient(apiToken: SEAM_API_KEY);

var connectWebview = seam.ConnectWebviews.Create(
  acceptedProviders: new() {Seam.Api.ConnectWebviews.CreateRequest.AcceptedProvidersEnum.Akiles}
);

Console.WriteLine(connectWebview.LoginSuccessful); // False

// Use the returned Connect Webview URL to display
// the Connect Webview authorization flow to your user.
Console.WriteLine(connectWebview.Url);

Output:

False
https://connect.getseam.com/connect_webviews/view?connect_webview_id=12345678-1234-1234-1234-123456789012&auth_token=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Java

Code:

import java.io.Console;
import java.util.*;
import com.fasterxml.jackson.annotation.*;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.seam.api.Seam;
import com.seam.api.core.ObjectMappers;
import com.seam.api.types.ConnectWebview;
import com.seam.api.types.Device;
import com.seam.api.types.Manufacturer;
import com.seam.api.types.ActionAttempt;
import com.seam.api.types.AccessCode;
import com.seam.api.resources.connectwebviews.requests.ConnectWebviewsCreateRequest;
import com.seam.api.resources.connectwebviews.requests.ConnectWebviewsGetRequest;
import com.seam.api.resources.devices.requests.DevicesListRequest;
import com.seam.api.resources.devices.requests.DevicesGetRequest;
import com.seam.api.resources.locks.requests.LocksUnlockDoorRequest;
import com.seam.api.resources.accesscodes.requests.AccessCodesCreateRequest;
import com.seam.api.resources.accesscodes.requests.AccessCodesListRequest;

public class Main {

  public static void main(String[] args) {

    Seam seam = Seam.builder()
      .apiKey(SEAM_API_KEY)
      .build();

    ConnectWebview connectWebview = seam.connectWebviews().create(ConnectWebviewsCreateRequest.builder()
      .acceptedProviders(List.of(AcceptedProvider.AKILES))
      .build());

    System.out.println(connectWebview.getLoginSuccessful()); // false

    // Use the returned Connect Webview URL to display
    // the Connect Webview authorization flow to your user.
    System.out.println(connectWebview.getUrl());

  }
}

Output:

false
https://connect.getseam.com/connect_webviews/view?connect_webview_id=12345678-1234-1234-1234-123456789012&auth_token=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Go

Code:

package main

import (
  "context"
  "fmt"
  "os"

  api "github.com/seamapi/go"
  seam "github.com/seamapi/go/client"
)

func main() {
  if err := run(); err != nil {
    _, _ = fmt.Fprintln(os.Stderr, err.Error())
    os.Exit(1)
  }
}

func run() error {
  client := seam.NewClient(
    seam.WithApiKey(SEAM_API_KEY),
  )

  connectWebview, err := client.ConnectWebviews.Create(
    context.Background(),
    &api.ConnectWebviewsCreateRequest{
      AcceptedProviders: []api.AcceptedProvider{
        api.AcceptedProviderAkiles,
      },
    },
  )

  if err != nil {
    return err
  }

  fmt.Println(connectWebview.LoginSuccessful) // false

  // Use the returned Connect Webview URL to display
  // the Connect Webview authorization flow to your user.
  fmt.Println(connectWebview.Url)

  return nil
}

Output:

false
https://connect.getseam.com/connect_webviews/view?connect_webview_id=12345678-1234-1234-1234-123456789012&auth_token=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

---

Authorize your workspace

In a web browser, go to the URL that the Connect Webview object returned.

For application developers, you can redirect your user to this Connect Webview URL so that they can authorize your app to control their devices using Seam. We even provide a prebuilt Connect Account Button within our suite of Seam Components that help you build your device management flow.

Because you're using a sandbox workspace, you can connect Seam's test Akiles account. We provide virtual devices for each of the brands that we support. These sandbox devices and systems enable you to test your app with devices from multiple brands without the need to own all the corresponding physical devices.

Complete the Connect Webview authorization flow by entering the following Akiles sandbox account credentials:

• Email: [e-mail]

• Password: 1234

Use the Seam Connect Webview authorization flow to connect an Akiles account with Seam. This flow varies slightly based on the device manufacturer.

Confirm that authorization through the Connect Webview was successful by querying its status.

Python

Code:

updated_connect_webview = seam.connect_webviews.get(connect_webview.connect_webview_id)

assert updated_connect_webview.login_successful is True # True

Output:

True

cURL (bash)

Code:

curl -X 'GET' \
  'https://connect.getseam.com/connect_webviews/get' \
  -H 'accept: application/json' \
  -H "Authorization: Bearer ${SEAM_API_KEY}" \
  -H 'Content-Type: application/json' \
  -d "{
  \"connect_webview_id\": \"${connect_webview_id}\"
}" | jq -r '"Login Successful (true): " + (.connect_webview.login_successful | tostring)'

Output:

Login Successful (true): true

JavaScript

Code:

const updatedConnectWebview = await seam.connectWebviews.get({
  connect_webview_id: connectWebview.connect_webview_id
});

console.log(updatedConnectWebview.login_successful); // true

Output:

true

Ruby

Code:

updated_connect_webview = seam.connect_webviews.get(
  connect_webview_id: connect_webview.connect_webview_id
)

puts updated_connect_webview.login_successful # true

Output:

true

PHP

Code:

$updated_connect_webview = $seam->connect_webviews->get(
  connect_webview_id: $connect_webview->connect_webview_id
);

echo $updated_connect_webview->login_successful ? 'true' : 'false', "\n"; // true

Output:

true

C#

Code:

var updatedConnectWebview = seam.ConnectWebviews.Get(
  connectWebviewId: connectWebview.connectWebviewId
);

Console.WriteLine(updatedConnectWebview.LoginSuccessful); // True

Output:

True

Java

Code:

ConnectWebview updatedConnectWebview = seam.connectWebviews().get(ConnectWebviewsGetRequest.builder()
  .connectWebviewId(connectWebview.getConnectWebviewId())
  .build());

System.out.println(updatedConnectWebview.getLoginSuccessful()); // true

Output:

true

Go

Code:

updatedConnectWebview, err := client.ConnectWebviews.Get(
  context.Background(),
  &api.ConnectWebviewsGetRequest{
    ConnectWebviewId: connectWebview.connectWebviewId,
  },
)

if err != nil {
  return err
}

fmt.Println(updatedConnectWebview.LoginSuccessful) // true

return nil

Output:

true

---

Step 3: Retrieve Akiles lock devices

When you link an Akiles account with Seam, we create a device object to represent each Akiles lock in your account. You can then retrieve these Akiles devices using the List Devices and Get Device endpoints.

The Seam API exposes each device's properties, such as the door lock status, capabilities, and so on.

Python

Code:

# Retrieve all devices, filtered by manufacturer,
# which is one of several filters that list() supports.
all_akiles_locks = seam.devices.list(manufacturer="akiles")

# Select the first device as an example.
front_door = all_akiles_locks[0]

# Inspect specific properties.
assert front_door.properties["online"] is True # True
assert front_door.properties["locked"] is True # True

# View the entire returned device object.
pprint(front_door)

Output:

Device(
  device_id='11111111-1111-1111-1111-444444444444',
  display_name='Lock 1',
  workspace_id='00000000-0000-0000-0000-000000000000'
  connected_account_id='11111111-1111-1111-1111-222222222222',
  created_at='2024-05-29T20:08:48.878Z',
  properties={
    'manufacturer': 'akiles',
    'online': True,
    'locked': True,
    ...
  }
  can_remotely_unlock=True,
  can_program_online_access_codes=True,
  ...
)

cURL (bash)

Code:

# Retrieve all devices, filtered by manufacturer, which is
# one of several filters that the list endpoint supports.
all_akiles_locks=$(
  # Use GET or POST.
  curl -X 'GET' \
    'https://connect.getseam.com/devices/list' \
    -H 'accept: application/json' \
    -H "Authorization: Bearer ${SEAM_API_KEY}" \
    -H 'Content-Type: application/json' \
    -d '{
    "manufacturer": "akiles"
  }')

# Select the first device as an example.
front_door=$(jq -r '.devices[0]' <<< ${all_akiles_locks})

# Inspect specific properties.
echo $(jq -r '"Online (true): " + (.properties.online | tostring)' <<< ${front_door})
echo $(jq -r '"Locked (true): " + (.properties.locked | tostring)' <<< ${front_door})

# View the entire returned device object.
echo ${front_door}

Output:

Online (true): true
Locked (true): true
{
  "device_id": "11111111-1111-1111-1111-444444444444",
  "display_name": "Lock 1",
  "workspace_id": "00000000-0000-0000-0000-000000000000",
  "connected_account_id": "11111111-1111-1111-1111-222222222222",
  "created_at": "2024-05-29T20:08:48.878Z",
  "properties": {
    "manufacturer": "akiles",
    "locked": true,
    "online": true,
    ...
  },
  "can_remotely_unlock": true,
  "can_program_online_access_codes": true,
  ...
}

JavaScript

Code:

// Retrieve all devices, filtered by manufacturer,
// which is one of several filters that list() supports.
const allAkilesLocks = await seam.devices.list({manufacturer: "akiles"});

// Select the first device as an example.
const frontDoor = allAkilesLocks[0];

// Inspect specific properties.
console.log(frontDoor.properties.online); // true
console.log(frontDoor.properties.locked); // true

// View the entire returned device object.
console.log(frontDoor);

Output:

true
true
{
  device_id: '11111111-1111-1111-1111-444444444444',
  display_name: 'Lock 1',
  workspace_id: '00000000-0000-0000-0000-000000000000',
  connected_account_id: '11111111-1111-1111-1111-222222222222',
  created_at: '2024-05-29T20:08:48.878Z',
  properties: {
    manufacturer: 'akiles',
    online: true,
    locked: true,
    ...
  },
  can_remotely_unlock: true,
  can_program_online_access_codes: true,
  ...
}

Ruby

Code:

# Retrieve all devices, filtered by manufacturer,
# which is one of several filters that list() supports.
all_akiles_locks = seam.devices.list(manufacturer: "akiles")

# Select the first device as an example.
front_door = all_akiles_locks[0]

# Inspect specific properties.
puts front_door.properties.online # true
puts front_door.properties.locked # true

# View the entire returned device object.
puts front_door.inspect

Output:

true
true
<
  Seam::Device:0x00438
    device_id="11111111-1111-1111-1111-444444444444"
    display_name="Lock 1"
    workspace_id="00000000-0000-0000-0000-000000000000"
    connected_account_id="11111111-1111-1111-1111-222222222222"
    created_at=2024-05-29 20:08:48.878 UTC
    properties={
      "manufacturer"=>"akiles",
      "online"=>true,
      "locked"=>true,
      ...
    }
    can_remotely_unlock=true
    can_program_online_access_codes=true
    ...
>

PHP

Code:

// Retrieve all devices, filtered by manufacturer,
// which is one of several filters that list() supports.
$all_akiles_locks = $seam->devices->list(manufacturer: "akiles");

// Select the first device as an example.
$front_door = $all_akiles_locks[0];

// Inspect specific properties.
echo $front_door->properties->online ? 'true' : 'false', "\n"; // true
echo $front_door->properties->locked ? 'true' : 'false', "\n"; // true

// View the entire returned device object.
echo json_encode($front_door, JSON_PRETTY_PRINT);

Output:

true
true
{
  "device_id": "11111111-1111-1111-1111-444444444444",
  "display_name": "Lock 1",
  "workspace_id": "00000000-0000-0000-0000-000000000000"
  "connected_account_id": "11111111-1111-1111-1111-222222222222",
  "created_at": "2024-05-29T20:08:48.878Z",
  "properties": {
    "manufacturer": "akiles",
    "online": true,
    "locked": true,
    ...
  },
  "can_remotely_unlock": true,
  "can_program_online_access_codes": true,
  ...
}

C#

Code:

// Retrieve all devices, filtered by manufacturer,
// which is one of several filters that list() supports.
var allAkilesLocks = seam.Devices.List(
  manufacturer: Seam.Api.Devices.ListRequest.ManufacturerEnum.Akiles
);

// Select the first device as an example.
Device frontDoor = allAkilesLocks[0];

// Inspect specific properties.
Console.WriteLine(frontDoor.Properties.Online); // true
Console.WriteLine(frontDoor.Properties.Locked); // true

// View the entire returned device object.
Console.WriteLine(frontDoor);

Output:

True
True
{
  "device_id": "11111111-1111-1111-1111-444444444444",
  "display_name": "Lock 1",
  "workspace_id": "00000000-0000-0000-0000-000000000000",
  "connected_account_id": "11111111-1111-1111-1111-222222222222",
  "created_at": "2024-05-29T20:08:48.878Z",
  "properties": {
    "manufacturer": "akiles",
    "online": true,
    "locked": true,
    ...
  },
  "can_remotely_unlock": true,
  "can_program_online_access_codes": true,
  ...
}

Java

Code:

// Retrieve all devices, filtered by manufacturer,
// which is one of several filters that list() supports.
var allAkilesLocks = seam.devices().list(DevicesListRequest.builder()
  .manufacturer(Manufacturer.AKILES)
  .build());

// Select the first device as an example.
Device frontDoor = allAkilesLocks.get(0);

// Inspect specific properties.
System.out.println(frontDoor.getProperties().getOnline()); // true
System.out.println(frontDoor.getProperties().getLocked()); // true

// View the entire returned device object.
System.out.println(frontDoor);

Output:

true
true
{
  "device_id" : "11111111-1111-1111-1111-444444444444",
  "display_name": "Lock 1",
  "workspace_id" : "00000000-0000-0000-0000-000000000000",
  "connected_account_id" : "11111111-1111-1111-1111-222222222222",
  "created_at" : "2024-05-29T20:08:48.878Z",
  "properties" : {
    "manufacturer" : "akiles",
    "online" : true,
    "locked" : true,
    ...
  },
  "can_remotely_unlock" : true,
  "can_program_online_access_codes": true,
  ...
}

Go

Code:

// Retrieve all devices, filtered by manufacturer,
// which is one of several filters that list() supports.
allAkilesLocks, err := client.Devices.List(
  context.Background(), &api.DevicesListRequest{
    Manufacturer: api.ManufacturerAkiles.Ptr(),
  },
)

// Select the first device as an example.
frontDoor := allAkilesLocks[0]

if err != nil {
  return err
}

// Inspect specific properties.
fmt.Println(frontDoor.Properties.Online) // true
fmt.Println(*frontDoor.Properties.Locked) // true

// View the entire returned device object.
fmt.Println(frontDoor)

return nil

Output:

true
true
{
  "device_id": "11111111-1111-1111-1111-444444444444",
  "display_name": "Lock 1",
  "workspace_id": "00000000-0000-0000-0000-000000000000",
  "connected_account_id": "11111111-1111-1111-1111-222222222222",
  "created_at": "2024-05-29T20:08:48.878Z",
  "properties": {
    "manufacturer": "akiles",
    "online": true,
    "locked": true,
    ...
  },
  "can_remotely_unlock": true,
  "can_program_online_access_codes": true,
  ...
}

---

Step 4: Control your Akiles lock

Next, you can use the Seam API to control your lock.

Each device that you connect to Seam has a specific set of capabilities. These capabilities define the Seam API actions that you can use, such as remote unlock actions, programming access codes, and so on. Seam's intuitive and granular capability flags inform your application about what features and behaviors each device supports. Notice the capability flags within the code samples in this guide.

Try out the following actions on your Akiles lock:

• Unlock your lock

• Program access codes on your lock

Unlock your lock

To unlock a door, use the Unlock Door endpoint. Specify the device that you want to unlock by including the device_id in the request body. This endpoint returns an action attempt to track the progress of the unlock operation.

Python

Code:

# Confirm that the device can remotely unlock.
# You're using a capability flag here!
if front_door.can_remotely_unlock:
  # Perform the unlock operation
  # and return an action attempt.
  action_attempt=seam.locks.unlock_door(device_id=front_door.device_id)

Output:

ActionAttempt(
  status='pending',
  action_type='UNLOCK_DOOR',
  action_attempt_id='11111111-2222-3333-4444-555555555555',
  result=None,
  error={}
)

cURL (bash)

Code:

# Confirm that the device can remotely unlock.
# You're using a capability flag here!
if  $(jq -r '.can_remotely_lock' <<< ${front_door}); then \
  # Perform the unlock operation
  # and return an action attempt.
  curl -X 'POST' \
    'https://connect.getseam.com/locks/unlock_door' \
    -H 'accept: application/json' \
    -H "Authorization: Bearer ${SEAM_API_KEY}" \
    -H 'Content-Type: application/json' \
    -d "{
      \"device_id\": \"$(jq -r '.device_id' <<< ${front_door})\"
  }";
fi

Output:

{
  "action_attempt": {
    "status":"pending",
    "action_type":"UNLOCK_DOOR",
    "action_attempt_id":"11111111-2222-3333-4444-555555555555",
    "result":null,
    "error":null
  },
  "ok":true
}

JavaScript

Code:

// Confirm that the device can remotely unlock.
// You're using a capability flag here!
if (frontDoor.can_remotely_unlock) {
  // Perform the unlock operation
  // and return an action attempt.
  const actionAttempt = await seam.locks.unlockDoor({
    device_id: frontDoor.device_id
  });
};

Output:

{
  actionAttempt: {
    status: 'success',
    action_attempt_id: '11111111-2222-3333-4444-555555555555',
    action_type: 'UNLOCK_DOOR',
    result: {},
    error: null
  }
}

Ruby

Code:

# Confirm that the device can remotely unlock.
# You're using a capability flag here!
if (front_door.can_remotely_unlock)
  # Perform the unlock operation
  # and return an action attempt.
  action_attempt = seam.locks.unlock_door(device_id: front_door.device_id)
end

Output:

<Seam::ActionAttempt:0x00438
  status="pending"
  action_type="UNLOCK_DOOR"
  action_attempt_id="11111111-2222-3333-4444-555555555555"
  result=nil>

PHP

Code:

// Confirm that the device can remotely unlock.
// You're using a capability flag here!
if ($front_door->can_remotely_unlock) {
  // Perform the unlock operation
  // and return an action attempt.
  $action_attempt = $seam->locks->unlock_door(device_id: $front_door->device_id);
}

Output:

{
  "action_attempt_id":"11111111-2222-3333-4444-555555555555",
  "action_type":"UNLOCK_DOOR",
  "error":null,
  "result":{},
  "status":"success"
}

C#

Code:

// Confirm that the device can remotely unlock.
// You're using a capability flag here!
if (frontDoor.CanRemotelyUnlock == true) {
  // Perform the unlock operation
  // and return an action attempt.
  ActionAttempt actionAttempt = seam.Locks.UnlockDoor(deviceId: frontDoor.DeviceId);
}

Output:

{
  "status": "pending",
  "action_type": "UNLOCK_DOOR",
  "action_attempt_id": "11111111-2222-3333-4444-555555555555"
}

Java

Code:

// Confirm that the device can remotely unlock.
// You're using a capability flag here!
if (frontDoor.getCanRemotelyUnlock())
{
  // Perform the unlock operation
  // and return an action attempt.
  ActionAttempt actionAttempt = seam.locks()
    .unlockDoor(LocksUnlockDoorRequest.builder()
      .deviceId(frontDoor.getDeviceId())
      .build());
}

Output:

Optional[
  {
    "action_type" : "UNLOCK_DOOR",
    "action_attempt_id" : "11111111-2222-3333-4444-555555555555",
    "status" : "pending"
  }
]

Go

Code:

// Confirm that the device can remotely unlock.
// You're using a capability flag here!
if *frontDoor.CanRemotelyUnlock {
  // Perform the unlock operation.
  actionAttempt, err := client.Locks.UnlockDoor(
    context.Background(),
    &api.LocksUnlockDoorRequest{
      DeviceId: frontDoor.DeviceId,
    },
  )

  if err != nil {
    return err
  }
}

return nil

Output:

&{pending <nil>
  {
    "status": "pending",
    "action_type": "UNLOCK_DOOR",
    "action_attempt_id": "11111111-2222-3333-4444-555555555555",
    "result": null,
    "error": null
  }
<nil>} <nil>

You can track the status of the unlock operation to confirm that the device unlocked successfully. Query the locked status of the device, retrieve the action attempt by ID, or look for a lock.unlocked event.

To query the locked status of the device:

Python

Code:

# Get the device by ID.
updated_front_door = seam.devices.get(device_id=front_door.device_id)

# Inspect the locked property to confirm
# that the unlock operation was successful.
assert updated_front_door.properties["locked"] is False # False

Output:

False

cURL (bash)

Code:

# Get the device by ID.
updated_front_door=$(
  # Use GET or POST.
  curl -X 'GET' \
    'https://connect.getseam.com/devices/get' \
    -H 'accept: application/json' \
    -H "Authorization: Bearer ${SEAM_API_KEY}" \
    -H 'Content-Type: application/json' \
    -d "{
      \"device_id\": \"$(jq -r '.device_id' <<< ${front_door})\"
  }")

# Inspect the locked property to confirm
# that the unlock operation was successful.
echo $(jq -r '"Locked (false): " + (.device.properties.locked | tostring)' <<< ${updated_front_door})

Output:

Locked (false): false

JavaScript

Code:

// Get the device by ID.
const updatedFrontDoor = await seam.devices.get({device_id: frontDoor.device_id});

// Inspect the locked property to confirm
// that the unlock operation was successful.
console.log(updatedFrontDoor.properties.locked) // false

Output:

false

Ruby

Code:

# Get the device by ID.
updated_front_door = seam.devices.get(device_id: front_door.device_id)

# Inspect the locked property to confirm
# that the unlock operation was successful.
puts updated_front_door.properties.locked # false

Output:

false

PHP

Code:

// Get the device by ID.
$updated_front_door = $seam->devices->get(device_id: $front_door->device_id);

// Inspect the locked property to confirm
// that the unlock operation was successful.
echo $updated_front_door->properties->locked ? 'true' : 'false', "\n"; // false

Output:

false

C#

Code:

// Get the device by ID.
Device updatedFrontDoor = seam.Devices.Get(
  deviceId: frontDoor.DeviceId
);

// Inspect the locked property to confirm
// that the unlock operation was successful.
Console.WriteLine(updatedFrontDoor.Properties.Locked); // false

Output:

False

Java

Code:

// Get the device by ID.
Device updatedFrontDoor = seam.devices().get(DevicesGetRequest.builder()
  .deviceId(frontDoor.getDeviceId())
  .build());

// Inspect the locked property to confirm
// that the unlock operation was successful.
System.out.println(updatedFrontDoor.getProperties().getLocked()); // false

Output:

false

Go

Code:

// Get the device by ID.
updatedFrontDoor, err := client.Devices.Get(
  context.Background(), &api.DevicesGetRequest{
    DeviceId: api.String(frontDoor.DeviceId),
  },
)

if err != nil {
  return err
}

// Inspect the locked property to confirm
// that the unlock operation was successful.
fmt.Println(*updatedFrontDoor.Properties.Locked) // false

Output:

false

---

Program access codes on your lock

You can use the Seam API to program online access codes on Akiles locks that have an integrated keypad or an Akiles Pinpad. Lock users can then enter these access codes using the keypad or Pinpad to unlock the lock.

The Seam API makes it easy to program both ongoing and time-bound online access codes.

Python

Code:

# Confirm that the device supports online access codes.
# Here's another capability flag!
if updated_front_door.can_program_online_access_codes:
  # Create an ongoing online access code.
  seam.access_codes.create(
    device_id = updated_front_door.device_id,
    name = "my ongoing code",
    code = "1234"
  )
  # Create a time-bound online access code.
  seam.access_codes.create(
    device_id = updated_front_door.device_id,
    name = "my time-bound code",
    starts_at = "2025-01-01T16:00:00Z",
    ends_at = "2025-01-22T12:00:00Z",
    code = "2345"
  )
  # List all access codes for this device.
  access_codes = seam.access_codes.list(
    device_id = updated_front_door.device_id
  )
  pprint(access_codes)

Output:

[
  AccessCode(
    access_code_id='11111111-1111-1111-1111-555555555555',
    device_id='11111111-1111-1111-1111-444444444444',
    type='ongoing',
    code='1234',
    name='my ongoing code',
    ...
  )
  AccessCode(
    access_code_id='11111111-1111-1111-1111-666666666666',
    device_id='11111111-1111-1111-1111-444444444444',
    type='time_bound',
    code='2345',
    starts_at='2025-01-01T16:00:00.000Z',
    ends_at='2025-01-22T12:00:00.000Z',
    name='my time-bound code',
    ...
  )
]

cURL (bash)

Code:

# Confirm that the device supports online access codes.
# Here's another capability flag!
if  $(jq -r '.device.can_program_online_access_codes' <<< ${updated_front_door}); then \
  # Create an ongoing online access code.
  curl -X 'POST' \
    'https://connect.getseam.com/access_codes/create' \
    -H 'accept: application/json' \
    -H "Authorization: Bearer ${SEAM_API_KEY}" \
    -H 'Content-Type: application/json' \
    -d "{
      \"device_id\": \"$(jq -r '.device.device_id' <<< ${updated_front_door})\",
      \"name\": \"my ongoing code\",
      \"code\": \"1234\"
  }"
  # Create a time-bound online access code.
  curl -X 'POST' \
    'https://connect.getseam.com/access_codes/create' \
    -H 'accept: application/json' \
    -H "Authorization: Bearer ${SEAM_API_KEY}" \
    -H 'Content-Type: application/json' \
    -d "{
      \"device_id\": \"$(jq -r '.device.device_id' <<< ${updated_front_door})\",
      \"name\": \"my time-bound code\",
      \"starts_at\": \"2025-01-01T16:00:00Z\",
      \"ends_at\": \"2025-01-22T12:00:00Z\",
      \"code\": \"2345\"
  }"
  # List all access codes for this device.
  access_codes=$(
  # Use GET or POST.
  curl -X 'GET' \
    'https://connect.getseam.com/access_codes/list' \
    -H 'accept: application/json' \
    -H "Authorization: Bearer ${SEAM_API_KEY}" \
    -H 'Content-Type: application/json' \
    -d "{
      \"device_id\": \"$(jq -r '.device.device_id' <<< ${updated_front_door})\"
  }")
  echo ${access_codes};
fi

Output:

{
  "access_codes": [
    {
      "access_code_id":"11111111-1111-1111-1111-555555555555",
      "device_id":"11111111-1111-1111-1111-444444444444",
      "name":"my ongoing code",
      "code":"1234",
      "type":"ongoing",
      ...
    },
    {
      "access_code_id": "11111111-1111-1111-1111-666666666666",
      "device_id": "11111111-1111-1111-1111-444444444444",
      "name": "my time-bound code",
      "code": "2345",
      "type": "time_bound",
      "starts_at": "2025-01-01T16:00:00.000Z",
      "ends_at": "2025-01-22T12:00:00.000Z",
      ...
    }
  ],
  "ok": true
}

JavaScript

Code:

// Confirm that the device supports online access codes.
// Here's another capability flag!
if (updatedFrontDoor.can_program_online_access_codes) {
  // Create an ongoing online access code.
  await seam.accessCodes.create({
    device_id: updatedFrontDoor.device_id,
    name: "my ongoing code",
    code: "1234"
  });
  // Create a time-bound online access code.
  await seam.accessCodes.create({
    device_id: updatedFrontDoor.device_id,
    name: "my time-bound code",
    starts_at: "2025-01-01T16:00:00Z",
    ends_at: "2025-01-22T12:00:00Z",
    code: "2345"
  });
  // List all access codes for this device.
  const accessCodes = await seam.accessCodes.list({
    device_id: updatedFrontDoor.device_id
  });
  console.log(accessCodes);
};

Output:

[
  {
    access_code_id: '11111111-1111-1111-1111-555555555555',
    device_id: '11111111-1111-1111-1111-444444444444',
    name: 'my ongoing code',
    code: '1234',
    type: 'ongoing',
    ...
  },
  {
    access_code_id: '11111111-1111-1111-1111-666666666666',
    device_id: '11111111-1111-1111-1111-444444444444',
    name: 'my time-bound code',
    code: '2345',
    type: 'time_bound',
    starts_at: '2025-01-01T16:00:00.000Z',
    ends_at: '2025-01-22T12:00:00.000Z',
    ...
  }
]

Ruby

Code:

# Confirm that the device supports online access codes.
# Here's another capability flag!
if (updated_front_door.can_program_online_access_codes)
  # Create an ongoing online access code.
  seam.access_codes.create(
    device_id: updated_front_door.device_id,
    name: "my ongoing code",
    code: "1234"
  )
  # Create a time-bound online access code.
  seam.access_codes.create(
    device_id: updated_front_door.device_id,
    name: "my time-bound code",
    starts_at: "2025-01-01T16:00:00Z",
    ends_at: "2025-01-22T12:00:00Z",
    code: "2345"
  )
  # List all access codes for this device.
  access_codes = seam.access_codes.list(
    device_id: updated_front_door.device_id
  )
  puts access_codes.inspect
end

Output:

[
  <Seam::AccessCode:0x00460
    access_code_id="11111111-1111-1111-1111-555555555555"
    device_id="11111111-1111-1111-1111-444444444444"
    name="my ongoing code"
    code="1234"
    type="ongoing"
    ...
  >,
  <Seam::AccessCode:0x00438
    access_code_id="11111111-1111-1111-1111-666666666666"
    device_id="11111111-1111-1111-1111-444444444444"
    name="my time-bound code"
    code="2345"
    type="time_bound"
    starts_at=2025-01-01 16:00:00 UTC
    ends_at=2025-01-22 12:00:00 UTC
    ...
  >
]

PHP

Code:

// Confirm that the device supports online access codes.
// Here's another capability flag!
if ($updated_front_door->can_program_online_access_codes) {
  // Create an ongoing online access code.
  $seam->access_codes->create(
    device_id: $updated_front_door->device_id,
    name: "my ongoing code",
    code: "1234"
  );
  // Create a time-bound online access code.
  $seam->access_codes->create(
    device_id: $updated_front_door->device_id,
    name: "my time-bound code",
    starts_at:  "2025-01-01T16:00:00Z",
    ends_at: "2025-01-22T12:00:00Z",
    code: "2345"
  );
  // List all access codes for this device.
  $access_codes = $seam->access_codes->list(
    device_id: $updated_front_door->device_id
  );
  echo json_encode($access_codes, JSON_PRETTY_PRINT);
}

Output:

[
  {
    "access_code_id": "11111111-1111-1111-1111-555555555555",
    "device_id": "11111111-1111-1111-1111-444444444444",
    "name": "my ongoing code",
    "type": "ongoing",
    "code": "1234",
    ...
  },
  {
    "access_code_id": "11111111-1111-1111-1111-666666666666",
    "device_id": "11111111-1111-1111-1111-444444444444",
    "name": "my time-bound code",
    "type": "time_bound",
    "starts_at": "2025-01-01T16:00:00.000Z",
    "ends_at": "2025-01-22T12:00:00.000Z",
    "code": "2345",
  }
]

C#

Code:

// Confirm that the device supports online access codes.
// Here's another capability flag!
if (updatedFrontDoor.CanProgramOnlineAccessCodes == true) {
  // Create an ongoing online access code.
  seam.AccessCodes.Create(
    deviceId: updatedFrontDoor.DeviceId,
    name: "my ongoing code",
    code: "1234"
  );
  // Create a time-bound online access code.
  seam.AccessCodes.Create(
    deviceId: updatedFrontDoor.DeviceId,
    name: "my time-bound code",
    startsAt: "2025-01-01T16:00:00Z",
    endsAt: "2025-01-22T12:00:00Z",
    code: "2345"
  );
  // List all access codes for this device.
  var accessCodes = seam.AccessCodes.List(
    deviceId: updatedFrontDoor.DeviceId
  );
  foreach (var accessCode in accessCodes)
  {
    Console.WriteLine(accessCode);
  }
}

Output:

{
  "type": "ongoing",
  "access_code_id": "11111111-1111-1111-1111-555555555555",
  "device_id": "11111111-1111-1111-1111-444444444444",
  "name": "my ongoing code",
  "code": "1234",
  ...
}
{
  "type": "time_bound",
  "access_code_id": "11111111-1111-1111-1111-666666666666",
  "device_id": "11111111-1111-1111-1111-444444444444",
  "name": "my time-bound code",
  "starts_at": "2025-01-01T16:00:00Z",
  "ends_at": "2025-01-22T12:00:00Z",
  "code": "2345",
  ...
}

Java

Code:

// Confirm that the device supports online access codes.
// Here's another capability flag!
if (updatedFrontDoor.getCanProgramOnlineAccessCodes())
{
  // Create an ongoing online access code.
  seam.accessCodes()
    .create(AccessCodesCreateRequest.builder()
      .deviceId(updatedFrontDoor.getDeviceId())
      .name("my ongoing code")
      .code("1234")
      .build());
  // Create a time-bound online access code.
  seam.accessCodes()
    .create(AccessCodesCreateRequest.builder()
      .deviceId(updatedFrontDoor.getDeviceId())
      .name("my time-bound code")
      .startsAt("2025-01-01T16:00:00Z")
      .endsAt("2025-01-22T12:00:00Z")
      .code("2345")
      .build());
  // List all access codes for this device.
  var accessCodes = seam.accessCodes()
    .list(AccessCodesListRequest.builder()
      .deviceId(updatedFrontDoor.getDeviceId())
      .build());
  System.out.println(accessCodes);
}

Output:

[
  {
    "access_code_id" : "11111111-1111-1111-1111-555555555555",
    "device_id" : "11111111-1111-1111-1111-444444444444",
    "name" : "my ongoing code",
    "code" : "1234",
    "type" : "ongoing",
    ...
  },
  {
    "access_code_id" : "11111111-1111-1111-1111-666666666666",
    "device_id" : "11111111-1111-1111-1111-444444444444",
    "name" : "my time-bound code",
    "code" : "2345",
    "type" : "time_bound",
    "starts_at" : "2025-01-01T16:00:00Z",
    "ends_at" : "2025-01-22T12:00:00Z",
    ...
  }
]

Go

Code:

// Confirm that the device supports online access codes.
// Here's another capability flag!
if *updatedFrontDoor.CanProgramOnlineAccessCodes {
  // Create an ongoing online access code.
  client.AccessCodes.Create(
    context.Background(),
    &api.AccessCodesCreateRequest{
      DeviceId: updatedFrontDoor.DeviceId,
      Name: api.String("my ongoing code"),
      Code: api.String("1234"),
    },
  )
  // Create a time-bound online access code.
  client.AccessCodes.Create(
    context.Background(),
    &api.AccessCodesCreateRequest{
      DeviceId: updatedFrontDoor.DeviceId,
      Name: api.String("my time-bound code"),
      StartsAt: api.String("2025-01-01T16:00:00Z"),
      EndsAt: api.String("2025-01-22T12:00:00Z"),
      Code: api.String("2345"),
    },
  )
  // List all access codes for this device.
  accessCodes, err := client.AccessCodes.List(
    context.Background(),
    &api.AccessCodesListRequest{
      DeviceId: updatedFrontDoor.DeviceId,
    },
  )
  fmt.Println(accessCodes)

  if err != nil {
      return err
  }
}

return nil

Output:

[
  {
    "access_code_id": "11111111-1111-1111-1111-555555555555",
    "device_id": "11111111-1111-1111-1111-444444444444",
    "name": "my ongoing code",
    "code": "1234",
    "type": "ongoing",
    ...
  }
  {
    "access_code_id": "11111111-1111-1111-1111-666666666666",
    "device_id": "11111111-1111-1111-1111-444444444444",
    "name": "my time-bound code",
    "code": "2345",
    "type": "time_bound",
    "starts_at": "2025-01-01T16:00:00.000Z",
    "ends_at": "2025-01-22T12:00:00.000Z",
    ...
  }
]

---

Step 5: Connect a real Akiles lock

Now that you have learned the basics of using the Seam API, you can connect and control a real Akiles device. To do so, make sure to switch to a non-sandbox workspace and API key.

For more details about setting up your real Akiles lock, see the Akiles locks integration guide.

---

Step 6: Build your application!

Seam makes it easy to develop your application. In addition to the robust Seam API and the wide variety of programming languages that our SDKs support, we also provide a suite of Seam Components. These prebuilt UI components help you to build your device management flow.

Seam Components make it easy to develop your application!

For example, you can use the Device Table Seam Component to display a list of devices and to identify all devices with issues. You can use the Device Details Seam Component to display a device's properties, settings, and issues, as well as to enable your users to perform actions based on each device's capabilities. The Access Code Details Seam Component provides a similar display and actions for access codes.

Seam Components use a responsive design to fit seamlessly on any screen size. They also provide device debugging flows to help your users.

To learn about all the Seam Components that we provide, see Seam Components.

---

Next steps

Now that you've completed this getting started guide for Akiles devices, you can learn more about what you can do with the Seam API.

• Explore See the other devices and system integrations that Seam supports.

• Learn Read about Seam concepts and the device and system capabilities that Seam supports.

• Use Seam Components Find out about Seam Components, which are prebuilt UI components for building your device management flow.

• Use webhooks Learn how to use webhooks as an efficient way to receive device events.

• Find out more Explore the other types of devices and systems that you can control with Seam, including access control systems, thermostats, and noise sensors.

• Develop for mobile access Learn about Seam's mobile access solution.

If you have any questions or want to report an issue, email us at [e-mail].

---

Quick links

Get an API Key (free)

Sign up for the Seam Console and get your API keys. →

Contact Sales

Got a project or a specific question? Contact our team to get answers. →