# 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](https://github.com/hookdeck/webhook-skills/blob/main/skills/azure-event-grid-webhooks/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](https://github.com/hookdeck/webhook-skills/blob/main/skills/azure-event-grid-webhooks/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/](https://github.com/hookdeck/webhook-skills/tree/main/skills/azure-event-grid-webhooks/examples/express/), [examples/nextjs/](https://github.com/hookdeck/webhook-skills/tree/main/skills/azure-event-grid-webhooks/examples/nextjs/), [examples/fastapi/](https://github.com/hookdeck/webhook-skills/tree/main/skills/azure-event-grid-webhooks/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](https://github.com/hookdeck/webhook-skills/blob/main/skills/azure-event-grid-webhooks/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 — dedupe on the event `id`
  and treat `aeg-delivery-count > 1` as a retry.
* Retry policy: 1–30 attempts (default 30); TTL 1–1440 minutes (default 1440).

## Environment Variables

```bash
# Event subscription names you expect (comma-separated). Compared against the
# aeg-subscription-name header. Required to complete the validation handshake.
AZURE_EVENT_GRID_SUBSCRIPTION_NAMES=my-webhook-subscription

# Shared secret delivered as a static delivery property (custom header).
# Never use the reserved `aeg-` prefix for the header name.
AZURE_EVENT_GRID_DELIVERY_SECRET_HEADER=x-eventgrid-token
AZURE_EVENT_GRID_DELIVERY_SECRET=

# OR: client secret carried in a query parameter of the endpoint URL.
# Comma-separate to accept BOTH old and new secrets during rotation.
AZURE_EVENT_GRID_QUERY_SECRET_PARAM=token
AZURE_EVENT_GRID_QUERY_SECRET=

# OR: Microsoft Entra ID protected endpoint (bearer token in Authorization)
AZURE_EVENT_GRID_ENTRA_TENANT_ID=
AZURE_EVENT_GRID_ENTRA_AUDIENCE=

# CloudEvents OPTIONS preflight: allowed WebHook-Request-Origin values
AZURE_EVENT_GRID_ALLOWED_ORIGINS=*
AZURE_EVENT_GRID_ALLOWED_RATE=120

# Local development escape hatch only — never in production
AZURE_EVENT_GRID_ALLOW_UNAUTHENTICATED=false

```

There is no signing secret here; nothing above is an HMAC key. The examples
fail closed: with no delivery secret, no query secret and no Entra config they reject every
request until `AZURE_EVENT_GRID_ALLOW_UNAUTHENTICATED=true` is set explicitly.

## Local Development

```bash
# Start tunnel (no account needed)
npx hookdeck-cli listen 3000 azure-event-grid --path /webhooks/azure-event-grid

```

Use the printed HTTPS URL as the event subscription's endpoint. Notes:

* Self-signed certificates are not supported for validation — a CA-signed
  certificate is required. A tunnel gives you one.
* If you return 200 without echoing the code, the subscription goes to
  `AwaitingManualAction`: GET the `validationUrl` within 10 minutes or the
  state becomes `Failed` and you must recreate the subscription. That URL uses
  port 553 — firewalls blocking 553 break the manual handshake.

## Reference Materials

* [references/overview.md](https://github.com/hookdeck/webhook-skills/blob/main/skills/azure-event-grid-webhooks/references/overview.md) - Event Grid concepts, event types by publisher, payload shapes, delivery semantics
* [references/setup.md](https://github.com/hookdeck/webhook-skills/blob/main/skills/azure-event-grid-webhooks/references/setup.md) - Create the topic and event subscription (portal + Azure CLI), delivery properties, Entra ID
* [references/verification.md](https://github.com/hookdeck/webhook-skills/blob/main/skills/azure-event-grid-webhooks/references/verification.md) - Both handshakes, channel authentication, Entra JWT validation, gotchas