Sunsa Wand for Mini Blinds and Vertical Blinds

As a renter, I’ve always wanted a way to automate existing blinds in a way that wouldn’t raise the eyebrow of my landlord. The new Sunsa Wand is perfect for that as it just replaces the existing wand in a way that’s not permanent. It takes AA batteries and connects to wifi for receiving commands to either twist the blinds open or closed.

Sadly, as of this writing, they are only able to be controlled by the mobile app, or a basic cloud API. However, over in the Hubitat forums, Sunsa has committed to providing a Local API (eventually).

I’ve had two of these devices controlling my living room blinds for months and they work great, but I really need to get them into Home Assistant so that I can do things like open them 30 minutes after sunrise and close them 30 minutes before sunset.

I don’t think it’s worth putting any effort into a full “sunsa-wand-cloud” integration when local control possibilities are on the way, so I’ve opted to instead use REST commands to their cloud API for now. I’ll reply to this post with more detail.

6 Likes

Integration with the Sunsa Wand Cloud API using REST Commands

In the Sunsa mobile app, you can turn on cloud API access and copy your secret API key, but for some reason, the app doesn’t give you access to your numeric User ID which is also necessary when calling the API. If you’re reading this and your User ID still doesn’t show up in the app, you will need to send them a message from the email address on your account to ask them for it. It can look something like this:

To: [email protected]
Subject: What's my User ID?

Hello,

Can I please have the numeric user ID that goes with my API key?

I'm trying to use Home Assistant for controlling my blinds and until a local control API is available, I'm following the instructions here: https://community.home-assistant.io/t/sunsa-wand-for-mini-blinds-and-vertical-blinds/370564

Thank you!

Next, you will need to find the Device ID associated with your specific wand(s). That can easily be found on the details page for your wand in the app.

Once you have your User ID, Device ID, and API key, you will use those three things to craft the API URL for each wand like this:

https://sunsahomes.com/api/public/123/devices/456?publicApiKey=123456789-1234-12345-1234-123456789abcd

Replace 123 with your User ID, and 456 with your device ID. The string at the end is obviously your API key

Since your API key needs to remain a secret, the URL(s) will need to be stored in your secrets file. I use the names “north” and “east” on my wands to indicate which window they’re attached to. Example secrets.yaml:

sunsa_api_north: https://sunsahomes.com/api/public/123/devices/456?publicApiKey=123456789-1234-12345-1234-123456789abcd
sunsa_api_east: https://sunsahomes.com/api/public/123/devices/789?publicApiKey=123456789-1234-12345-1234-123456789abcd

Next, create REST commands in the Home Assistant config file for each wand. From there, a template cover can be created for each wand that calls the REST command service each time open or close is called. Here’s my configuration.yaml:

rest_command:
  sunsa_north:
    url: !secret sunsa_api_north
    method: PUT
    headers:
      accept: 'application/json'
    payload: '{"Position": {{ position }}}'
    content_type: 'application/json'
  sunsa_east:
    url: !secret sunsa_api_east
    method: PUT
    headers:
      accept: 'application/json'
    payload: '{"Position": {{ position }}}'
    content_type: 'application/json'


cover:
  - platform: template
    covers:
      north_blinds:
        unique_id: living_room_blinds_north
        friendly_name: North Blinds
        device_class: blind
        open_cover:
          service: rest_command.sunsa_north
          data:
            position: 0
        close_cover:
          service: rest_command.sunsa_north
          data:
            position: -100
      east_blinds:
        unique_id: living_room_blinds_east
        friendly_name: East Blinds
        device_class: blind
        open_cover:
          service: rest_command.sunsa_east
          data:
            position: 0
        close_cover:
          service: rest_command.sunsa_east
          data:
            position: -100

Note that the position in my close commands are set to “-100” because I want the blinds to close up instead of down. According to the Sunsa Wand API “0” is “open” (which is the opposite of what Home Assistant uses for cover position), “100” is “closed down”, and “-100” is “closed up”. You can customize that value as desired.

Once HA Core is restarted, your new cover(s) should be available.

As a bonus, here’s my automation for closing the blinds 30 minutes before sunset every day:

alias: 'Living Room Blinds: close 30min before sunset'
mode: single
trigger:
  - platform: sun
    event: sunset
    offset: '-0:30:00'
action:
  - service: cover.close_cover
    target:
      entity_id:
        - cover.north_blinds
        - cover.east_blinds

If you found this post helpful, give it a like so that I know it was worth writing. :wink:

15 Likes

I have 8 Sunsa blinds and thanks to your post I was able to automate all my blinds in HA. I’m a HA noobie and it was very easy to follow your instructions. Thank you very much.

2 Likes

This is great – thank you so much! It works like a charm.

Would it be easy(ish) to modify these to allow manual control between positions -100 and 100? In direct sun, we sometimes like to turn them halfway down, etc.

Absolutely! Any button/automation/script/etc that can call a service can set the blinds to a specific position. It may take some experimentation to figure out what value to use, but you just need to replace the data “position” value with that number when calling the service:

          service: rest_command.sunsa_east
          data:
            position: 45

Unfortunately, it’s not as easy to setup Home Assistant’s built-in cover.set_cover_position service for this because it doesn’t understand the concept of a cover that can close in more than one direction. Once there’s a real integration instead of just this hack, it should be much easier. :slight_smile:

I was able to utilize the cover.set_cover_position by changing the “Default Smart Home Direction” from Down to Up within the Sunsa App for every Sunsa wand that I have, and then was able to use the cover.set_cover_position to a positive integer position value (70, in my case), which closed the blind in the Up position 70%.

Additionally, the Api for Sunsa will only permit position value multiples of 10, so the 45 example would be invalid.

Huge thank you to @PanicRide for the OP - it was so helpful in getting me set up! All my automations, scenes, and integration with Google Assistant are now all working perfectly using your write-up as the backbone.

Thank you, @PanicRide!

@mholmesio, did you have to change anything in configuration.yaml to make that work? Looking at the attributes of my Sunsa covers, “position” isn’t there.

Ideally, I’d love to get a slider in Lovelace for each blind, but so far it isn’t working.

Thanks again for the help.

You can do that with a number helper and an automation that calls the rest command whenever its value changes.

The number helper should range from -100 to 100 with a step of 10. It looks like this:

The automation looks like this:

alias: Blinds Slider North
trigger:
  - platform: state
    entity_id: input_number.north_blinds_slider
action:
  - service: rest_command.sunsa_north
    data:
      position: '{{ trigger.to_state.state | int }}'
mode: single

The number helper entity will show up as a slider :slight_smile:

Thank you, that works!

Can an automation be setup to update the number helper/slider if the blinds are adjusted some other way? For example, I have automations that simply open and close the blinds. The wands also have a double-tap feature to open/close them, and it’s possible to also adjust them in the Sunsa app. Ideally, the slider in my HA would update to show the current position.

Sadly, there’s no easy way to do that with changes that happen outside of Home Assistant until there’s a real integration running real code instead of these temporary hacks.

The major reasons for that are:

  • The format of the Sunsa API doesn’t allow for reading values using the REST integration since they provide the wand information in an unordered JSON list instead of using a JSON dict. Custom code will need to be used to read those instead.
  • The position numbers Sunsa provides are -100 through 100 with 0 being fully open. Those need to be translated to the way Home Assistant expects them which are 0 for fully closed and 100 for fully open.
  • Home Assistant doesn’t seem to understand the concept of blinds that can open in more than one direction. Therefore, even with a full integration, some hackyness may still exist. Someone with more knowledge will have to chime in to confirm, but I believe these may be the only options:
    • Only allow HA to close the blinds in one direction and leave that direction up to your “Smart Home Close Direction” setting in the Sunsa app.
      -or-
    • Expose a toggle in HA for each wand that allows you to set the close direction. If you have it set to close up, but something else closes them down, the integration would need to flip that toggle and just continue to report it’s close position using the HA standard 0-100.

For your open/close automations in Home Assistant, you can always modify your template covers to update the value of your number helpers instead of calling the rest commands directly. That way, your number helpers will call the rest commands and your sliders will be updated with the new value when open or close is called on the blinds from any of your automations. :wink:

Thank you so much for the thorough explanation – that makes sense.

I’ve changed my automations to update the number helpers, and it works great. I just need to tell my family members to use HA as much as possible for the blinds. :slightly_smiling_face:

Just started with home assistant and found this. Thank you so much for figuring this out and sharing it.

I was wondering if there was a to get the temp and battery pulled into home assistant?

The temperature sensor isn’t exposed in their public API, so even if there was a cloud integration, that wouldn’t be available. From what I’ve seen of it in the app, it doesn’t seem very accurate anyway. :person_shrugging:

This is my implementation of using Sunsa cover. Implemented support for curtain opening position. You can specify by what percentage the curtain should open. And of course the automation of closing and opening 30 minutes before and 30 minutes after Sunset and Sunrise.

The battery percentage is also displayed.

sensors part sensor.yaml
! Do not forget to change Your_Personal_Token_from_Sunsa_app and Your_User_ID !

- platform: rest
  resource: 'https://sunsahomes.com/api/public/Your_User_ID/devices?publicApiKey=Your_Personal_Token_from_Sunsa_app'
  name: sunsa_api
  json_attributes:
    - devices
  value_template: "OK"

- platform: template
  sensors:
    sunsa_1_battery_percentage:
      friendly_name: 'Sunsa 1 battery percentage'
      device_class: battery
      value_template: "{{ state_attr('sensor.sunsa_api', 'devices')[0]['batteryPercentage'] }}"
      unit_of_measurement: '%'
      icon_template: mdi:battery-high

    sunsa_1_position:
      friendly_name: 'Sunsa 1 position'
      value_template: "{{ state_attr('sensor.sunsa_api', 'devices')[0]['position'] }}"
      unit_of_measurement: '%'
      icon_template: mdi:blinds-horizontal

    sunsa_1_is_connected:
      friendly_name: 'Sunsa 1 connected'
      value_template: "{{ state_attr('sensor.sunsa_api', 'devices')[0]['isConnected'] }}"
      icon_template: mdi:connection

Cover part (put it in configuration.yaml)
! Do not forget to change Your_Personal_Token_from_Sunsa_app and Your_Device_ID !

rest_command:
  sunsa_1:
    url: https://sunsahomes.com/api/public/Your_User_ID/devices/Your_Device_ID?publicApiKey=Your_Personal_Token_from_Sunsa_app
    method: put
    content_type: 'application/json; charset=utf-8'
    payload: '{"Position": {{ position }} }'

cover:
  - platform: template
    covers:
      sunsa_1:
        device_class: blind
        friendly_name: "Sunsa 1"
        set_cover_position:
          service: rest_command.sunsa_1
          data:
            position: "-{{position}}"
        open_cover:
          service: rest_command.sunsa_1
          data:
            position: 0
        close_cover:
          service: rest_command.sunsa_1
          data:
            position: -100
        position_template: "{{ 100- (state_attr('sensor.sunsa_api', 'devices')[0]['position'] * -1) }}"

The main problem I solved was matching the positions of Home Assistant and Sunsa. For example, Home Assistant’s curtains are closed at position 0, while Sunsa’s curtains are closed at position -100. In addition, Home Assistant uses only positive values for the position of curtains in the range from 0 to 100.
All this is solved in my example. In UI Home Assistant, you can correctly give a command to open/close the curtains by a certain percentage.

P.s. Your_User_ID you can find in Sunsa app
Your_Device_ID you can find by open next URL in browser:
! Do not forget to change Your_Personal_Token_from_Sunsa_app and Your_User_ID !

https://sunsahomes.com/api/public/Your_User_ID/devices?publicApiKey=Your_Personal_Token_from_Sunsa_app

4 Likes

I wanted to share what I’ve done in case it helps anyone. Huge thanks to @PanicRide and @wida specifically, whose code I used significantly to achieve this.

I have 12 wands in place, so I wanted to make it repeatable (should be able to do simple find and replace of my naming format to meet your needs), so devices are clearly labeled and easily searchable. I am only putting examples of a couple wands instead of all 12 in the interest of brevity. Duplicate and modify as needed to add more.
My goals were the following:

  • User friendly cards (partner acceptance factor)
  • Slider to control position
  • Simple close up/open/close down buttons (using the custom cover settings)
  • Battery percentage
  • Have all changes update on the Sunsa app and in HA every time they’re changed in either place.
  • Have all blinds close 20 minutes before sunset
  • Have blinds automatically close, if the wand gets up to 88°F (this one is not yet available, as the API for temp is not yet exposed. I will add this one once it does).

Here is a screenshot of a couple cards (I have HACS integrated and Vertical Stack In Card in place - GitHub - ofekashery/vertical-stack-in-card: 📐 Home Assistant Card: Similar to vertical/horizontal-stack, but removes card borders):

Now, onto the code.

  1. First, create the API calls in the secrets.yaml
    Note - Modify Your_Access_Token, Your_API_ID and Your_Device_ID to reflect your specific device. These can be found in the Sunsa app
# sunsa main api
api_sunsa_main: https://sunsahomes.com/api/public/Your_API_ID/devices?publicApiKey=Your_Access_Token
# sunsa familyroom_e_blinds api
api_sunsa_familyroom_e_blinds: https://sunsahomes.com/api/public/Your_API_ID/devices/Your_Device_ID?publicApiKey=Your_Access_Token
# sunsa foyer_w_blinds api
api_sunsa_foyer_w_blinds: https://sunsahomes.com/api/public/Your_API_ID/devices/Your_Device_ID?publicApiKey=Your_Access_Token
  1. Next, update your customize.yaml file.
    NOTE - This is needed, so that the buttons are always available on the cover entity and don’t grey out based on current position. This is important for use with the slider.
## Covers
cover.familyroom_e_blinds:
  assumed_state: true

cover.foyer_w_blinds:
  assumed_state: true
  1. Next, call customize.yaml, create the input_number, rest_command, and cover sections in your configurations.yaml
    Note - I chose to put it all here, if you use a separate sensors.yaml or other call, make sure to adjust. Also, I commented it in the code, but make sure to modify the [0] device list where needed.
# Configure a default setup of Home Assistant (frontend, api, etc)
default_config:
# includes
homeassistant:
  customize: !include customize.yaml
group: !include groups.yaml
automation: !include automations.yaml
script: !include scripts.yaml
scene: !include scenes.yaml

## Input Numbers
input_number:
# Blinds
  familyroom_e_blinds_slider:
    name: Family Room - E Blinds Slider
    min: -100
    max: 100
    step: 10
  foyer_w_blinds_slider:
    name: Foyer - W Blinds Slider
    min: -100
    max: 100
    step: 10

## Rest Commands
rest_command:
  sunsa_familyroom_e_blinds:
    url: !secret api_sunsa_familyroom_e_blinds
    method: PUT
    headers:
      accept: 'application/json'
    payload: '{"Position": {{ position }}}'
    content_type: 'application/json'
  sunsa_foyer_w_blinds:
    url: !secret api_sunsa_foyer_w_blinds 
    method: PUT
    headers:
      accept: 'application/json'
    payload: '{"Position": {{ position }}}'
    content_type: 'application/json'

## Sensors
sensor:
  - platform: rest
    resource: !secret api_sunsa_main
    name: api_sunsa_main
    json_attributes:
      - devices
    value_template: "OK"
  
  - platform: template
    sensors:
    # NOTE - Modify the [0], [1], etc device identifier below for each device, to ensure it's calling the right one. These are listed top to bottom in the Sunsa app. First device is [0], second is [1] and so on.
      # Family Room - E Blinds
      familyroom_e_blinds_battery_percentage:
        friendly_name: 'Family Room - E Blinds Battery Percentage'
        device_class: battery
        value_template: "{{ state_attr('sensor.api_sunsa_main', 'devices')[0]['batteryPercentage'] }}"
        unit_of_measurement: '%'
        icon_template: mdi:battery-high
      familyroom_e_blinds_position:
        friendly_name: 'Family Room - E Blinds Position'
        value_template: "{{ state_attr('sensor.api_sunsa_main', 'devices')[0]['position'] }}"
        unit_of_measurement: '%'
        icon_template: mdi:blinds-horizontal
      familyroom_e_blinds_is_connected:
        friendly_name: 'Family Room - E Blinds Connection Status'
        value_template: "{{ state_attr('sensor.api_sunsa_main', 'devices')[0]['isConnected'] }}"
        icon_template: mdi:connection

      # Foyer - W Blinds
      foyer_w_blinds_battery_percentage:
        friendly_name: 'Foyer - W Blinds Battery Percentage'
        device_class: battery
        value_template: "{{ state_attr('sensor.api_sunsa_main', 'devices')[1]['batteryPercentage'] }}"
        unit_of_measurement: '%'
        icon_template: mdi:battery-high
      foyer_w_blinds_position:
        friendly_name: 'Foyer - W Blinds Position'
        value_template: "{{ state_attr('sensor.api_sunsa_main', 'devices')[1]['position'] }}"
        unit_of_measurement: '%'
        icon_template: mdi:blinds-horizontal
      foyer_w_blinds_is_connected:
        friendly_name: 'Foyer - W Blinds Connection Status'
        value_template: "{{ state_attr('sensor.api_sunsa_main', 'devices')[1]['isConnected'] }}"
        icon_template: mdi:connection

## Covers
cover:
  - platform: template
    covers:
    # Family Room - E Blinds
      familyroom_e_blinds:
        unique_id: familyroom_e_blinds
        friendly_name: 'Family Room - E Blinds'
        device_class: blind
        open_cover:
          service: rest_command.sunsa_familyroom_e_blinds
          data:
            position: "-100"
        stop_cover:
          service: rest_command.sunsa_familyroom_e_blinds
          data:
            position: "0"
        close_cover:
          service: rest_command.sunsa_familyroom_e_blinds
          data:
            position: "100"
        
    # Foyer - W Blinds
      foyer_w_blinds:
        unique_id: foyer_w_blinds
        friendly_name: 'Foyer - W Blinds'
        device_class: blind
        open_cover:
          service: rest_command.sunsa_foyer_w_blinds
          data:
            position: "-100"
        stop_cover:
          service: rest_command.sunsa_foyer_w_blinds
          data:
            position: "0"
        close_cover:
          service: rest_command.sunsa_foyer_w_blinds
          data:
            position: "100"
  1. Next, create the automations to keep the slider position and the Sunsa app in sync using the rest calls.
  • Make the rest call based on the slider changes
    NOTE - Create a blank automation and input this code into the yaml edit portion - Modify as needed
alias: Update-Slider0-FamilyRoomE-Blinds-Set-Position
description: ''
trigger:
  - platform: state
    entity_id: input_number.familyroom_e_blinds_slider
condition: []
action:
  - service: rest_command.sunsa_familyroom_e_blinds
    data:
      position: '{{ states(''input_number.familyroom_e_blinds_slider'') | int}}'
mode: single

  • Update the slider position, based on changes from rest

NOTE - This will sometimes have a delay before the slider is updated to mirror the changes from rest

alias: Update-Slider0-FamilyRoomE-Blinds-From-Rest
description: ''
trigger:
  - platform: state
    entity_id:
      - sensor.familyroom_e_blinds_position
condition: []
action:
  - service: input_number.set_value
    data:
      value: '{{ state_attr(''sensor.api_sunsa_main'', ''devices'')[0][''position''] }}'
    target:
      entity_id: input_number.familyroom_e_blinds_slider
mode: single


  1. Next, set all the blinds to close 20 minutes before sunset.
  • First, create a script to close all the blinds to their desired position
    NOTE - Change the position to -100 if you want them to close up. Also, make sure to enter the entity ID during script creation, to ensure the script has a user friendly name during creation. You won’t be able to easily modify this later
alias: Blinds-Close-All
sequence:
  - service: rest_command.sunsa_familyroom_e_blinds
    data:
      position: 100
  - service: rest_command.sunsa_foyer_w_blinds
    data:
      position: 100
mode: single
icon: mdi:blinds
  • Next, create the automation to call the script at the right time
alias: Blinds-Close-Before-Sunset
description: ''
trigger:
  - platform: sun
    event: sunset
    offset: '-20'
condition: []
action:
  - service: script.blinds_close_all
    data: {}
mode: single

  1. Finally, create the cards for usage from lovelace (utilizing Vertical Stack In Card from HACS, noted above.):
type: vertical-stack
cards:
  - type: custom:vertical-stack-in-card
    title: Family Room - E Blinds
    cards:
      - type: entities
        entities:
          - entity: input_number.familyroom_e_blinds_slider
            name: Variable Open Rate
          - entity: cover.familyroom_e_blinds
            name: Close Up/Open/Close Down
            secondary_info: none
      - type: horizontal-stack
        cards:
          - type: entities
            entities:
              - entity: sensor.familyroom_e_blinds_is_connected
                name: Connection
                secondary_info: last-updated
          - type: entities
            entities:
              - entity: sensor.familyroom_e_blinds_battery_percentage
                name: Battery
                secondary_info: last-updated
  - type: custom:vertical-stack-in-card
    title: Foyer - W Blinds
    cards:
      - type: entities
        entities:
          - entity: input_number.foyer_w_blinds_slider
            name: Variable Open Rate
          - entity: cover.foyer_w_blinds
            name: Close Up/Open/Close Down
            secondary_info: none
      - type: horizontal-stack
        cards:
          - type: entities
            entities:
              - entity: sensor.foyer_w_blinds_is_connected
                name: Connection
                secondary_info: last-updated
          - type: entities
            entities:
              - entity: sensor.foyer_w_blinds_battery_percentage
                name: Battery
                secondary_info: last-updated

DISCLAIMER:
I’m about to be away for a large work project, so unfortunately, I won’t be checking back here for a while, so I will not be able to offer any assistance with your implementations. My hope is that this write-up is a good enough jumping off point to get you started/heading in the right direction if you’re coming into this fresh.

4 Likes

This all is great! I have mine set up and working as mentioned in the above posts with only one issue; for some reason when I go to adjust one of my two blinds the other one adjusts as well. I’ve reviewed the code and do not see any differences and have the blinds named completely different names. Any ideas?

If you’re using the rest calls, make sure the device numbers [0], [1], etc. are changed as well. Post your yaml if you’re still having issues.

Here is my configuration.yaml. I noticed that I had the order of the blinds different than what is shown on the app and changed it to what is listed below. That has seemed to stop the both from adjusting when I would change one but I do notice that if I make changes in the app, they are not reflected on my dashboard. Is that expected?

## Input Numbers
input_number:
# Blinds
  office_blinds_slider:
    name: Office Blinds Slider
    min: -100
    max: 100
    step: 10
  master_bedroom_blinds_slider:
    name: Master Bedroom Blinds Slider
    min: -100
    max: 100
    step: 10


## Rest Commands
rest_command:
  sunsa_office_blinds:
    url: !secret api_sunsa_office_blinds 
    method: PUT
    headers:
      accept: 'application/json'
    payload: '{"Position": {{ position }}}'
    content_type: 'application/json'
  sunsa_master_bedroom_blinds:
    url: !secret api_sunsa_master_bedroom_blinds
    method: PUT
    headers:
      accept: 'application/json'
    payload: '{"Position": {{ position }}}'
    content_type: 'application/json'


## Sensors
sensor:
  - platform: rest
    resource: !secret api_sunsa_main
    name: api_sunsa_main
    json_attributes:
      - devices
    value_template: "OK"
  
  - platform: template
    sensors:
    # NOTE - Modify the [0], [1], etc device identifier below for each device, to ensure it's calling the right one. These are listed top to bottom in the Sunsa app. First device is [0], second is [1] and so on.
      # Office Blinds
      office_blinds_battery_percentage:
        friendly_name: 'Office Blinds Battery Percentage'
        device_class: battery
        value_template: "{{ state_attr('sensor.api_sunsa_main', 'devices')[0]['batteryPercentage'] }}"
        unit_of_measurement: '%'
        icon_template: mdi:battery-high
      office_blinds_position:
        friendly_name: 'Office Blinds Position'
        value_template: "{{ state_attr('sensor.api_sunsa_main', 'devices')[0]['position'] }}"
        unit_of_measurement: '%'
        icon_template: mdi:blinds-horizontal
      office_blinds_is_connected:
        friendly_name: 'Office Blinds Connection Status'
        value_template: "{{ state_attr('sensor.api_sunsa_main', 'devices')[0]['isConnected'] }}"
        icon_template: mdi:connection
      # Master Bedroom Blinds
      master_bedroom_blinds_battery_percentage:
        friendly_name: 'Master Bedroom Blinds Battery Percentage'
        device_class: battery
        value_template: "{{ state_attr('sensor.api_sunsa_main', 'devices')[1]['batteryPercentage'] }}"
        unit_of_measurement: '%'
        icon_template: mdi:battery-high
      master_bedroom_blinds_position:
        friendly_name: 'Master Bedroom Blinds Position'
        value_template: "{{ state_attr('sensor.api_sunsa_main', 'devices')[1]['position'] }}"
        unit_of_measurement: '%'
        icon_template: mdi:blinds-horizontal
      master_bedroom_blinds_is_connected:
        friendly_name: 'Master Bedroom Blinds Connection Status'
        value_template: "{{ state_attr('sensor.api_sunsa_main', 'devices')[1]['isConnected'] }}"
        icon_template: mdi:connection

The automations are what keeps rest in sync with HA, without them, it won’t sync. You need 2 automations, per blind. One to sync rest to the slider, one to sync the slider with rest.

THIS IS AMAZING. Great integration and great walkthrough. I followed it to the letter, and it’s up and running, flawlessly.

What steps have to be taken to convert this to an actual integration (and get this guy some credit for a great product!)?