azure-event-grid-webhooks

--- name: azure-event-grid-webhooks description: > Receive and validate Azure Event Grid webhook deliveries. Use when setting up an Event Grid WebHook event handler, implementing the Microsoft.EventGrid.SubscriptionValidationEvent handshake (echo data.validationCode as validationResponse with HTTP 200), implementing the CloudEvents v1.0 HTTP OPTIONS abuse-protection preflight (WebHook-Request-Origin / WebHook-Allowed-Origin), checking the aeg-subscription-name / aeg-event-type / aeg-delivery-count headers, authenticating deliveries with a static delivery-property header or a Microsoft Entra ID bearer token, parsing Event Grid schema arrays vs CloudEvents objects, or handling events like Microsoft.Storage.BlobCreated. Event Grid does NOT sign the request body — there is no HMAC signature. license: MIT metadata: author: hookdeck version: "0.1.0" repository: https://github.com/hookdeck/webhook-skills ---

# Azure Event Grid Webhooks

## When to Use This Skill

- How do I receive Azure Event Grid events at an HTTP endpoint? - How do I verify an Azure Event Grid webhook? Where is the signature header? - How do I handle `Microsoft.EventGrid.SubscriptionValidationEvent`? - Why is my Event Grid event subscription stuck in `AwaitingManualAction` or `Failed`? - What is `WebHook-Request-Origin` / `WebHook-Allowed-Origin` and why is Event Grid sending me an HTTP OPTIONS request? - How do I authenticate Event Grid deliveries with a custom header, a query-parameter secret, or Microsoft Entra ID? - How do I parse `Microsoft.Storage.BlobCreated` from an Event Grid array vs a CloudEvents object?

## There Is No Signature — Read This First

Event Grid is a managed pub/sub broker, not a single-vendor webhook signer.

- **Event Grid does not sign the request body.** There is no `X-Signature`, no HMAC, no shared signing secret, no timestamp+signature pair, no asymmetric signature. **Do not write a `crypto.createHmac` / `hmac.new` verifier for Event Grid** — there is nothing to verify against. - Security comes from two other things, and a production handler needs both:

| Layer | What it proves | Mechanism | |-------|----------------|-----------| | **Handshake** (subscription time) | You own the endpoint and expected this subscription | `SubscriptionValidationEvent` echo, or the CloudEvents OPTIONS preflight | | **Channel auth** (every delivery) | The caller is who you configured | A static [delivery-property](references/verification.md) header you choose, a client secret in a query parameter, or a Microsoft Entra ID bearer token |

- Because nothing is signed, there is **no raw-body requirement**. Parsing JSON before authenticating is safe here in a way it never is for Stripe or Shopify.

> If you are looking at Hookdeck's `AZURE_EVENT_GRID` source config and see HMAC > / Basic Auth / API Key options: those configure a header **you** attach via > Event Grid delivery properties. Azure computes no HMAC over the payload.

## Two Handshakes — Which One Fires Depends on the Delivery Schema

| Event subscription's delivery schema | Handshake | Method | |--------------------------------------|-----------|--------| | **Event Grid schema** (`eventgridschema`) | `Microsoft.EventGrid.SubscriptionValidationEvent` — echo the code | `POST` | | **CloudEvents v1.0 schema** (`cloudeventschemav1_0`) | CloudEvents abuse protection preflight | `OPTIONS` |

Verbatim from the docs: *"When you use the CloudEvents schema for output, Event Grid uses the CloudEvents v1.0 abuse protection **in place of** the Event Grid validation event mechanism."* Implement both — one handler, two paths.

## Validation Handshake (core)

Event Grid POSTs a JSON **array** containing only the validation event, with header `aeg-event-type: SubscriptionValidation`. Gate on `aeg-subscription-name` first: withholding the echo is how you deliberately fail validation for a subscription you did not create.

```javascript const VALIDATION_EVENT = 'Microsoft.EventGrid.SubscriptionValidationEvent';

// Event Grid schema arrives as an ARRAY; CloudEvents as a single OBJECT. const events = Array.isArray(body) ? body : [body]; const validation = events.find((e) => e && e.eventType === VALIDATION_EVENT);

if (validation) { const subscription = String(req.get('aeg-subscription-name') || '').toLowerCase(); // An attacker who learns your URL can point their own subscription at it. if (!EXPECTED_SUBSCRIPTIONS.includes(subscription)) { return res.sendStatus(403); // No 200, no echo => validation fails. Intended. } // MUST be 200 — "HTTP 202 Accepted isn't recognized as a valid Event Grid // subscription validation response" — and must complete within 30 seconds. return res.status(200).json({ validationResponse: validation.data.validationCode }); } ```

The documented response field is camelCase `validationResponse`. Microsoft's own C#/JS samples on the receive-events page emit PascalCase `ValidationResponse`; the docs do not state whether matching is case-sensitive, so use the documented camelCase form.

## CloudEvents Abuse-Protection Preflight (core)

```javascript // OPTIONS on the exact endpoint URI being registered. Consent is signalled by // the HEADERS, not the status code. app.options('/webhooks/azure-event-grid', (req, res) => { const origin = req.get('WebHook-Request-Origin'); // e.g. eventemitter.example.com if (!origin || !isAllowedOrigin(origin)) return res.sendStatus(403); // withhold consent res.set('WebHook-Allowed-Origin', origin); // or '*' res.set('WebHook-Allowed-Rate', '120'); // requests per minute, or '*' res.set('Allow', 'POST, OPTIONS'); res.sendStatus(200); }); ```

This handshake *"doesn't aim to establish an authentication or authorization context"* — it only proves the endpoint expects traffic. Channel auth still matters.

## Channel Authentication (core)

The practical shared-secret path is a **static delivery property**: a custom header you configure on the event subscription and compare server-side. Never name it with the reserved `aeg-` prefix.

```javascript const crypto = require('crypto');

function checkDeliverySecret(received, expected) { if (!expected) return false; // Fail CLOSED when unconfigured. const a = Buffer.from(String(received || '')); const b = Buffer.from(expected); if (a.length !== b.length) return false; // timingSafeEqual throws on length mismatch return crypto.timingSafeEqual(a, b); } ```

The second shared-secret path is a **client secret as a query parameter**. You append it to the subscription's endpoint URL and *"Event Grid service includes all the query parameters in every event delivery request to the webhook"*:

```bash az eventgrid event-subscription create ... \ --endpoint "https://example.com/webhooks/azure-event-grid?token=<secret>" ```

Azure stores these encrypted, keeps them out of service logs and traces, and withholds them when you read the subscription back unless you pass `--include-full-endpoint-url`.

**Rotation is the trap.** The docs: *"If you update the client secret, you also need to update the event subscription. To avoid delivery failures during this secret rotation, make the webhook accept both old and new secrets for a limited duration before updating the event subscription with the new secret."* So accept a *list*, not a single value, and compare in constant time against every entry:

```javascript function checkAgainstAny(received, expectedCsv) { const accepted = String(expectedCsv || '').split(',').map((v) => v.trim()).filter(Boolean); if (accepted.length === 0) return false; // Fail CLOSED — "unset" is never "allow all". // No early return: timing must not leak which secret in the set matched. return accepted.reduce((hit, c) => checkDeliverySecret(received, c) || hit, false); } ```

Do not lowercase the accepted list while parsing it — secrets are case-sensitive, and a shared `parseList` helper that normalises subscription names will silently break secret comparison.

For Microsoft Entra ID protected endpoints, Event Grid *"is now passing the Microsoft Entra bearer token to the webhook client in every message. You need to validate the authorization token in your webhook."* Validate it as a normal JWT against your own Entra application (`jsonwebtoken` + `jwks-rsa`, or PyJWT + `PyJWKClient`) — see [references/verification.md](references/verification.md). Microsoft does not publish the token's claim set, so do not hard-code claims.

> **For complete handlers with both handshakes, all three channel-auth modes, schema normalisation, and tests**, see [examples/express/](examples/express/), [examples/nextjs/](examples/nextjs/), [examples/fastapi/](examples/fastapi/).

## Message Headers

| Header | Description | |--------|-------------| | `aeg-subscription-name` | Name of the event subscription — **check this** | | `aeg-delivery-count` | Number of attempts made for the event (retry signal) | | `aeg-event-type` | `SubscriptionValidation`, `Notification`, or `SubscriptionDeletion` | | `aeg-metadata-version` | Event Grid schema: metadata version. CloudEvents: the spec version | | `aeg-data-version` | Event Grid schema: data version. Not applicable for CloudEvents | | `aeg-output-event-id` | ID of the Event Grid event |

`Content-Type` is `application/json; charset=utf-8` for Event Grid schema and `application/cloudevents+json; charset=utf-8` for CloudEvents schema.

## Payload Shapes

**Event Grid schema — a JSON array.** *"Event Grid sends the events to subscribers in an array that has a single event."* Batching is off by default but configurable up to 5,000 events, so **always loop**.

```json [{ "topic": "/subscriptions/...", "subject": "/blobServices/default/containers/c/blobs/f.jpg", "eventType": "Microsoft.Storage.BlobCreated", "id": "aaaa0a0a-...", "data": { "api": "PutBlob", "url": "https://...", "contentLength": 52577 }, "dataVersion": "", "metadataVersion": "1", "eventTime": "2024-12-06T03:32:15.7238874Z" }] ```

**CloudEvents v1.0 schema — a single JSON object** with `specversion`, `type`, `source`, `id`, `time`, `subject`, `data`. Normalise both: `eventType`→`type`, `eventTime`→`time`, `topic`→`source`.

## Event Types

Event Grid is a broker: **most event types belong to the publishing service or to a custom topic whose publisher defines them**, not to Event Grid itself.

Emitted by the `Microsoft.EventGrid` resource provider:

| Event type | Data | |-----------|------| | `Microsoft.EventGrid.SubscriptionValidationEvent` | `validationCode`, `validationUrl` | | `Microsoft.EventGrid.SubscriptionDeletedEvent` | `eventSubscriptionId` | | `Microsoft.EventGrid.MQTTClientCreatedOrUpdated` | Event Grid Namespaces / MQTT broker | | `Microsoft.EventGrid.MQTTClientDeleted` | Event Grid Namespaces / MQTT broker | | `Microsoft.EventGrid.MQTTClientSessionConnected` | Event Grid Namespaces / MQTT broker | | `Microsoft.EventGrid.MQTTClientSessionDisconnected` | Event Grid Namespaces / MQTT broker |

Representative publisher event types (attributed to their publisher): `Microsoft.Storage.BlobCreated`, `Microsoft.Storage.BlobDeleted` (Azure Blob Storage); `Microsoft.Resources.ResourceWriteSuccess`, `Microsoft.Resources.ResourceDeleteSuccess`, `Microsoft.Resources.ResourceActionSuccess` (Azure subscription / resource group). See [references/overview.md](references/overview.md).

## Delivery Semantics

- **HTTPS only.** *"Event Grid supports only HTTPS webhook endpoints."* - **Success codes — only these**: `200`, `201`, `202`, `203`, `204`. Everything outside 200–204 is a failure. (Note the contrast with the validation handshake, where **202 is explicitly not accepted**.) - **30-second timeout.** Exceeding it queues the message for retry — ack fast, process asynchronously. - **Not retried for webhooks**: 400, 401, 403, 413. - **Backoff**: 10s, 30s, 1m, 5m, 10m, 30m, 1h, 3h, 6h, then every 12h up to 24h. - **At-least-once, unordered.** Duplicates happen — **dedu