SkinTemperatureRecord: Health Connect skin temperature data

What Google says SkinTemperatureRecord is

Captures the skin temperature of a user. Each record can represent a series of measurements of temperature differences.

The ability to insert or read this record type is dependent on the version of HealthConnect installed on the device. To check if available: call HealthConnectFeatures.getFeatureStatus and pass HealthConnectFeatures.FEATURE_SKIN_TEMPERATURE as an argument. See further down for an example on how to read skin temperature.

Quoted from Google’s SkinTemperatureRecord Jetpack reference, last updated 2026-08-06, read 2026-10-03.

Class

androidx.health.connect.client.records.SkinTemperatureRecord

Google's category

Vitals

Record type

Series

Unit class

androidx.health.connect.client.units.Temperature

Mandatory fields

deltasendTimemeasurementLocationmetadatastartTime

Added in (Jetpack)

1.1.0

Feature flag

FEATURE_SKIN_TEMPERATURE

Permissions

The exact strings Google’s data-types table declares for SkinTemperatureRecord. Google’s page: “Before requesting any permissions, your app must declare them in the manifest.”

<uses-permission android:name="android.permission.health.READ_SKIN_TEMPERATURE" />
<uses-permission android:name="android.permission.health.WRITE_SKIN_TEMPERATURE" />

import androidx.health.connect.client.permission.HealthPermission
import androidx.health.connect.client.records.SkinTemperatureRecord

val permissions = setOf(
    HealthPermission.getReadPermission(SkinTemperatureRecord::class),
    HealthPermission.getWritePermission(SkinTemperatureRecord::class),
)

The 8 fields of SkinTemperatureRecord

Types and descriptions as Google’s reference prints them. The range column quotes Google’s own range annotation or sentence; a dash means Google states none, which is not the same as no validation.

Aggregate metrics

The AggregateMetric constants Google defines on SkinTemperatureRecord. The value type is the T in Google’s AggregateMetric<T> signature. Every aggregate metric across all records.

Google’s read-data guide: “For cumulative types like StepsRecord, use aggregate() instead of readRecords() to avoid double counting from multiple sources and improve accuracy.” and “The aggregation API also contains logic to handle duplicate records, and lessens the chances of rate limiting.”

Constants

The 4 const val values Google’s reference lists on SkinTemperatureRecord, with the integer each maps to.

Read SkinTemperatureRecord in Kotlin

The shape of Google’s own read example, with SkinTemperatureRecord and its names filled in. Get the client with HealthConnectClient.getOrCreate(context) after checking getSdkStatus.

import androidx.health.connect.client.HealthConnectClient
import androidx.health.connect.client.records.SkinTemperatureRecord
import androidx.health.connect.client.request.ReadRecordsRequest
import androidx.health.connect.client.time.TimeRangeFilter
import java.time.Instant

suspend fun readSkinTemperature(
    client: HealthConnectClient,
    startTime: Instant,
    endTime: Instant,
): List<SkinTemperatureRecord> {
    val response = client.readRecords(
        ReadRecordsRequest(
            SkinTemperatureRecord::class,
            timeRangeFilter = TimeRangeFilter.between(startTime, endTime),
        )
    )
    // One page of up to pageSize records (default 1000); follow
    // response.pageToken for the rest.
    return response.records
}

import androidx.health.connect.client.HealthConnectClient
import androidx.health.connect.client.records.SkinTemperatureRecord
import androidx.health.connect.client.request.AggregateRequest
import androidx.health.connect.client.time.TimeRangeFilter
import java.time.Instant
import androidx.health.connect.client.units.TemperatureDelta

suspend fun aggregateSkinTemperature(
    client: HealthConnectClient,
    startTime: Instant,
    endTime: Instant,
): TemperatureDelta? {
    val response = client.aggregate(
        AggregateRequest(
            metrics = setOf(SkinTemperatureRecord.TEMPERATURE_DELTA_AVG),
            timeRangeFilter = TimeRangeFilter.between(startTime, endTime),
        )
    )
    // get() is declared as returning a nullable value.
    return response[SkinTemperatureRecord.TEMPERATURE_DELTA_AVG]
}

import androidx.health.connect.client.HealthConnectFeatures
import androidx.health.connect.client.permission.HealthPermission
import androidx.health.connect.client.readRecord
import androidx.health.connect.client.records.SkinTemperatureRecord
import androidx.health.connect.client.request.ReadRecordsRequest
import androidx.health.connect.client.time.TimeRangeFilter

if (
    healthConnectClient.features.getFeatureStatus(
        HealthConnectFeatures.FEATURE_SKIN_TEMPERATURE
    ) == HealthConnectFeatures.FEATURE_STATUS_AVAILABLE
) {
    if (
        healthConnectClient.permissionController
            .getGrantedPermissions()
            .contains(HealthPermission.getReadPermission(SkinTemperatureRecord::class))
    ) {
        val response =
            healthConnectClient.readRecords(
                ReadRecordsRequest<SkinTemperatureRecord>(
                    timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
                )
            )
        for (skinTemperatureRecord in response.records) {
            // Process each skin temperature record
        }
    } else {
        // Permission hasn't been granted. Request permission to read skin temperature.
    }
} else {
    // Feature is not available. It is not possible to read skin temperature.
}

Setting up the client, the permission flow and Play Console declaration: integrating Health Connect step by step.

HealthKit counterpart

No verified HealthKit counterpart. The cross-platform matrix only pairs metrics checked against both Apple’s and Google’s documentation, and SkinTemperatureRecord is not among them yet. A similarly named Apple type may exist on the HealthKit reference, but a name match is not a verified mapping.

The metric on other platforms

This guide lists SkinTemperatureRecord beside the types on the other platforms this site covers whose own descriptions name the same metric, each quoted, with how each one is read.

• Body Temperature API: Core, Skin and Wrist Temperature Data

Questions

What permission does SkinTemperatureRecord need?

Google's Health Connect data-types table (read 2026-10-03) declares android.permission.health.READ_SKIN_TEMPERATURE for reading SkinTemperatureRecord and android.permission.health.WRITE_SKIN_TEMPERATURE for writing it, and says apps must declare permissions in the manifest before requesting them.

Which aggregate metrics does SkinTemperatureRecord support?

Google's Jetpack reference defines 3 on SkinTemperatureRecord: TEMPERATURE_DELTA_AVG (AggregateMetric<TemperatureDelta>), TEMPERATURE_DELTA_MAX (AggregateMetric<TemperatureDelta>) and TEMPERATURE_DELTA_MIN (AggregateMetric<TemperatureDelta>). Pass them in the metrics set of an AggregateRequest and read each back from the AggregationResult.

What values does SkinTemperatureRecord.baseline accept?

Google's reference types baseline as Temperature?. Its description reads: "Temperature in Temperature unit. Optional field, null by default. Valid range: 0-100 Celsius degrees."

Is SkinTemperatureRecord an interval, instantaneous or series record?

Google's data-types table lists SkinTemperatureRecord as Series, and defines that column as indicating "whether the data is recorded at an instant in time or over an interval". Its mandatory fields are deltas, endTime, measurementLocation, metadata and startTime.