You've built an email agent, it works, and now it checks its inbox by calling the API every 30 seconds — burning requests all night to discover, 2,879 times out of 2,880, that nothing happened.

Polling is the duct tape of inbox architectures. It's also, sometimes, the right call. If you're giving an agent its own mailbox with Nylas Agent Accounts (currently in beta), both patterns are supported out of the box, and the docs are refreshingly non-dogmatic about which to use. Here's the actual tradeoff.

Option 1: subscribe once, react instantly

Register a webhook with the message.created trigger and your endpoint gets an HTTP POST as soon as mail lands in the agent's mailbox:

curl --request POST \
  --url "https://api.us.nylas.com/v3/webhooks" \
  --header "Authorization: Bearer $NYLAS_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "trigger_types": ["message.created"],
    "callback_url": "https://yourapp.example.com/webhooks/nylas"
  }'

The payload carries the message metadata — grant_id, subject, from, snippet, id — so your handler can fetch the full body or update state without guessing. Here's what actually arrives for an Agent Account:

{
  "specversion": "1.0",
  "type": "message.created",
  "id": "<WEBHOOK_ID>",
  "time": 1723821985,
  "webhook_delivery_attempt": 1,
  "data": {
    "application_id": "<NYLAS_APPLICATION_ID>",
    "object": {
      "object": "message",
      "id": "<MESSAGE_ID>",
      "grant_id": "<NYLAS_GRANT_ID>",
      "subject": "Hello from Nylas",
      "from": [{ "email": "sender@example.com", "name": "Sender" }],
      "to": [{ "email": "test@your-application.nylas.email", "name": "" }],
      "date": 1723821981,
      "snippet": "This is a sample message"
    }
  }
}

Note webhook_delivery_attempt right there in the envelope — the platform is telling you redelivery is part of the contract. And because the subscription is application-level with grant_id in every payload, one webhook covers your entire fleet of agent mailboxes; you don't subscribe per account.

There are 43 trigger types overall, spanning messages, threads, calendars, events, contacts, folders, grants, and more, so the same channel that announces inbound mail can also report calendar changes or grant lifecycle events. (If your app also handles connected human accounts, subscribing to grant.expired in the same array tells you when one needs re-authentication — Agent Accounts themselves rarely expire, since there's no OAuth token underneath.)

The handshake, precisely

Two operational requirements come with the subscription. First, when you create or activate the webhook, Nylas sends a GET request with a challenge query parameter; your endpoint must echo the exact value back in the body of a 200 OK — no quotes, no extra data — within 10 seconds. Completing that handshake is also what generates your webhook_secret. Second, every subsequent notification must get a 200 OK within the same 10-second budget, so ack first, process async.

Each notification also carries an X-Nylas-Signature header: a hex-encoded HMAC-SHA256 of the raw request body, signed with that webhook_secret. Recompute it over the unmodified body and compare before trusting the payload — a forged POST to your endpoint should never make your agent send email.

Worth a paragraph of perspective: this is dramatically simpler than provider-native push. Gmail's push API wants a Cloud Pub/Sub topic and a mailbox re-watch every 7 days; Microsoft Graph wants per-resource subscriptions renewed roughly every 3 days; IMAP wants a persistent connection you babysit. The unified webhook needs one POST and no renewal.

Option 2: just ask

Polling is a GET on a timer:

curl --request GET \
  --url "https://api.us.nylas.com/v3/grants/<GRANT_ID>/messages?limit=5" \
  --header "Authorization: Bearer $NYLAS_API_KEY"

No public HTTPS endpoint, no signature verification, no challenge handshake, no retry semantics to reason about. The cost is the polling triangle: latency (you find out on your schedule, not the event's), waste (most polls return nothing), and rate pressure (frequent polling across many mailboxes adds up fast).

The comparison that actually matters

When polling is honestly fine

The case for polling is stronger than webhook advocates admit:

• Batch workflows. An agent that summarizes the inbox every morning gains nothing from second-level latency.
• Prototypes and local dev. A poll loop runs on your laptop; a webhook needs a public URL or a tunnel. The quickstart lists polling first for exactly this reason.
• Low-stakes timing. If a 5-minute delay changes nothing about the outcome, the simplest thing that works wins.

The case against polling kicks in when the agent is conversational. A prospect replies to your sales agent and waits. Every minute of polling interval is a minute of dead air, multiplied across every conversation. That's when push earns its infrastructure.

The hybrid most teams land on

Webhooks as the primary signal, polling as the reconciler. Webhook delivery is at-least-once, not exactly-once — so a periodic sweep of GET /messages catches anything that slipped through, while dedup (keyed on message id) handles anything delivered twice. You get real-time reactions with a batch-mode safety net, and the polling cadence can be lazy — every 10 or 15 minutes — because it's no longer the primary path.

One more thing the quickstart calls out: the message.created payload for an Agent Account is identical in shape to the same trigger for a connected Gmail or Outlook grant. If your app handles both, one handler covers everything; branch on the grant's provider field ("nylas") when you need to treat agent mail differently.

Concrete next step: take the Agent Accounts quickstart, set up both paths — webhook subscription plus a poll loop — and time the gap between them for a real inbound message. The real-time webhooks guide has the full trigger catalog when you're ready to subscribe to more than mail.