Temp Stick API Documentation

https://tempstickapi.com/api/v1

X-API-Key: YOUR_API_KEY

X-API-Key: YOUR_API_KEY
Accept: application/json
User-Agent: YourAppName/1.0
X-Client-Name: YourAppName
X-Client-Version: 1.0

headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Accept": "application/json",
    "User-Agent": "MyTempStickApp/1.0",
    "X-Client-Name": "MyTempStickApp",
    "X-Client-Version": "1.0",
}

headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Accept": "application/json",
}

(CELSIUS * 1.8) + 32

function celsius_to_fahrenheit($celsius, $round = 1) {
    return round(($celsius * 1.8) + 32, $round);
}

2026-04-27T15:30:00Z
2026-04-27T15:30:00+00:00

<?php

$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => 'https://tempstickapi.com/api/v1/sensors/all',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => '', // Automatically decode gzip responses.
    CURLOPT_TIMEOUT => 30,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Accept: application/json',
        'User-Agent: MyTempStickApp/1.0',
        'X-Client-Name: MyTempStickApp',
        'X-Client-Version: 1.0',
    ],
]);

$response = curl_exec($curl);

if ($response === false) {
    $error = curl_error($curl);
    curl_close($curl);
    throw new RuntimeException('Temp Stick API request failed: ' . $error);
}

$http_code = curl_getinfo($curl, CURLINFO_HTTP_CODE);
curl_close($curl);

if ($http_code < 200 || $http_code >= 300) {
    throw new RuntimeException('Temp Stick API returned HTTP ' . $http_code . ': ' . $response);
}

echo $response;

?>

const headers = new Headers();

headers.append("X-API-Key", "YOUR_API_KEY");
headers.append("Accept", "application/json");
headers.append("User-Agent", "MyTempStickApp/1.0");
headers.append("X-Client-Name", "MyTempStickApp");
headers.append("X-Client-Version", "1.0");

const requestOptions = {
  method: "GET",
  headers: headers,
  redirect: "follow"
};

fetch("https://tempstickapi.com/api/v1/sensors/all", requestOptions)
  .then(response => {
    if (!response.ok) {
      throw new Error(`Temp Stick API returned HTTP ${response.status}`);
    }

    return response.json();
  })
  .then(result => console.log(result))
  .catch(error => console.error("Temp Stick API request failed:", error));

curl --location --request GET 'https://tempstickapi.com/api/v1/sensors/all' \
  --header 'X-API-Key: YOUR_API_KEY' \
  --header 'Accept: application/json' \
  --header 'User-Agent: MyTempStickApp/1.0' \
  --header 'X-Client-Name: MyTempStickApp' \
  --header 'X-Client-Version: 1.0'

import requests

url = "https://tempstickapi.com/api/v1/sensors/all"

headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Accept": "application/json",
    "User-Agent": "MyTempStickApp/1.0",
    "X-Client-Name": "MyTempStickApp",
    "X-Client-Version": "1.0",
}

response = requests.get(url, headers=headers, timeout=30)
response.raise_for_status()

data = response.json()
print(data)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => 'https://tempstickapi.com/api/v1/sensor/YOUR_SENSOR_ID',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => '',
    CURLOPT_TIMEOUT => 30,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_POSTFIELDS => [
        'sensor_name' => 'Test',
        'send_interval' => '3600',
        'alert_interval' => '1800',
        'use_alert_interval' => '0',
        'alert_temp_below' => '',
        'alert_temp_above' => '',
        'alert_humidity_below' => '',
        'alert_humidity_above' => '',
        'connection_sensitivity' => '3',
        'use_offset' => '0',
        'temp_offset' => '0',
        'humidity_offset' => '0',
    ],
    CURLOPT_HTTPHEADER => [
        'X-API-Key: YOUR_API_KEY',
        'Accept: application/json',
        'User-Agent: MyTempStickApp/1.0',
        'X-Client-Name: MyTempStickApp',
        'X-Client-Version: 1.0',
    ],
]);

$response = curl_exec($curl);

if ($response === false) {
    $error = curl_error($curl);
    curl_close($curl);
    throw new RuntimeException('Temp Stick API request failed: ' . $error);
}

$http_code = curl_getinfo($curl, CURLINFO_HTTP_CODE);
curl_close($curl);

if ($http_code < 200 || $http_code >= 300) {
    throw new RuntimeException('Temp Stick API returned HTTP ' . $http_code . ': ' . $response);
}

echo $response;

?>

const formData = new FormData();

formData.append("sensor_name", "Test");
formData.append("send_interval", "3600");
formData.append("alert_interval", "1800");
formData.append("use_alert_interval", "0");
formData.append("alert_temp_below", "");
formData.append("alert_temp_above", "");
formData.append("alert_humidity_below", "");
formData.append("alert_humidity_above", "");
formData.append("connection_sensitivity", "3");
formData.append("use_offset", "0");
formData.append("temp_offset", "0");
formData.append("humidity_offset", "0");

const headers = new Headers();

headers.append("X-API-Key", "YOUR_API_KEY");
headers.append("Accept", "application/json");
headers.append("User-Agent", "MyTempStickApp/1.0");
headers.append("X-Client-Name", "MyTempStickApp");
headers.append("X-Client-Version", "1.0");

const requestOptions = {
  method: "POST",
  headers: headers,
  body: formData,
  redirect: "follow"
};

fetch("https://tempstickapi.com/api/v1/sensor/YOUR_SENSOR_ID", requestOptions)
  .then(response => {
    if (!response.ok) {
      throw new Error(`Temp Stick API returned HTTP ${response.status}`);
    }

    return response.json();
  })
  .then(result => console.log(result))
  .catch(error => console.error("Temp Stick API request failed:", error));

curl --location --request POST 'https://tempstickapi.com/api/v1/sensor/YOUR_SENSOR_ID' \
  --header 'X-API-Key: YOUR_API_KEY' \
  --header 'Accept: application/json' \
  --header 'User-Agent: MyTempStickApp/1.0' \
  --header 'X-Client-Name: MyTempStickApp' \
  --header 'X-Client-Version: 1.0' \
  --form 'sensor_name=Test' \
  --form 'send_interval=3600' \
  --form 'alert_interval=1800' \
  --form 'use_alert_interval=0' \
  --form 'alert_temp_below=' \
  --form 'alert_temp_above=' \
  --form 'alert_humidity_below=' \
  --form 'alert_humidity_above=' \
  --form 'connection_sensitivity=3' \
  --form 'use_offset=0' \
  --form 'temp_offset=0' \
  --form 'humidity_offset=0'

import requests

url = "https://tempstickapi.com/api/v1/sensor/YOUR_SENSOR_ID"

headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Accept": "application/json",
    "User-Agent": "MyTempStickApp/1.0",
    "X-Client-Name": "MyTempStickApp",
    "X-Client-Version": "1.0",
}

data = {
    "sensor_name": "Test",
    "send_interval": "3600",
    "alert_interval": "1800",
    "use_alert_interval": "0",
    "alert_temp_below": "",
    "alert_temp_above": "",
    "alert_humidity_below": "",
    "alert_humidity_above": "",
    "connection_sensitivity": "3",
    "use_offset": "0",
    "temp_offset": "0",
    "humidity_offset": "0",
}

response = requests.post(url, headers=headers, files={}, data=data, timeout=30)
response.raise_for_status()

result = response.json()
print(result)

First retry: wait 2 seconds
Second retry: wait 5 seconds
Third retry: wait 15 seconds
Additional retries: wait longer, or stop and alert the user

const getBatteryPercentage = voltage => {

  // typical voltage range of sensors is 2.3v to 3.0v
  // (0% to 100%)

  const baseline = 2.30; // lowest allowed voltage
  const remaining_voltage = voltage - baseline;

  let voltagePct = remaining_voltage / 0.007;

  if(voltagePct > 100){ voltagePct = 100; }
  if(voltagePct < 0){ voltagePct = 0; }

  return Math.round(voltagePct);

}

// Import necessary libraries
const {google} = require('googleapis'); // Google's Node.js client library
const axios = require('axios'); // HTTP client
const fs = require('fs'); // Node.js File System module

// Define the path for a JSON file where the application will store data. 
// The application will remember the last 1000 readings per sensor.
const dataFile = __dirname + '/data.json';

// Provide the API key for the Temp Stick service. This is reading a txt file called "temp-stick-api-key" (no extension)
const TEMP_STICK_API_KEY = fs.readFileSync(__dirname + "/temp-stick-api-key");

// Configure the Google JWT (JSON Web Token) authorization object
const auth = new google.auth.JWT({
  // Point to your Google service account file
  keyFile: __dirname + '/config/temp-stick-datalogging.json',
  // Specify the scope that the JWT is allowed to access. 
  // In this case, we're giving it access to Google Sheets.
  scopes: ['https://www.googleapis.com/auth/spreadsheets'],
});

// Initialize the Google Sheets API client
const sheets = google.sheets({version: 'v4', auth});

// Define the ID of the Google Sheets spreadsheet to be accessed. Replace '' with your actual spreadsheet id.
const spreadsheetId = '';

// Create a variable to store historical data. 
let dataHistory = null;

// Check if the file specified by dataFile already exists
if(fs.existsSync(dataFile)) {
  // If it does, read the file and parse its JSON content into the dataHistory variable
  dataHistory = JSON.parse(fs.readFileSync(dataFile));
} else {
  // If it doesn't, initialize dataHistory with an object that has an empty 'alerts' array
  dataHistory = {
    alerts: [],
  };
}

// Define a function to save the current state of dataHistory back into the dataFile
const saveData = () => {
  fs.writeFileSync(dataFile, JSON.stringify(dataHistory));
}

// The getSensors function retrieves sensor data from the Temp Stick API
async function getSensors() {
  try {
    // Send a GET request to the Temp Stick API's 'sensors/all' endpoint
    const response = await axios.get('https://tempstickapi.com/api/v1/sensors/all', {
      headers: {
        'X-API-KEY': TEMP_STICK_API_KEY // Include the Temp Stick API key in the request headers
      },
      timeout: 0, // Do not set a timeout for the request
    });

    const res = response.data; // Extract the data from the response

    // If the API request was successful, return the list of sensor items
    // If not, return false
    if(res.type === 'success') {
      return res.data.items;
    } else {
      return false;
    }

  } catch (error) { // If there's an error in the try block, log it
    console.error(error);
  }
}

// The getAlertNotifications function retrieves alert notifications from the Temp Stick API
async function getAlertNotifications() {
  try {
    // Send a GET request to the Temp Stick API's 'user/notifications' endpoint
    const response = await axios.get('https://tempstickapi.com/api/v1/user/notifications', {
      headers: {
        'X-API-KEY': TEMP_STICK_API_KEY // Include the Temp Stick API key in the request headers
      },
      timeout: 0, // Do not set a timeout for the request
    });

    const res = response.data; // Extract the data from the response

    // If the API request was successful, return the list of notification items
    // If not, return false
    if(res.type === 'success') {
      return res.data.items;
    } else {
      return false;
    }

  } catch (error) { // If there's an error in the try block, log it
    console.error(error);
  }
}

// The getMessages function retrieves messages for a specific sensor from the Temp Stick API
async function getMessages(sensorId) {
  try {
    // Send a GET request to the Temp Stick API's 'sensor/{sensorId}/readings' endpoint
    // The request will include a query string specifying the settings and offset for the readings
    const response = await axios.get(`https://tempstickapi.com/api/v1/sensor/${sensorId}/readings?setting=24_hours&offset=21600`, {
      headers: {
        'X-API-KEY': TEMP_STICK_API_KEY // Include the Temp Stick API key in the request headers
      },
      timeout: 0, // Do not set a timeout for the request
    });

    const res = response.data; // Extract the data from the response

    // If the API request was successful, return the list of readings
    // If not, return false
    if(res.type === 'success') {
      return res.data.readings;
    } else {
      return false;
    }

  } catch (error) { // If there's an error in the try block, log it
    console.error(error);
  }
}

// Function to add alerts to a Google Spreadsheet
async function addAlertsToSheet(alerts) {

  // Initialize an empty array to hold the data
  let data = [];

  // Loop through the alerts array
  for(alert of alerts) {

    // Combine the event type and event message into one string
    let message = alert.event_type + " " + alert.event_message;
    let created = alert.created;

    // Convert the created timestamp into Ontario time
    let ontarioTime = new Date(created).toLocaleString("en-US", {
      timeZone: "America/Toronto",
    });

    // Add a new row of data for each alert
    data.push([
      alert.sensor_id,
      message,
      ontarioTime,
    ])
  }

  // Sort the data array by date
  data = data.sort((a, b) => {
    return new Date(b[2]) - new Date(a[2]);
  });

  const sheetName = 'Alerts'; // replace with your sheet name

  // Get the spreadsheet details
  const spreadsheet = await sheets.spreadsheets.get({
    auth,
    spreadsheetId,
  });

  // Find the sheetId of the sheet with the given name
  const sheet = spreadsheet.data.sheets.find(sheet => sheet.properties.title === sheetName);
  const sheetId = sheet.properties.sheetId;

  // Insert rows into the spreadsheet
  await sheets.spreadsheets.batchUpdate({
    auth,
    spreadsheetId,
    resource: {
      requests: [{
        insertDimension: {
          range: {
            sheetId: sheetId,
            dimension: 'ROWS',
            startIndex: 1,
            endIndex: 1 + data.length
          },
          inheritFromBefore: false
        }
      }]
    }
  });

  // Update the spreadsheet with the new data
  await sheets.spreadsheets.values.update({
    auth,
    spreadsheetId,
    range: sheetName + '!A2', // assuming that your data starts from column A and the header is in the first row
    valueInputOption: 'USER_ENTERED',
    resource: { values: data },
  });

}

// Function to add sensor readings to a Google Spreadsheet
async function addSensorValuesToSheet(newReadings) {

  // Initialize an empty array to hold the data
  let data = [];

  // Loop through the readings array
  for(reading of newReadings) {

    // Grab the necessary values from the reading
    let tempC = reading.temperature;
    let tempF = (tempC * 9/5 + 32).toFixed(1); // Convert the temperature to Fahrenheit
    let humidity = reading.humidity;
    let checkin = reading.sensor_time;

    // Convert the check-in time to Ontario time
    let ontarioTime = new Date(checkin).toLocaleString("en-US", {
      timeZone: "America/Toronto",
    });

    let rssi = reading.rssi;
    let time_to_connect = reading.time_to_connect;
    let battery_pct = getBatteryPercentage(reading.voltage); // Get the battery percentage

    // Add a new row of data for each reading
    data.push([
      reading.sensor_id,
      tempC,
      tempF,
      humidity,
      rssi,
      time_to_connect,
      battery_pct,
      reading.offline,
      ontarioTime,
    ])
  }

  // Sort the data array by date
  data = data.sort((a, b) => {
    return new Date(b[8]) - new Date(a[8]);
  });

  const sheetName = 'Readings'; // replace with your sheet name

  // Insert rows into the spreadsheet
  await sheets.spreadsheets.batchUpdate({
    auth,
    spreadsheetId,
    resource: {
      requests: [{
        insertDimension: {
          range: {
            sheetId: 0,
            dimension: 'ROWS',
            startIndex: 1,
            endIndex: 1 + data.length
          },
          inheritFromBefore: false
        }
      }]
    }
  });

  // Update the spreadsheet with the new data
  await sheets.spreadsheets.values.update({
    auth,
    spreadsheetId,
    range: sheetName + '!A2', // assuming that your data starts from column A and the header is in the first row
    valueInputOption: 'USER_ENTERED',
    resource: { values: data },
  });

}

// Function to process the alerts
const processAlerts = async () => {
  // Fetch alert notifications
  const alerts = await getAlertNotifications();

  // Initialize an empty array for new alerts
  const newAlerts = [];

  // Loop over all alerts
  for(let alert of alerts) {
    // Check if the alert already exists in the history
    let alertExists = false;
    for(let existingAlert of dataHistory.alerts) {
      if(existingAlert.id === alert.id) {
        alertExists = true;
        break;
      }
    }

    // If the alert doesn't exist, add it to the new alerts array
    if (!alertExists) {
      newAlerts.unshift(alert);
    }
  }

  // Add new alerts to the history and limit history size to 1000 entries
  dataHistory.alerts = [...newAlerts, ...dataHistory.alerts];
  if(dataHistory.alerts.length > 1000) {
    dataHistory.alerts = dataHistory.alerts.slice(0, 1000);
  }

  // Add new alerts to the Google Sheet and save data
  await addAlertsToSheet(newAlerts);
  saveData();
};

// Function to process sensor data
const processSensors = async () => {
  // Fetch sensors data
  const sensors = await getSensors();

  // Process alerts after 60 seconds to allow for data to come in
  setTimeout(processAlerts, 60000);

  // If sensors are available
  if (sensors && sensors.length > 0) {
    let nextCheckIn = null;
    const now = new Date();
    const batchUpdate = [];

    // Loop over all sensors
    for (let sensor of sensors) {

      // If there's no history for this sensor, create a new array for it
      if(!dataHistory[sensor.sensor_id]) {
        dataHistory[sensor.sensor_id] = [];
      }

      // Get messages for each sensor
      const readings = await getMessages(sensor.sensor_id);
      const newReadings = [];

      // Loop over all readings
      for(let reading of readings) {
        reading.sensor_id = sensor.sensor_id;
        let readingExists = false;

        // Check if the reading already exists in the history
        for(let existingReading of dataHistory[sensor.sensor_id]) {
          if(existingReading.sensor_time === reading.sensor_time) {
            readingExists = true;
            break;
          }
        }

        // If the reading doesn't exist, add it to the new readings array and batch update array
        if (!readingExists) {
          newReadings.unshift(reading);
          batchUpdate.push(reading);
        }
      }

      // Add new readings to the history and limit history size to 1000 entries
      dataHistory[sensor.sensor_id] = [...newReadings, ...dataHistory[sensor.sensor_id]];
      if(dataHistory[sensor.sensor_id].length > 1000) {
        dataHistory[sensor.sensor_id] = dataHistory[sensor.sensor_id].slice(0, 1000);
      }

      // Calculate the next check-in time
      let sensorNextCheckIn = new Date(sensor.next_checkin + "Z");
      while (sensorNextCheckIn <= now) {
        sensorNextCheckIn = new Date(sensorNextCheckIn.getTime() + 60000);
      }
      if (!nextCheckIn || sensorNextCheckIn < nextCheckIn) {
        nextCheckIn = sensorNextCheckIn;
      }
    }

    // If there are any new readings, add them to the Google Sheet
    if(batchUpdate.length > 0) {
      await addSensorValuesToSheet(batchUpdate);
    }

    // Save the data
    saveData();

    // Calculate sleep time until the next check-in
    if (nextCheckIn) {
      let sleepTime = nextCheckIn.getTime() - now.getTime() + 60 * 1000;
      if(sleepTime < 0) {
        sleepTime = 15000;
      }

      // Delay the next sensor process by sleep time
      if (sleepTime > 0) {
        console.log(`Sleeping for ${sleepTime / 1000} seconds...`);
        setTimeout(processSensors, sleepTime);
      } else {
        // always sleep for 60 seconds although this should never process
        setTimeout(processSensors, 60000);
      }
    } else {
      console.log('No next check-in time. Exiting...');
    }
  } else {
    console.log('No sensors. Exiting...');
  }
};

// Start processing the sensors
processSensors();