Use the free Open-Meteo weather API, which doesn't need a key, to get tomorrow's total rainfall forecast for latitude 40.25 and longitude -111.65, and log it.send

This task needs one new tool: UrlFetchApp.fetch(url), which is the Apps Script method for calling a web address and getting back its response. It's how you talk to an API like Open-Meteo. You'll also use two small helper pieces that go with it:

• .getContentText() — pulls the plain text out of the response UrlFetchApp.fetch() gives you
• Session.getScriptTimeZone() — gets the time zone your script is set to, so Utilities.formatDate() can use it

Everything else in the code below uses concepts you already know: template literals, JSON.parse, parallel arrays, and a for loop search.

Here's the plan: build tomorrow's date as text, ask Open-Meteo for the daily rainfall forecast, then search for the row that matches tomorrow's date.

// Settings for the location, kept at the top so they're easy to find and change
const LATITUDE = 40.25
const LONGITUDE = -111.65

function logTomorrowRainfall() {
  // Figure out tomorrow's date
  const today = new Date()
  const tomorrow = new Date()
  tomorrow.setDate(today.getDate() + 1)

  // Turn tomorrow's date into text like "2025-05-21" to match the API's format
  const timeZone = Session.getScriptTimeZone()
  const tomorrowText = Utilities.formatDate(tomorrow, timeZone, "yyyy-MM-dd")

  // Build the web address to ask Open-Meteo for daily rainfall totals
  const url = `https://api.open-meteo.com/v1/forecast?latitude=${LATITUDE}&longitude=${LONGITUDE}&daily=precipitation_sum&timezone=auto`

  // Fetch the data from the API and turn it into an object
  const response = UrlFetchApp.fetch(url)
  const responseText = response.getContentText()
  const data = JSON.parse(responseText)

  // The API gives back two parallel arrays: dates and rainfall amounts
  const dates = data.daily.time
  const rainfallAmounts = data.daily.precipitation_sum

  // Search the dates array for the index that matches tomorrow
  let tomorrowIndex = -1
  for (let i = 0; i < dates.length; i++) {
    if (dates[i] === tomorrowText) {
      tomorrowIndex = i
    }
  }

  // Log the result, or say if it wasn't found
  if (tomorrowIndex === -1) {
    Logger.log("Tomorrow's forecast was not found")
  } else {
    const tomorrowRainfall = rainfallAmounts[tomorrowIndex]
    Logger.log(`Tomorrow's total rainfall forecast: ${tomorrowRainfall} mm`)
  }
}

A couple of notes:

• The first time you run this, Apps Script will ask you to authorize it, since fetching a web address needs permission (even though this API doesn't need a key).
• This is a read-only call — it doesn't send email, touch Calendar, or change Drive files — so there's no need for a dry run here.

Want me to explain any part of this in more depth, like how the JSON structure from the API is shaped?

This will run every morning on a trigger. What happens if the weather service is down, or sends back an error? How should the code handle that?send

Good question — right now, if Open-Meteo is down or sends back bad data, UrlFetchApp.fetch() will throw an error and stop the script. Since this runs on a trigger with nobody watching, that error just sits on the Executions page (which you already know how to check) — but you won't get any warning unless you go look.

This needs one new concept: try/catch. It lets you say "try these steps, and if any of them cause an error, do something else instead of stopping the whole script." It looks like this:

try {
  // steps that might fail
} catch (error) {
  // steps to run instead, if something above failed
}

Here's the updated code using it:

// Settings for the location, kept at the top so they're easy to find and change
const LATITUDE = 40.25
const LONGITUDE = -111.65

function logTomorrowRainfall() {
  // Figure out tomorrow's date
  const today = new Date()
  const tomorrow = new Date()
  tomorrow.setDate(today.getDate() + 1)

  // Turn tomorrow's date into text like "2025-05-21" to match the API's format
  const timeZone = Session.getScriptTimeZone()
  const tomorrowText = Utilities.formatDate(tomorrow, timeZone, "yyyy-MM-dd")

  // Build the web address to ask Open-Meteo for daily rainfall totals
  const url = `https://api.open-meteo.com/v1/forecast?latitude=${LATITUDE}&longitude=${LONGITUDE}&daily=precipitation_sum&timezone=auto`

  // Try to fetch and read the data, and catch it if anything goes wrong
  try {
    const response = UrlFetchApp.fetch(url)
    const responseText = response.getContentText()
    const data = JSON.parse(responseText)

    // The API gives back two parallel arrays: dates and rainfall amounts
    const dates = data.daily.time
    const rainfallAmounts = data.daily.precipitation_sum

    // Search the dates array for the index that matches tomorrow
    let tomorrowIndex = -1
    for (let i = 0; i < dates.length; i++) {
      if (dates[i] === tomorrowText) {
        tomorrowIndex = i
      }
    }

    if (tomorrowIndex === -1) {
      Logger.log("Tomorrow's forecast was not found in the response")
    } else {
      const tomorrowRainfall = rainfallAmounts[tomorrowIndex]
      Logger.log(`Tomorrow's total rainfall forecast: ${tomorrowRainfall} mm`)
    }

  } catch (error) {
    // This runs if fetch(), getContentText(), JSON.parse(), or anything else above failed
    Logger.log(`Could not get rainfall forecast: ${error}`)
  }
}

A few notes on how this behaves:

• If Open-Meteo is completely unreachable, UrlFetchApp.fetch() throws an error, and the catch block logs it instead of the script crashing silently.
• If Open-Meteo responds but with an error status (like a server error), fetch() also throws by default — so that's caught too.
• If the response comes back but isn't shaped the way you expect (missing data), JSON.parse() or reading data.daily.time might fail, and that's caught as well.

Setting up the trigger: 1. In the Apps Script editor, click the clock icon ("Triggers") in the left sidebar. 2. Click Add Trigger. 3. Choose logTomorrowRainfall as the function to run. 4. Set the event source to Time-driven, then pick Day timer and choose a morning time range.

Testing without waiting: Just select logTomorrowRainfall in the function dropdown at the top of the editor and click Run. Since it's not tied to onEdit or onOpen, it doesn't need a fake event object — you can run it directly anytime.

Would you like to also have it email you if the fetch fails, so you don't have to check the Executions page yourself?

Instead of email, our club has a Discord channel with an incoming webhook. If less than 2 mm of rain is expected tomorrow, post a message to the channel saying the beds need watering. How do I do that, and where should I keep the webhook address?send

This needs two new things:

1. PropertiesService — a way to store a value (like a secret webhook address) outside your code, so it's not sitting in plain text in a file that other club members might see if they open the script. You set it once through the editor, then read it in code with PropertiesService.getScriptProperties().getProperty("KEY_NAME").

2. An options object for UrlFetchApp.fetch() — so far you've only used fetch(url) to read data. To send data (a message) to Discord, you pass a second argument describing the request: what method to use (post), what kind of data you're sending (application/json), and the actual message (payload). It looks like this:

UrlFetchApp.fetch(url, {
  method: "post",
  contentType: "application/json",
  payload: JSON.stringify({ content: "some message" })
})

Setting up the webhook address: 1. In the Apps Script editor, click the gear icon ("Project Settings") in the left sidebar. 2. Scroll to Script Properties and click Add script property. 3. Set the property name to DISCORD_WEBHOOK_URL and paste in your Discord webhook address as the value. 4. Save.

Since posting to Discord is an external action with a visible effect (like sending email), I've written it as a dry run first — it logs what it would post instead of actually posting. Here's the code:

// Settings for the location, kept at the top so they're easy to find and change
const LATITUDE = 40.25
const LONGITUDE = -111.65
const RAIN_THRESHOLD_MM = 2

function logTomorrowRainfall() {
  // Figure out tomorrow's date
  const today = new Date()
  const tomorrow = new Date()
  tomorrow.setDate(today.getDate() + 1)

  // Turn tomorrow's date into text like "2025-05-21" to match the API's format
  const timeZone = Session.getScriptTimeZone()
  const tomorrowText = Utilities.formatDate(tomorrow, timeZone, "yyyy-MM-dd")

  // Build the web address to ask Open-Meteo for daily rainfall totals
  const url = `https://api.open-meteo.com/v1/forecast?latitude=${LATITUDE}&longitude=${LONGITUDE}&daily=precipitation_sum&timezone=auto`

  try {
    const response = UrlFetchApp.fetch(url)
    const responseText = response.getContentText()
    const data = JSON.parse(responseText)

    // The API gives back two parallel arrays: dates and rainfall amounts
    const dates = data.daily.time
    const rainfallAmounts = data.daily.precipitation_sum

    // Search the dates array for the index that matches tomorrow
    let tomorrowIndex = -1
    for (let i = 0; i < dates.length; i++) {
      if (dates[i] === tomorrowText) {
        tomorrowIndex = i
      }
    }

    if (tomorrowIndex === -1) {
      Logger.log("Tomorrow's forecast was not found in the response")
    } else {
      const tomorrowRainfall = rainfallAmounts[tomorrowIndex]
      Logger.log(`Tomorrow's total rainfall forecast: ${tomorrowRainfall} mm`)

      // If not enough rain is expected, post an alert
      if (tomorrowRainfall < RAIN_THRESHOLD_MM) {
        const message = `Only ${tomorrowRainfall} mm of rain expected tomorrow — the beds need watering!`
        postToDiscord(message)
      }
    }

  } catch (error) {
    Logger.log(`Could not get rainfall forecast: ${error}`)
  }
}

// Posts a message to the club's Discord channel using the incoming webhook
function postToDiscord(message) {
  const properties = PropertiesService.getScriptProperties()
  const webhookUrl = properties.getProperty("DISCORD_WEBHOOK_URL")

  // Discord expects the message inside an object with a "content" property
  const payload = JSON.stringify({ content: message })

  // DRY RUN: log what would be sent instead of actually sending it
  Logger.log(`Would post to Discord: ${message}`)

  // When you're ready to send for real, uncomment the lines below
  // const options = {
  //   method: "post",
  //   contentType: "application/json",
  //   payload: payload
  // }
  // UrlFetchApp.fetch(webhookUrl, options)
}

Testing this without waiting for tomorrow's real forecast: You can temporarily change the if (tomorrowRainfall < RAIN_THRESHOLD_MM) line to something like if (true) to force the alert branch to run, then change it back afterward.

Once you've checked the Execution log and are happy with the dry run message, just let me know and I'll show you the version with the real UrlFetchApp.fetch() call turned on.