SmartThings API Survey: Help Shape the Future

SmartThings API Survey:

We are enhancing our SmartThings API and would love your input. Please take ~10 minutes to complete our survey and shape the future SmartThings API experience.

We are interested in respondents from both current users and prospective users of the SmartThings API. The survey is anonymous.

We are interested in learning about your

  • Use cases and goals
  • Experience integrating with the SmartThings API
  • Frustrations and blockers
  • Other solutions you’ve looked at
  • and more

We really appreciate your inputs and this will be used by the product team to guide the roadmap. Thank you!

Wow, that was ten minutes of my life that I won’t get back. I’ll assume the total instability of the survey on my phone might not have been your fault, though I am more sceptical about one of the later sections that was difficult to complete because the last answer field only accepted one character at a time then changed keyboard focus back three fields, and if an email address is supposed to be optional you shouldn’t reject an empty answer.

It was actually possible to start completing the survey as an end user/hobbyist but it was getting tricky by the second or third question and by the end it was totally impossible.

The survey didn’t seem to have any meat. There are many problems with the API. Only asking about one was unexpected.

Hi @orangebucket thank you for completing the survey and for you comments on the experience. Sorry to hear of the difficulties. We fixed the logic to the optional email question to only show the open field if a respondent is wanting to leave it. We double-checked the mobile experience too to make sure it’s working as expected.

Proposal: SmartThings Context Capabilities

Extending the SmartThings API from Device State to Home Context

Executive Summary

SmartThings already has a strong device-centric model. Devices are represented through Device Profiles, Components, Capabilities, Attributes, and Commands. Capabilities are core to the SmartThings architecture because they abstract device functions and allow SmartThings to retrieve the state of a device component or control a device function.

This model works very well for describing what an individual device can do.

However, many advanced smart home experiences depend on information that does not naturally belong to one device. Examples include local weather, rain forecast, solar position, outdoor air quality, room occupancy, average room climate, energy tariffs, hub health, mesh health, privacy state, and overall safety state.

This proposal suggests introducing SmartThings Context Capabilities: a standardized, permissioned, API-accessible, and optionally hub-cached way to expose shared contextual information through the SmartThings platform.

The central idea is:

SmartThings should not only expose what each device reports. SmartThings should also expose what the home, room, location, hub, and network know.

This would make the SmartThings platform more valuable for users, automation developers, Edge Driver developers, SmartApp developers, and device manufacturers — including both Matter device manufacturers and manufacturers using SmartThings Cloud Connected Devices.


Why This Matters for the SmartThings API

The SmartThings API is already positioned as the core API for controlling devices, creating automations, managing Locations, and retrieving user and device information.

Today, however, the API is still primarily built around device state, device commands, locations, rooms, scenes, rules, and installed integrations. That is useful, but it leaves a gap: there is no first-class API object for shared home context.

For example, a manufacturer or developer may want to ask:

What is the local outdoor temperature?
Is rain expected soon?
What is the solar elevation?
Is this room probably occupied?
What is the average room temperature?
Is privacy mode active?
Is there a safety event in this Location?
Is the hub cloud-connected?
Is the Thread or Zigbee network unstable?
Is electricity expensive right now?

Today, that information must usually be inferred from individual devices, external services, virtual devices, proprietary cloud integrations, or custom automation logic.

A SmartThings Context API would make this information available in a standard way.


The Core Opportunity

SmartThings already connects many different integration types:

Cloud Connected Devices
Hub Connected Devices
Direct Connected Devices
Mobile Connected Devices
Matter devices
Edge Drivers
Rules
SmartApps
Partner cloud integrations

Cloud Connected Devices are particularly important here. SmartThings Schema allows manufacturers with an existing cloud to integrate devices into SmartThings using JSON payloads for communication between the manufacturer cloud and SmartThings, including device state events and commands.

That means Context Capabilities should not be designed only for Edge or only for Matter.

They should be part of the SmartThings API layer.

A manufacturer with a cloud-connected irrigation controller, air purifier, thermostat, camera, EV charger, appliance, window covering, robot vacuum, or energy device could benefit just as much as a Matter manufacturer.

The strategic positioning could be:

Device manufacturers bring the device. SmartThings brings the home context.

Or:

SmartThings makes connected devices context-aware, regardless of whether they connect through Matter, Edge, Schema, Direct Connected, or another supported integration path.


Problem

Many advanced automations and product experiences need shared context:

Current outdoor temperature
Rain forecast
Wind speed and gusts
Solar elevation and azimuth
Cloud cover
Outdoor air quality
Pollen level
Room occupancy
Average room temperature
Average room humidity
Window-open state per room
Electricity price
Grid carbon intensity
Hub health
Matter controller state
Thread/Zigbee/Z-Wave network health
Privacy mode
Overall safety state
Water leak state
Smoke/CO state

Today, manufacturers and developers often need to solve this individually.

Typical workarounds include:

Virtual weather devices
Manufacturer-specific weather integrations
Cloud SmartApps
External API bridges
Custom Edge Drivers
Manual virtual switches
Duplicated automations
Hardcoded driver preferences
Device-specific logic

These workarounds create duplicated effort and inconsistent user experiences.

For example:

  • A cloud-connected awning manufacturer may need weather and wind data.
  • A cloud-connected irrigation manufacturer may need rain forecast and soil moisture.
  • A cloud-connected air purifier manufacturer may need outdoor AQI and pollen.
  • A cloud-connected camera manufacturer may need privacy state and occupancy context.
  • A cloud-connected thermostat manufacturer may need room-level climate aggregation and energy pricing.
  • A cloud-connected EV charger manufacturer may need tariff windows, solar forecast, and whole-home load state.

Each manufacturer can build these integrations alone, but that is inefficient. It also produces fragmented behavior across the SmartThings ecosystem.


Proposal

Introduce SmartThings Context Capabilities as a new platform concept exposed through the SmartThings API.

Instead of only exposing:

Device
└── Component
    └── Capability
        └── Attribute

SmartThings could also expose:

Location
└── Context Capability
    └── Attribute

Room
└── Context Capability
    └── Attribute

Hub
└── Context Capability
    └── Attribute

Network
└── Context Capability
    └── Attribute

Example context paths:

location.weather.temperature
location.weather.windGust
location.weather.precipitationProbability
location.daylight.solarElevation
location.daylight.solarAzimuth
location.airQuality.aqi
location.energy.electricityPrice
location.privacy.cameraRecordingAllowed
location.safety.waterLeakState

room.livingRoom.climate.averageTemperature
room.livingRoom.occupancy.state
room.livingRoom.light.averageIlluminance
room.livingRoom.windows.anyOpen

hub.health.cloudConnected
hub.health.localExecutionAvailable
hub.health.firmwareVersion

network.thread.borderRouterCount
network.thread.lastTopologyChange
network.zigbee.lowSignalDeviceCount
network.matter.offlineDeviceCount

This would extend the SmartThings capability philosophy beyond individual devices and into the home itself.


API-First Design

The most important aspect of this proposal is that Context Capabilities should be exposed through the SmartThings API.

Possible API endpoints:

GET /locations/{locationId}/context
GET /locations/{locationId}/context/weather
GET /locations/{locationId}/context/daylight
GET /locations/{locationId}/context/energy
GET /locations/{locationId}/context/privacy
GET /locations/{locationId}/context/safety

GET /locations/{locationId}/rooms/{roomId}/context
GET /locations/{locationId}/rooms/{roomId}/context/climate
GET /locations/{locationId}/rooms/{roomId}/context/occupancy

GET /locations/{locationId}/hubs/{hubId}/context
GET /locations/{locationId}/networks/thread/context
GET /locations/{locationId}/networks/zigbee/context

Example response:

{
  "locationId": "home-123",
  "weather": {
    "temperature": {
      "value": 9.4,
      "unit": "C",
      "updatedAt": "2026-04-29T15:10:00Z",
      "expiresAt": "2026-04-29T15:40:00Z",
      "source": "SmartThings Weather",
      "quality": "estimated"
    },
    "windGust": {
      "value": 42,
      "unit": "km/h",
      "updatedAt": "2026-04-29T15:10:00Z",
      "expiresAt": "2026-04-29T15:40:00Z",
      "source": "SmartThings Weather",
      "quality": "estimated"
    }
  },
  "daylight": {
    "sunrise": "2026-04-29T03:48:00Z",
    "sunset": "2026-04-29T18:31:00Z",
    "solarElevation": 18.2,
    "solarAzimuth": 251.7,
    "isDaylight": true
  }
}

The important part is that this context is not tied to a specific device unless a user or the platform explicitly selects a device as the source.


Value for Cloud Connected Device Manufacturers

This is one of the strongest selling points.

SmartThings Cloud Connected Devices communicate through SmartThings Schema, where the manufacturer cloud exchanges JSON payloads with the SmartThings Cloud for device state events and commands.

A Context API would give cloud-connected manufacturers a standardized way to build richer device experiences without each manufacturer recreating the same context infrastructure.

Example: Cloud-Connected Irrigation Controller

A manufacturer may already provide:

Valve state
Zone state
Schedule state
Flow state
Fault state
Battery state

But smarter irrigation requires:

Rain forecast
Recent precipitation
Outdoor temperature
Wind speed
Soil moisture
Season
Sun exposure
Water leak state
Watering restrictions

SmartThings could expose:

location.weather.precipitationProbability
location.weather.precipitationExpected
location.weather.temperature
location.weather.windSpeed
location.daylight.dayLength
location.safety.waterLeakState
area.soil.moisture

The manufacturer could then offer a better SmartThings experience without building every environmental integration itself.

Example: Cloud-Connected Air Purifier

The device may provide:

Fan speed
Filter life
Indoor PM2.5
VOC level
Mode

SmartThings Context could provide:

location.airQuality.aqi
location.airQuality.pm25
location.airQuality.pollenIndex
room.occupancy.state
location.intent.quietHours

This would allow the manufacturer to build logic such as:

Run harder when outdoor AQI is poor and windows were recently opened.
Use quiet mode when the room is occupied at night.
Recommend ventilation only when outdoor air is cleaner than indoor air.

Example: Cloud-Connected EV Charger

The device may provide:

Charging state
Plug state
Charging current
Energy delivered
Fault state

SmartThings Context could provide:

location.energy.electricityPrice
location.energy.nextLowPriceWindow
location.energy.gridCarbonIntensity
location.energy.solarForecast
home.workload.highPowerLoadActive

This would allow the manufacturer to offer tariff-aware, carbon-aware, or solar-aware charging inside SmartThings.


Value for Hub Connected and Edge Devices

Edge Drivers currently emit device capability events and receive capability commands. The current Edge model is therefore very device-oriented. Context Capabilities would add a new read-only input layer for drivers.

Possible Lua API:

local temp = driver.context:get({
  scope = "location",
  group = "weather",
  attribute = "temperature"
})

local wind_gust = driver.context:get({
  scope = "location",
  group = "weather",
  attribute = "windGust"
})

Subscription example:

driver.context:subscribe({
  scope = "location",
  group = "weather",
  attribute = "windGust"
}, function(event)
  if event.value > 35 then
    -- Protect awnings, blinds, skylights, or outdoor equipment.
  end
end)

Room context example:

local occupied = device.context.room:get("occupancy.state")
local room_temp = device.context.room:get("climate.averageTemperature")
local window_open = device.context.room:get("windows.anyOpen")

This would benefit SmartThings stock drivers, community Edge Drivers, manufacturer Edge Drivers, LAN integrations, Zigbee, Z-Wave, Matter, and future hub-connected integrations.


Value for Rules and Routines

Context Capabilities could become new Rule operands.

Example:

{
  "if": {
    "greaterThan": {
      "left": {
        "locationContext": {
          "context": "weather",
          "attribute": "windGust"
        }
      },
      "right": {
        "decimal": 35
      }
    },
    "then": [
      {
        "command": {
          "devices": ["awning-device-id"],
          "commands": [
            {
              "component": "main",
              "capability": "windowShade",
              "command": "close"
            }
          ]
        }
      }
    ]
  }
}

Room context example:

{
  "if": {
    "and": [
      {
        "equals": {
          "left": {
            "roomContext": {
              "roomId": "living-room-id",
              "context": "occupancy",
              "attribute": "state"
            }
          },
          "right": {
            "string": "occupied"
          }
        }
      },
      {
        "lessThan": {
          "left": {
            "roomContext": {
              "roomId": "living-room-id",
              "context": "light",
              "attribute": "averageIlluminance"
            }
          },
          "right": {
            "integer": 80
          }
        }
      }
    ],
    "then": [
      {
        "command": {
          "devices": ["blind-device-id"],
          "commands": [
            {
              "component": "main",
              "capability": "windowShade",
              "command": "open"
            }
          ]
        }
      }
    ]
  }
}

For the SmartThings app, these same concepts could appear as Routine conditions:

If wind gust is above 35 km/h
If Living Room is occupied
If outdoor air quality is worse than indoor air quality
If electricity price is low
If privacy mode is active
If any water leak is detected in this Location

Suggested Context Areas

1. Location Weather Context

location.weather.temperature
location.weather.feelsLikeTemperature
location.weather.humidity
location.weather.dewPoint
location.weather.pressure
location.weather.windSpeed
location.weather.windGust
location.weather.windDirection
location.weather.cloudCover
location.weather.precipitationProbability
location.weather.precipitationExpected
location.weather.weatherCondition
location.weather.updatedAt
location.weather.expiresAt

Useful for irrigation, awnings, blinds, heating, cooling, ventilation, outdoor lighting, water protection, and freeze protection.

2. Daylight and Solar Context

location.daylight.sunrise
location.daylight.sunset
location.daylight.civilDawn
location.daylight.civilDusk
location.daylight.solarNoon
location.daylight.solarElevation
location.daylight.solarAzimuth
location.daylight.isDaylight
location.daylight.dayLength

Useful for blinds, shades, lighting, solar gain management, privacy automations, security lighting, and energy optimization.

3. Air Quality Context

location.airQuality.aqi
location.airQuality.pm25
location.airQuality.pm10
location.airQuality.ozone
location.airQuality.pollenIndex
location.airQuality.category

Useful for air purifiers, ventilation, window automation, HVAC, and health-aware routines.

4. Room Context

room.climate.averageTemperature
room.climate.averageHumidity
room.occupancy.state
room.occupancy.confidence
room.light.averageIlluminance
room.windows.anyOpen
room.airQuality.summary
room.comfort.score

Useful for thermostats, radiator valves, fans, air purifiers, lighting, blinds, and presence-aware automation.

5. Energy Context

location.energy.electricityPrice
location.energy.electricityPriceLevel
location.energy.nextLowPriceWindow
location.energy.nextHighPriceWindow
location.energy.gridCarbonIntensity
location.energy.solarForecast
location.energy.demandResponseActive

Useful for EV chargers, batteries, heat pumps, dishwashers, washing machines, dryers, water heaters, smart plugs, and energy dashboards.

6. Safety Context

location.safety.smokeState
location.safety.coState
location.safety.waterLeakState
location.safety.freezeState
location.safety.intrusionState
location.safety.highestSeverity
location.safety.affectedRooms

Useful for water valves, sirens, locks, lights, cameras, notifications, and insurance-related services.

7. Privacy Context

location.privacy.privacyMode
location.privacy.cameraRecordingAllowed
location.privacy.microphoneAllowed
location.privacy.presenceDetailAllowed
location.privacy.guestPrivacyMode

Useful for cameras, presence sensors, mmWave sensors, microphones, voice devices, and room-aware automations.

8. Hub and Network Context

hub.health.cloudConnected
hub.health.localExecutionAvailable
hub.health.firmwareVersion
hub.health.firmwareUpdateAvailable
hub.health.zigbeeRadioState
hub.health.zwaveRadioState
hub.health.threadRadioState
hub.health.matterControllerState

network.thread.borderRouterCount
network.thread.lastTopologyChange
network.thread.routeInstability
network.zigbee.lowSignalDeviceCount
network.zwave.routeChanges
network.matter.offlineDeviceCount

Useful for diagnostics, support, device onboarding, Matter reliability, Thread troubleshooting, Zigbee troubleshooting, advanced Edge Drivers, and manufacturer support workflows.


Hub-Cached Context

Some context can live purely in the cloud, but the most useful context should be hub-cached where possible.

Recommended model:

Cloud service fetches or calculates context
        ↓
SmartThings normalizes context into standard attributes
        ↓
Hub receives a signed context snapshot
        ↓
Rules and Edge Drivers use latest local snapshot where supported
        ↓
Cloud refreshes periodically

Each value should include freshness metadata:

{
  "value": 12.7,
  "unit": "C",
  "updatedAt": "2026-04-29T15:10:00Z",
  "expiresAt": "2026-04-29T15:40:00Z",
  "source": "SmartThings Weather",
  "quality": "estimated",
  "confidence": 0.82
}

This allows automations, apps, and drivers to distinguish between:

fresh value
stale value
missing value
estimated value
measured value
derived value
user-selected source value

That matters for safety-relevant use cases such as awnings, water valves, heating, cooling, cameras, and security behavior.


Source Selection and Fallbacks

SmartThings could allow users to configure preferred sources for context values.

Example:

Outdoor temperature source priority:
1. Garden weather station
2. Balcony temperature sensor
3. SmartThings local weather
4. Regional weather fallback

Then automations, API clients, Rules, and drivers can simply consume:

location.outdoor.temperature

The metadata would still show the source:

{
  "value": 8.6,
  "unit": "C",
  "source": "Garden Weather Station",
  "quality": "measured"
}

or:

{
  "value": 9.4,
  "unit": "C",
  "source": "SmartThings Weather",
  "quality": "estimated"
}

This combines the simplicity of platform-provided context with the accuracy of real local sensors.


Permissions and Privacy

Context access should be permissioned through the SmartThings API authorization model.

Low-risk context could use simple read scopes:

r:locations:context:weather
r:locations:context:daylight
r:locations:context:airQuality

Sensitive context should require more explicit authorization:

r:locations:context:occupancy
r:rooms:context:occupancy
r:locations:context:privacy
r:locations:context:safety
r:locations:context:security

This is important because not every integration needs sensitive household state.

A blind controller may reasonably need daylight and weather.

A camera integration may need privacy state.

An EV charger may need energy context.

A simple light integration probably does not need detailed occupancy, security, or privacy state.

Write Access

Most context should be read-only for ordinary integrations.

Recommended categories:

1. Platform-Owned Context

Written only by SmartThings:

location.daylight.sunrise
location.daylight.solarElevation
location.weather.forecast

2. User-Selected Source Context

Derived from devices selected by the user:

location.outdoor.temperature
room.climate.averageTemperature
room.occupancy.state

3. Partner-Provided Context

Written by authorized partner integrations:

location.energy.electricityPrice
location.energy.gridCarbonIntensity
location.weather.providerForecast
location.airQuality.providerAqi

4. Trusted/System Diagnostic Context

Published by SmartThings or trusted system components:

hub.health.cloudConnected
network.thread.borderRouterCount
network.zigbee.lowSignalDeviceCount

Ordinary third-party integrations should not freely write critical state such as:

location.safety.smokeState
location.safety.coState
location.occupancy.state
location.privacy.cameraRecordingAllowed

unless the user explicitly authorizes that integration as the source for that context.


Possible Implementation Path

Phase 1: System-Created Context Devices

The fastest implementation could use system-managed pseudo-devices.

Example:

Device: Home Context
Components:
- weather
- daylight
- airQuality
- energy
- safety
- privacy
- network

Advantages:

Backward-compatible
Uses existing device/capability model
Works with existing app concepts
Works with existing Rules concepts more easily
Can be introduced gradually

Disadvantages:

Weather, daylight, energy, and network health are not really devices
May clutter the device list if not hidden or grouped carefully
Less elegant for room, hub, and network-scoped context

This would be a practical first step, especially because current capabilities and events are strongly tied to device components.

Phase 2: SmartThings Context API

Add first-class API endpoints:

GET /locations/{locationId}/context
GET /locations/{locationId}/context/{contextName}
GET /locations/{locationId}/rooms/{roomId}/context

This would make Context Capabilities usable by:

Cloud Connected Device manufacturers
SmartApps
Partner integrations
Rules API tools
External dashboards
Advanced users
Support and diagnostics tools

Phase 3: Rules and Routine Integration

Add context operands to Rules and user-friendly conditions to the SmartThings app.

Examples:

If local wind gust is above 35 km/h
If Living Room is occupied
If outdoor AQI is poor
If electricity price is low
If privacy mode is active
If any water leak is detected

Phase 4: Edge Driver Read API

Expose read-only context access to Edge Drivers:

driver.context:get(...)
driver.context:subscribe(...)

This would enable local hub-connected devices and manufacturer Edge Drivers to consume the same context layer.

Phase 5: Partner and Certification Program

SmartThings could create a manufacturer-facing program:

SmartThings Context-Aware
Optimized for SmartThings Context
Enhanced SmartThings Experience
Context-Aware SmartThings Device

Example categories:

Context-Aware Irrigation
Context-Aware Water Protection
Context-Aware Blinds and Awnings
Context-Aware EV Charging
Context-Aware Air Quality
Context-Aware Cameras
Context-Aware Energy Management
Context-Aware Appliances

This would create a clear ecosystem advantage.


Manufacturer Positioning

The manufacturer-facing message could be:

SmartThings makes connected devices context-aware.

Or:

Bring your device. SmartThings provides the home intelligence around it.

Or:

Devices do not merely work in SmartThings. They become smarter in SmartThings.

This applies to:

Cloud connected Dädevices
Hub connected devices
Direct connected devices
Partner cloud integrations

For manufacturers, this reduces the need to build proprietary integrations for:

weather
forecast
solar position
energy tariffs
grid carbon data
room occupancy
privacy state
hub diagnostics
mesh diagnostics
safety aggregation

For SmartThings, this creates platform differentiation.

The SmartThings API becomes not only a device-control API, but also a home-context API.


Feasibility

What is already true today

SmartThings already has the necessary conceptual building blocks: Locations, Rooms, Devices, Device Profiles, Components, Capabilities, Attributes, Commands, Rules, Cloud Connected Devices, Edge Drivers, and the SmartThings API.

Device Profiles contain Components, and Components group Capabilities.

The SmartThings API already supports device access, device metadata, device state, and more.

Cloud Connected Device support is real and relevant. SmartThings Schema is intended for cloud-to-cloud device integrations where the manufacturer cloud and SmartThings exchange JSON payloads for device state events and commands.

Rules can automate devices and services, and local execution is possible when the involved devices and services support local execution.

Edge Drivers emit capability events for device/component state and receive capability commands.

What does not appear to exist publicly today

There does not appear to be a public SmartThings API concept equivalent to first-class:

location.context
room.context
hub.context
network.context

The current public capability model is device/component-oriented: capabilities retrieve state from a device component or control a device function.

Edge Driver capability events are also currently device/component-oriented. Event handling requires the device and component the event belongs to.

So this proposal is not merely asking SmartThings to expose an already-existing hidden attribute. It would require either:

A system-managed context device model
or
A new first-class Context API
or
Both

Feasibility assessment

Most feasible short-term path

A system-created “Home Context” device is the most feasible first step.

Why?

Because it reuses the existing device/component/capability model. SmartThings already knows how to expose device state to the app, API, Rules, and integrations.

The tradeoff is conceptual: weather, daylight, energy, privacy, and network health are not truly devices. But as a compatibility layer, this is practical.

Best long-term path

A first-class SmartThings Context API is the better architecture.

This avoids pretending that weather or room occupancy aggregation is a device. It would allow clean modeling of:

Location context
Room context
Hub context
Network context

This would require new API endpoints, new permissions, new Rules operands, and eventually new app UI.

Edge Driver feasibility

Edge Driver support is feasible, but likely not the first step.

The current Edge API is device-centered, so a new read-only context API would need to be added to the Lua libraries. It should probably come after the cloud/API context model exists.

Rules feasibility

Rules integration is feasible, but it depends on whether SmartThings models context as a pseudo-device or as a new operand type.

If modeled as pseudo-devices, Rules can reuse more existing machinery.

If modeled as first-class context, Rules need new operands such as:

{
  "locationContext": {
    "context": "weather",
    "attribute": "windGust"
  }
}

Local execution feasibility

Local execution is possible for hub-cached context, but not for all context.

For example:

Solar position can be calculated locally.
Room temperature aggregation can be local if source devices are local.
Hub health can be local.
Some network diagnostics can be local.
Weather forecast and energy tariffs usually require cloud refresh.

A hybrid model is realistic:

Cloud-fed
Hub-cached
Timestamped
Expires gracefully
Falls back safely

Conclusion

SmartThings already does an excellent job representing individual devices.

The next opportunity is to represent the shared context around those devices.

A SmartThings Context API would allow the platform to expose weather, daylight, air quality, energy, room state, safety, privacy, hub health, and network health in a standardized way.

This would benefit users, but it would also be highly valuable for device manufacturers — especially manufacturers of Cloud Connected Devices.

The core message is:

SmartThings Context Capabilities would make the SmartThings API more than a device-control API. It would become a home-intelligence API.

That is the real selling point.

We do of course already have weather observations and forecasts, and air quality, available in the Coordinate API, but we have to jump through hoops to do anything with it so we might just as well use third party services. The most we really get exposed to is the barest of bare bones that we see used in Routines/Rules.

Similarly we can use the Summary API for the static ‘tile’ information for Locations and Rooms but we probably aren’t intended to and it isn’t really in a usable form. It is a shame really as that has so much potential.

Yes, exactly - that sounds like the Client API, not really the public SmartThings API layer I had in mind.

And that distinction is important.

I am not thinking about relying on app-facing summary endpoints that happen to be used for tiles in the SmartThings app. What I had in mind is something more basic and more official: a documented, supported way for SmartThings to expose context for a Location or Room.

The reason I keep coming back to this idea is simple: as a SmartThings user, you eventually hit a wall.

SmartThings is very good at devices. A device has components, capabilities, attributes and commands. That part works well.

But the home itself still feels very device-centric. Locations and Rooms mostly organize devices; they do not really behave like entities with their own state.

When I create a Routine, I cannot simply say:

If Living Room temperature is above 24 °C, then …

or:

If Bathroom is occupied, then …

or:

If any window in this room is open, then …

Instead, I have to pick a specific device in that room that provides the capability I need. If there are several temperature sensors, I have to choose one. If I want an average temperature, it already starts to feel like building logic myself. If I want room occupancy, I often end up combining motion sensors, presence sensors, mmWave sensors, modes, virtual switches, or helper devices.

That is where it feels like something fundamental is missing.

We use virtual devices for things that are not really devices. We install helper drivers. We use weather proxy drivers. We build little workarounds for states that, from a user perspective, should simply belong to the Room or Location.

A Room should be able to have a temperature.

A Room should be able to have an occupancy state.

A Location should be able to have local weather, daylight, air quality, safety state, or privacy state.

So yes, the existing Client/Summary API is interesting because it shows that SmartThings already calculates some of this information for the app. But that is not the same as exposing it as a proper platform feature.

What I mean is more like:

room.livingRoom.temperature
room.livingRoom.occupancy
room.livingRoom.windows.anyOpen
location.weather.temperature
location.daylight.isDaylight
location.airQuality.aqi

Not necessarily with exactly those names, of course - just the general idea.

For normal users, this could make Routines much more natural. It would reduce the need for virtual devices, helper drivers, weather proxy drivers and complicated workaround logic. Ever tried something like IF one of the windows in this room are open … as a precondition?

SmartThings already models devices very well. I just think the next step would be to model the home around those devices just as cleanly.

Just to be clear, I do broadly agree. If I have a point it is that some of the building blocks do already exist in the API, albeit not in a particularly useful form for the community to exploit. If the information was in what I would consider to be the ‘right’ place instead of seemingly just being for the convenience of the mobile app, then what @Andreas_Roedl is suggesting would already look a lot closer.

The weather and air quality services are already in the API. The /weatherdata endpoint in the Client API already shows a distillation of them for Locations, but why is it confined to the Client API and why isn’t it under /locations? Some of the info creeps into Rules in a rather dumbed down form via what could be considered an embryonic Location context. It has just never grown beyond that.

Similarly /summary/presentation (Client API again) shows that quite some effort has already been placed into being able to combine device information on a Location and Room basis. The ‘static’ information ends up in /summary when again it seems like it ought to be proudly presented in the public API under /locations.

All I ask is that new API features or enhancements are local-first (unlike the circadian rhythm or the gradual brightening) and with no extra vendor certification required (unlike SmartThings Energy which does not trust Matter certification and requires its own). I know that’s placing a burden on them for performance and business reasons.

The elephant in the room is still the app dependence on SmartThings API cloud and lack of local control of devices if the SmartThings cloud is not available because the app cannot talk to the hub directly, not even for turning on a Zigbee or Matter light. Meanwhile, there are smart home platforms where the app does not even need a hub because they can be the Matter controller, like Apple Home or SmartLife. That would be a huge selling point, more so if Samsung smartphones included Thread radio like some iPhones or Pixel phones.

Yes, I think that describes the current situation very well.

The interesting part is not that SmartThings has none of this. The interesting part is that some of the building blocks already seem to exist, but they are in places where they are mostly useful for the mobile app, not as a proper public platform model.

That is also why I increasingly think less in terms of individual devices and more in terms of Locations and Rooms.

Devices come and go. They get replaced, moved, reset, renamed, excluded, re-added, or substituted by another brand. But the Location remains. The Rooms remain. The living room is still the living room, even if the thermostat, motion sensor, temperature sensor, blinds, or radiator valve behind it change over time.

That is where the current model starts to feel a little strange from a user perspective.

For example, I now have several devices in the living room that expose temperature. Some are dedicated sensors, some are thermostats, some are presence sensors, and nowadays it feels like almost every device has a temperature sensor hidden somewhere. So which one is the “real” living room temperature?

Why doesn’t the SmartThings API simply offer something like an average or representative room temperature, similar to what Home Insight already seems to do visually?

The same applies to occupancy, windows, lights, humidity, air quality, and other states. As users, we often do not actually want to automate against one specific device. We want to automate against the state of the room or the home.

Sometimes I imagine what it would be like if my wife had to rebuild our entire smart home in SmartThings from scratch. She would not think in device IDs, capabilities, components, or which sensor happens to be best placed. She would simply expect to say:

Set the living room to 21 °C at 6 PM.

She would not know, and should not need to know, that an Aqara FP300 is responsible for presence detection, or that the Frient Smoke Detector happens to be the best temperature source in the bedroom, or that three different thermostats in one room need to be coordinated.

She thinks in states and desired outcomes, not in individual devices.

And honestly, that is probably how normal users think.

Of course, I understand that @Nathan_Sterner @SmartThings API survey is likely aimed strongly at B2B and partner integrations. That is also why I framed my proposal in that direction. But the user-facing benefit would be just as important.

A good example is a small manufacturer that recently launched a Matter-over-Thread radiator thermostat valve. No manufacturer cloud, no dedicated app, no ecosystem logic like Tado. Once it is connected to SmartThings, you can manually control each thermostat in the app. That is basically it.

If you have several of them in one room, you are back to controlling individual devices. There is no room-level heating logic, no representative room temperature, no awareness of open windows, no understanding of whether the room is occupied, and no real abstraction above the physical devices.

The manufacturer is essentially saying:

Here is the device. Now you figure out how to make it smart.

But this is exactly where SmartThings could provide enormous value.

What if the kind of intelligence that Tado provides through its own cloud could exist natively in SmartThings?

For that, the API would need an abstraction layer above individual devices. Something like:

If the average temperature in the living room is below X, set all radiator thermostats in that room to Y.

Or:

If any window in this room is open, pause heating in this room.

Or:

If the room is occupied and the room temperature is below the target, heat the room.

That sounds simple from a user perspective, but implementing this kind of cross-device logic in SmartThings is surprisingly difficult.

And that is where many current workarounds start to feel like Rube Goldberg machines.

Virtual switches. Helper devices. Mirrored attributes. Multiple routines just to express one logical condition. Rules copied into the Advanced Web App with IDs manually adjusted. Virtual aggregation devices just to represent something that should arguably already exist at Location or Room level.

Personally, I really dislike virtual devices for this kind of thing. I understand why they exist, and I understand why they are useful, but it feels fundamentally wrong to create a virtual switch and several routines just because I want to use a condition like:

Not all windows in this Location are closed.

That should not require a workaround.

So yes, I completely agree: the fact that /weatherdata, /summary, and /summary/presentation already exist is actually very interesting. It suggests that SmartThings already has pieces of a Location and Room context layer. But those pieces are not where they should be. They seem to be shaped around the mobile app experience instead of being exposed as a clean, documented, public API model.

What I would love to see is this idea taken seriously as a proper platform layer:

Location context
Room context
...
Hub context
Network context

Not as app tile data. Not as hidden Client API behavior. Not as something only advanced users can reverse-engineer.

But as a supported SmartThings API concept.

Because the missing piece is not just more device control. SmartThings already controls devices very well.

The missing piece is a clean way to describe and control the state of the home above the individual devices. An aggregation layer of capabilities, if you will.