Source: https://cli.nylas.com/guides/calendar-attendee-tracking-cli

# Track Calendar Attendee Responses

Every attendee you invite carries an RSVP status the calendar already tracks. This guide reads accepted, declined, and no-response state straight from the event JSON, counts each bucket, and emails the people who never replied — calendar attendee tracking without opening a single calendar UI.

Written by [Pouya Sanooei](https://cli.nylas.com/authors/pouya-sanooei) Software Engineer

Reviewed by [Qasim Muhammad](https://cli.nylas.com/authors/qasim-muhammad)

Updated June 9, 2026

> **TL;DR:** Run `nylas calendar events show <id> --json` and read the `participants[].status` field: every attendee is `yes`, `no`, `maybe`, or `noreply`. Filter for the silent ones and email them — the one-pass script is at the bottom.

## 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.

```bash
# 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.

```bash
# 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.

```bash
# 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.

```bash
# 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.

```bash
#!/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

- [Google Calendar API Quotas and Limits](https://cli.nylas.com/guides/google-calendar-api-quotas) — Google Calendar API quota reference
- [Track event RSVPs from the CLI](https://cli.nylas.com/guides/event-rsvp-tracking-cli) — the companion guide on monitoring invite responses over time
- [Create calendar invites](https://cli.nylas.com/guides/create-calendar-invites-cli) — send the invites whose responses you track here
- [RSVP to calendar invites](https://cli.nylas.com/guides/rsvp-to-calendar-invites-cli) — accept, decline, or tentatively answer invites yourself
- [Relay email to a webhook](https://cli.nylas.com/guides/email-to-webhook-relay) — pipe reminder activity into another system as it happens
- [Save email to SQLite](https://cli.nylas.com/guides/email-to-sqlite) — archive the reminders you send into a queryable table
- [Command reference](https://cli.nylas.com/docs/commands) — every flag, subcommand, and example
- [Google Calendar API: events reference](https://developers.google.com/workspace/calendar/api/v3/reference/events) — the attendee responseStatus field behind Google events
- [Microsoft Graph: attendee resource](https://learn.microsoft.com/en-us/graph/api/resources/attendee) — the equivalent response-status model for Outlook
- [RFC 5545 — iCalendar](https://datatracker.ietf.org/doc/html/rfc5545) — the PARTSTAT property that standardizes RSVP states