Track Calendar Attendee Responses

Where does the calendar store each attendee's response?

The response lives in the event itself. When you run nylas calendar events show with --json, every entry in the participants array carries an email and a status. There are exactly 4 status values, so the entire RSVP state of a 50-person meeting fits in one object.

The four values are yes (accepted), no (declined), maybe (tentative), and noreply for anyone who hasn't answered. A fresh invite starts every attendee at noreply and flips to one of the other three the moment they click a button in their calendar client.

# Dump one event as JSON and look at the participants block
nylas calendar events show evt_abc123 --json | jq '.participants'

# [
#   { "email": "lead@company.com",  "status": "yes" },
#   { "email": "eng@company.com",   "status": "no" },
#   { "email": "intern@company.com","status": "noreply" }
# ]

How do I list who accepted, declined, or hasn't responded?

List the responses by piping nylas calendar events show --json into jq and printing each attendee's email beside their status. One command turns a 12-person invite into a flat, sorted roster you can scan in a couple of seconds, with no calendar UI involved.

The jq filter below walks the participants array and emits one tab-separated line per attendee. Sorting by status groups all the noreply rows together, so the people you still need to chase land in a single block at the end. This works identically on Google and Outlook events because the status field is normalized by the API.

# One line per attendee: email then status, grouped by response
nylas calendar events show evt_abc123 --json \
  | jq -r '.participants[] | "\(.status)\t\(.email)"' \
  | sort

# no       eng@company.com
# noreply  intern@company.com
# noreply  newhire@company.com
# yes      lead@company.com

How do I get a headcount for each response type?

Get a headcount by grouping the participants on their status and counting each group. For a 20-person all-hands you usually want one number per bucket — how many accepted, how many declined, how many are still silent — not the full roster. A single jq expression produces that summary.

The filter uses group_by(.status) to bucket the attendees, then prints each status with its count. If the accepted count clears your quorum — say 8 of 12 for a decision meeting — you can skip the chase entirely. The output is two columns, so it drops straight into a stand-up note or a Slack update.

# Count attendees per response status
nylas calendar events show evt_abc123 --json \
  | jq -r '.participants | group_by(.status)[] | "\(.[0].status): \(length)"'

# no: 1
# noreply: 2
# yes: 1

How do I email the people who haven't responded?

Email the non-responders by filtering the participants for status == "noreply", pulling their addresses, and passing them to nylas email send. The two commands chain in one line, so you never copy an address by hand. A nudge sent within 24 hours of the invite measurably lifts reply rates.

The --to flag accepts a comma-separated list, which is exactly what the jq filter and paste produce. The --yes flag skips the interactive confirmation so the command runs unattended in a script or a cron job.

# Collect the silent attendees, then send one reminder to all of them
PENDING=$(nylas calendar events show evt_abc123 --json \
  | jq -r '.participants[] | select(.status == "noreply") | .email' \
  | paste -sd, -)

nylas email send --to "$PENDING" \
  --subject "Quick RSVP: are you joining Thursday's review?" \
  --body "Haven't seen your response yet — please accept or decline the invite." --yes

How do I run attendee tracking as one script?

The full loop reads the event once, prints a status summary, then emails only the people still at noreply. The script below caches the JSON in a variable so it hits the calendar a single time, and it exits cleanly when everyone has already replied — the one case worth a guard, since sending a reminder to nobody would still fire an empty email.

#!/usr/bin/env bash
set -euo pipefail
EVENT_ID="evt_abc123"

EVENT=$(nylas calendar events show "$EVENT_ID" --json)

echo "Response summary:"
echo "$EVENT" | jq -r '.participants | group_by(.status)[] | "  \(.[0].status): \(length)"'

PENDING=$(echo "$EVENT" \
  | jq -r '.participants[] | select(.status == "noreply") | .email' \
  | paste -sd, -)

[ -z "$PENDING" ] && { echo "Everyone has responded."; exit 0; }

nylas email send --to "$PENDING" \
  --subject "Reminder: please RSVP" \
  --body "We still need your response on the calendar invite — accept or decline when you can." --yes

Next steps

• Track event RSVPs from the CLI — the companion guide on monitoring invite responses over time
• Create calendar invites — send the invites whose responses you track here
• RSVP to calendar invites — accept, decline, or tentatively answer invites yourself
• Relay email to a webhook — pipe reminder activity into another system as it happens
• Save email to SQLite — archive the reminders you send into a queryable table
• Command reference — every flag, subcommand, and example
• Google Calendar API: events reference — the attendee responseStatus field behind Google events
• Microsoft Graph: attendee resource — the equivalent response-status model for Outlook
• RFC 5545 — iCalendar — the PARTSTAT property that standardizes RSVP states