Resuming a Thermostat Schedule

Use /thermostats/activate_weekly_program to release a hold set by Seam and resume the schedule already configured on the thermostat. For example, after temporarily changing a set point for a demand-response event, you can return the thermostat to the schedule that the user configured in the manufacturer’s app. This native weekly program is the schedule stored on the device. Resuming it does not create or replace its daily periods or temperature settings. You only need the thermostat’s device_id.

To create or change a weekly program through Seam, see Creating and Managing Thermostat Programs. Use activate_weekly_program when you want to resume the program already on the device.

Before You Begin

Connect the thermostat to Seam and make sure that the desired schedule is configured on the device or in the manufacturer’s app. Resuming a native weekly program is supported through the Honeywell Resideo, ecobee, and Sensi integrations. Check the device’s top-level can_activate_weekly_program capability flag before making the request. This flag must be present and true. Google Nest and SmartThings thermostats do not support this operation through Seam. Set SEAM_API_KEY in your environment and replace the sample device ID. Reuse the client initialized in the first example for the following steps. Java and Go snippets belong inside your application method or function, with the imports at the top of the file.

The JavaScript examples use @seamapi/http 2.35.0 or later. The native Ruby and PHP examples require seam 2.160.0 or later and seamapi/seam 4.15.0 or later, respectively. Python, C#, and Go use their SDK’s request interface to support the new endpoint and response fields. Java uses a Java 11+ HTTP fallback because its released SDK does not expose this operation. The Seam CLI examples refresh its API schema with --update.

Retrieve the device using /devices/get:

import { SeamHttp } from '@seamapi/http'

const seam = new SeamHttp()
const device = await seam.devices.get({
  device_id: '11111111-1111-1111-2222-444444444444',
})

if (device.can_activate_weekly_program !== true) {
  throw new Error('This thermostat cannot resume its native weekly program.')
}

curl --request POST \
  --url 'https://connect.getseam.com/devices/get' \
  --header "Authorization: Bearer ${SEAM_API_KEY}" \
  --header 'Content-Type: application/json' \
  --data '{"device_id": "11111111-1111-1111-2222-444444444444"}'

from seam import Seam

seam = Seam()
# Use the SDK's request client to preserve the new capability field.
device = seam.client.post(
    "/devices/get",
    json={"device_id": "11111111-1111-1111-2222-444444444444"},
)["device"]

if device.get("can_activate_weekly_program") is not True:
    raise ValueError("This thermostat cannot resume its native weekly program.")

require "seam"

seam = Seam.new
device = seam.devices.get(
  device_id: "11111111-1111-1111-2222-444444444444"
)

unless device.can_activate_weekly_program == true
  raise "This thermostat cannot resume its native weekly program."
end

require 'vendor/autoload.php';

$seam = new Seam\Seam();
$device = $seam->devices->get(
    device_id: "11111111-1111-1111-2222-444444444444"
);

if ($device->can_activate_weekly_program !== true) {
    throw new RuntimeException("This thermostat cannot resume its native weekly program.");
}

using System;
using Seam.Client;
using Newtonsoft.Json.Linq;

var seam = new SeamClient(Environment.GetEnvironmentVariable("SEAM_API_KEY"));
var deviceResponse = await seam.PostAsync<JObject>(
    "/devices/get",
    new RequestOptions {
        Data = new { device_id = "11111111-1111-1111-2222-444444444444" }
    }
);
var device = deviceResponse.EnsureData("/devices/get")["device"]!;

if ((bool?)device["can_activate_weekly_program"] != true) {
    throw new InvalidOperationException("This thermostat cannot resume its native weekly program.");
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

// Java 11+ HTTP fallback. Run these statements in a method that
// declares throws IOException, InterruptedException (or catches them).
HttpClient client = HttpClient.newBuilder()
    .connectTimeout(Duration.ofSeconds(30))
    .build();
HttpRequest deviceRequest = HttpRequest.newBuilder()
    .uri(URI.create("https://connect.getseam.com/devices/get"))
    .timeout(Duration.ofSeconds(30))
    .header("Authorization", "Bearer " + System.getenv("SEAM_API_KEY"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(
        "{\"device_id\":\"11111111-1111-1111-2222-444444444444\"}"
    ))
    .build();
HttpResponse<String> deviceResponse = client.send(
    deviceRequest, HttpResponse.BodyHandlers.ofString()
);
if (deviceResponse.statusCode() < 200 || deviceResponse.statusCode() >= 300) {
    throw new IllegalStateException(deviceResponse.body());
}
// Check device.can_activate_weekly_program in this JSON before continuing.
System.out.println(deviceResponse.body());

import (
    "context"
    "fmt"
    "net/http"
    "os"
    "time"

    "github.com/seamapi/go/core"
)

caller := core.NewCaller(&core.CallerParams{
    Client: &http.Client{Timeout: 30 * time.Second},
    MaxAttempts: 1,
})
headers := http.Header{
    "Authorization": []string{"Bearer " + os.Getenv("SEAM_API_KEY")},
}
deviceID := "11111111-1111-1111-2222-444444444444"
var deviceResponse map[string]interface{}
err := caller.Call(context.Background(), &core.CallParams{
    URL: "https://connect.getseam.com/devices/get",
    Method: http.MethodPost,
    Headers: headers,
    Request: map[string]string{"device_id": deviceID},
    Response: &deviceResponse,
})
if err != nil {
    panic(err)
}
device := deviceResponse["device"].(map[string]interface{})
if device["can_activate_weekly_program"] != true {
    panic("This thermostat cannot resume its native weekly program.")
}

SEAM_CLI_TOKEN="$SEAM_API_KEY" seam devices get \
  --device-id '11111111-1111-1111-2222-444444444444' \
  --non-interactive --json --update

For cURL, Java, and Seam CLI, inspect the response and confirm that device.can_activate_weekly_program is true before continuing.

Resume the Native Weekly Program

Call /thermostats/activate_weekly_program with the thermostat’s device_id. No program ID, set points, or end time are required.

const actionAttempt = await seam.thermostats.activateWeeklyProgram(
  { device_id: device.device_id },
  { waitForActionAttempt: false },
)

curl --request POST \
  --url 'https://connect.getseam.com/thermostats/activate_weekly_program' \
  --header "Authorization: Bearer ${SEAM_API_KEY}" \
  --header 'Content-Type: application/json' \
  --data '{"device_id": "11111111-1111-1111-2222-444444444444"}'

# Request fallback for SDK versions without the generated method.
action_attempt = seam.client.post(
    "/thermostats/activate_weekly_program",
    json={"device_id": device["device_id"]},
)["action_attempt"]

action_attempt = seam.thermostats.activate_weekly_program(
  device_id: device.device_id,
  wait_for_action_attempt: false
)

$actionAttempt = $seam->thermostats->activate_weekly_program(
    device_id: $device->device_id,
    wait_for_action_attempt: false
);

// Use the SDK's request client until its generated method is available.
var activationResponse = await seam.PostAsync<JObject>(
    "/thermostats/activate_weekly_program",
    new RequestOptions {
        Data = new { device_id = (string)device["device_id"]! }
    }
);
var actionAttempt = activationResponse.EnsureData(
    "/thermostats/activate_weekly_program"
)["action_attempt"]!;

HttpRequest activationRequest = HttpRequest.newBuilder()
    .uri(URI.create("https://connect.getseam.com/thermostats/activate_weekly_program"))
    .timeout(Duration.ofSeconds(30))
    .header("Authorization", "Bearer " + System.getenv("SEAM_API_KEY"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(
        "{\"device_id\":\"11111111-1111-1111-2222-444444444444\"}"
    ))
    .build();
HttpResponse<String> activationResponse = client.send(
    activationRequest, HttpResponse.BodyHandlers.ofString()
);
if (activationResponse.statusCode() < 200 || activationResponse.statusCode() >= 300) {
    throw new IllegalStateException(activationResponse.body());
}
System.out.println(activationResponse.body());

var activationResponse map[string]interface{}
err = caller.Call(context.Background(), &core.CallParams{
    URL: "https://connect.getseam.com/thermostats/activate_weekly_program",
    Method: http.MethodPost,
    Headers: headers,
    Request: map[string]string{"device_id": deviceID},
    Response: &activationResponse,
})
if err != nil {
    panic(err)
}
actionAttempt := activationResponse["action_attempt"].(map[string]interface{})
actionAttemptID := actionAttempt["action_attempt_id"].(string)
fmt.Println(actionAttemptID)

SEAM_CLI_TOKEN="$SEAM_API_KEY" seam thermostats activate-weekly-program \
  --device-id '11111111-1111-1111-2222-444444444444' \
  --non-interactive --json --update

The HTTP response includes an action attempt with action_type set to ACTIVATE_WEEKLY_PROGRAM. The following example shows a pending response, with other response fields omitted:

{
  "action_attempt": {
    "action_attempt_id": "22222222-2222-2222-3333-555555555555",
    "action_type": "ACTIVATE_WEEKLY_PROGRAM",
    "status": "pending",
    "result": null,
    "error": null
  }
}

Confirm Completion

These examples return the action attempt without waiting for completion. An accepted HTTP request does not mean that the thermostat has finished resuming its schedule. Poll /action_attempts/get using the returned action_attempt_id until status is success or error. The following examples retrieve its current status once; repeat this check while it is pending. For cURL, Java, and Seam CLI, replace the sample action attempt ID with the ID returned by your activation request.

const latestActionAttempt = await seam.actionAttempts.get(
  { action_attempt_id: actionAttempt.action_attempt_id },
  { waitForActionAttempt: false },
)
console.log(latestActionAttempt.status)

curl --request POST \
  --url 'https://connect.getseam.com/action_attempts/get' \
  --header "Authorization: Bearer ${SEAM_API_KEY}" \
  --header 'Content-Type: application/json' \
  --data '{"action_attempt_id": "22222222-2222-2222-3333-555555555555"}'

latest_action_attempt = seam.client.post(
    "/action_attempts/get",
    json={"action_attempt_id": action_attempt["action_attempt_id"]},
)["action_attempt"]
print(latest_action_attempt["status"])

latest_action_attempt = seam.action_attempts.get(
  action_attempt_id: action_attempt.action_attempt_id,
  wait_for_action_attempt: false
)
puts latest_action_attempt.status

$latestActionAttempt = $seam->action_attempts->get(
    action_attempt_id: $actionAttempt->action_attempt_id,
    wait_for_action_attempt: false
);
echo $latestActionAttempt->status;

var actionAttemptResponse = await seam.PostAsync<JObject>(
    "/action_attempts/get",
    new RequestOptions {
        Data = new { action_attempt_id = (string)actionAttempt["action_attempt_id"]! }
    }
);
var latestActionAttempt = actionAttemptResponse.EnsureData(
    "/action_attempts/get"
)["action_attempt"]!;
Console.WriteLine(latestActionAttempt["status"]);

// Replace the sample ID with action_attempt.action_attempt_id from the response.
HttpRequest actionAttemptRequest = HttpRequest.newBuilder()
    .uri(URI.create("https://connect.getseam.com/action_attempts/get"))
    .timeout(Duration.ofSeconds(30))
    .header("Authorization", "Bearer " + System.getenv("SEAM_API_KEY"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(
        "{\"action_attempt_id\":\"22222222-2222-2222-3333-555555555555\"}"
    ))
    .build();
HttpResponse<String> actionAttemptResponse = client.send(
    actionAttemptRequest, HttpResponse.BodyHandlers.ofString()
);
if (actionAttemptResponse.statusCode() < 200 || actionAttemptResponse.statusCode() >= 300) {
    throw new IllegalStateException(actionAttemptResponse.body());
}
System.out.println(actionAttemptResponse.body());

var actionResponse map[string]interface{}
err = caller.Call(context.Background(), &core.CallParams{
    URL: "https://connect.getseam.com/action_attempts/get",
    Method: http.MethodPost,
    Headers: headers,
    Request: map[string]string{"action_attempt_id": actionAttemptID},
    Response: &actionResponse,
})
if err != nil {
    panic(err)
}
latestActionAttempt := actionResponse["action_attempt"].(map[string]interface{})
fmt.Println(latestActionAttempt["status"])

SEAM_CLI_TOKEN="$SEAM_API_KEY" seam action-attempts get \
  --action-attempt-id '22222222-2222-2222-3333-555555555555' \
  --non-interactive --json --update

If the status is error, inspect the action attempt’s error for details.

On ecobee thermostats, vacation events and mandatory demand-response events are not canceled by this operation.

What Happens After the Schedule Resumes?

Seam releases its hold and lets the thermostat follow its native weekly program. Seam does not change the HVAC mode as part of this operation. For example, resuming the program while the thermostat is off does not turn heating or cooling on. The thermostat resumes the program currently stored on it. If you previously replaced that program using /thermostats/update_weekly_program, this operation does not restore the older program. While the native program is active, Seam does not reapply a fallback preset or write climate settings when a previously active Seam schedule ends. Seam takes control again when any of the following occurs:

You activate a climate preset.
You make a direct HVAC setting change, such as calling heat, cool, heat_cool, off, or set_hvac_mode.
A scheduled climate preset reaches its activation time.

Resuming the native program does not delete your Seam thermostat schedules. If you want the thermostat to keep following its own program, review upcoming Seam schedules and delete any schedules that should no longer activate. For a temporary override workflow, apply the desired climate settings at the start of the event, then call activate_weekly_program when the event ends. Schedule that final API call in your application; this endpoint does not accept a future activation time.

Getting Started

Use Cases

Core Concepts

Capability Guides

UI Components

Developer Tools

Industry Guides

Device Manufacturer Guidance

Low-Level APIs

Resuming a Thermostat Schedule

Before You Begin

Resume the Native Weekly Program

Confirm Completion

What Happens After the Schedule Resumes?

​Before You Begin

​Resume the Native Weekly Program

​Confirm Completion

​What Happens After the Schedule Resumes?

Before You Begin

Resume the Native Weekly Program

Confirm Completion

What Happens After the Schedule Resumes?